image.png

05 Gateway网关.png
06 Gateway实现负载均衡.png

一、网关基本概念

1、API网关介绍

API 网关出现的原因是微服务架构的出现，不同的微服务一般会有不同的网络地址，而外部客户端可能需要调用多个服务的接口才能完成一个业务需求，如果让客户端直接与各个微服务通信，会有以下的问题：
（1）客户端会多次请求不同的微服务，增加了客户端的复杂性。
（2）存在跨域请求，在一定场景下处理相对复杂。
（3）认证复杂，每个服务都需要独立认证。
（4）难以重构，随着项目的迭代，可能需要重新划分微服务。例如，可能将多个服务合并成一个或者将一个服务拆分成多个。如果客户端直接与微服务通信，那么重构将会很难实施。
（5）某些微服务可能使用了防火墙 / 浏览器不友好的协议，直接访问会有一定的困难。
以上这些问题可以借助 API 网关解决。API 网关是介于客户端和服务器端之间的中间层，所有的外部请求都会先经过 API 网关这一层。也就是说，API 的实现方面更多的考虑业务逻辑，而安全、性能、监控可以交由 API 网关来做，这样既提高业务灵活性又不缺安全性

2、Spring Cloud Gateway

Spring cloud gateway是spring官方基于Spring 5.0、Spring Boot2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供简单、有效和统一的API路由管理方式，Spring Cloud Gateway作为Spring Cloud生态系统中的网关，目标是替代Netflix Zuul，其不仅提供统一的路由方式，并且还基于Filer链的方式提供了网关基本的功能，例如：安全、监控/埋点、限流等。
10fde967-d265-42b9-b023-a735963b0205.jpg

3、Spring Cloud Gateway核心概念

网关提供API全托管服务，丰富的API管理功能，辅助企业管理大规模的API，以降低管理成本和安全风险，包括协议适配、协议转发、安全策略、防刷、流量、监控日志等贡呢。一般来说网关对外暴露的URL或者接口信息，我们统称为路由信息。如果研发过网关中间件或者使用过Zuul的人，会知道网关的核心是Filter以及Filter Chain（Filter责任链）。Sprig Cloud Gateway也具有路由和Filter的概念。下面介绍一下Spring Cloud Gateway中几个重要的概念。
（1）路由。路由是网关最基础的部分，路由信息有一个ID、一个目的URL、一组断言和一组Filter组成。如果断言路由为真，则说明请求的URL和配置匹配
（2）断言。Java8中的断言函数。Spring Cloud Gateway中的断言函数输入类型是Spring5.0框架中的ServerWebExchange。Spring Cloud Gateway中的断言函数允许开发者去定义匹配来自于http request中的任何信息，比如请求头和参数等。
（3）过滤器。一个标准的Spring webFilter。Spring cloud gateway中的filter分为两种类型的Filter，分别是Gateway Filter和Global Filter。过滤器Filter将会对请求和响应进行修改处理
a3cb663f-16f5-4133-b091-1b92035b57ce.jpg
如上图所示，Spring cloud Gateway发出请求。然后再由Gateway Handler Mapping中找到与请求相匹配的路由，将其发送到Gateway web handler。Handler再通过指定的过滤器链将请求发送到我们实际的服务执行业务逻辑，然后返回。

二、创建api-gateway模块（网关服务）


1、在infrastructure模块下创建api_gateway模块

2537b086-dc28-44d0-8580-2521d2c0b33d.png

2、在pom.xml引入依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.atguigu</groupId>
  4.         <artifactId>common_utils</artifactId>
  5.         <version>0.0.1-SNAPSHOT</version>
  6.     </dependency>
  8.     <dependency>
  9.         <groupId>org.springframework.cloud</groupId>
  10.         <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  11.     </dependency>
  13.     <dependency>
  14.         <groupId>org.springframework.cloud</groupId>
  15.         <artifactId>spring-cloud-starter-gateway</artifactId>
  16.     </dependency>
  18.     <!--gson-->
  19.     <dependency>
  20.         <groupId>com.google.code.gson</groupId>
  21.         <artifactId>gson</artifactId>
  22.     </dependency>
  24.     <!--服务调用-->
  25.     <dependency>
  26.         <groupId>org.springframework.cloud</groupId>
  27.         <artifactId>spring-cloud-starter-openfeign</artifactId>
  28.     </dependency>
  29. </dependencies>

3、编写application.properties配置文件

  1. # 服务端口
  2. server.port=8222
  3. # 服务名
  4. spring.application.name=service-gateway
  6. # nacos服务地址
  7. spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
  9. #使用服务发现路由
  10. spring.cloud.gateway.discovery.locator.enabled=true
  11. #服务路由名小写
  12. #spring.cloud.gateway.discovery.locator.lower-case-service-id=true
  14. #设置路由id
  15. spring.cloud.gateway.routes[0].id=service-acl
  16. #设置路由的uri
  17. spring.cloud.gateway.routes[0].uri=lb://service-acl
  18. #设置路由断言,代理servicerId为auth-service的/auth/路径
  19. spring.cloud.gateway.routes[0].predicates= Path=/*/acl/**
  21. #配置service-edu服务
  22. spring.cloud.gateway.routes[1].id=service-edu
  23. spring.cloud.gateway.routes[1].uri=lb://service-edu
  24. spring.cloud.gateway.routes[1].predicates= Path=/eduservice/**
  26. #配置service-ucenter服务
  27. spring.cloud.gateway.routes[2].id=service-ucenter
  28. spring.cloud.gateway.routes[2].uri=lb://service-ucenter
  29. spring.cloud.gateway.routes[2].predicates= Path=/ucenterservice/**
  31. #配置service-ucenter服务
  32. spring.cloud.gateway.routes[3].id=service-cms
  33. spring.cloud.gateway.routes[3].uri=lb://service-cms
  34. spring.cloud.gateway.routes[3].predicates= Path=/cmsservice/**
  36. spring.cloud.gateway.routes[4].id=service-msm
  37. spring.cloud.gateway.routes[4].uri=lb://service-msm
  38. spring.cloud.gateway.routes[4].predicates= Path=/edumsm/**
  40. spring.cloud.gateway.routes[5].id=service-order
  41. spring.cloud.gateway.routes[5].uri=lb://service-order
  42. spring.cloud.gateway.routes[5].predicates= Path=/orderservice/**
  44. spring.cloud.gateway.routes[6].id=service-order
  45. spring.cloud.gateway.routes[6].uri=lb://service-order
  46. spring.cloud.gateway.routes[6].predicates= Path=/orderservice/**
  48. spring.cloud.gateway.routes[7].id=service-oss
  49. spring.cloud.gateway.routes[7].uri=lb://service-oss
  50. spring.cloud.gateway.routes[7].predicates= Path=/eduoss/**
  52. spring.cloud.gateway.routes[8].id=service-statistic
  53. spring.cloud.gateway.routes[8].uri=lb://service-statistic
  54. spring.cloud.gateway.routes[8].predicates= Path=/staservice/**
  56. spring.cloud.gateway.routes[9].id=service-vod
  57. spring.cloud.gateway.routes[9].uri=lb://service-vod
  58. spring.cloud.gateway.routes[9].predicates= Path=/eduvod/**
  60. spring.cloud.gateway.routes[10].id=service-edu
  61. spring.cloud.gateway.routes[10].uri=lb://service-edu
  62. spring.cloud.gateway.routes[10].predicates= Path=/eduuser/**

yml文件：

  1. server:
  2.   port: 8222
  4. spring:
  5.   application:
  6.   cloud:
  7.     gateway:
  8.       discovery:
  9.         locator:
  10.           enabled: true
  11.       routes:
  12.       - id: SERVICE-ACL
  13.         uri: lb://SERVICE-ACL
  14.         predicates:
  15.         - Path=/*/acl/** # 路径匹配
  16.       - id: SERVICE-EDU
  17.         uri: lb://SERVICE-EDU
  18.         predicates:
  19.         - Path=/eduservice/** # 路径匹配
  20.       - id: SERVICE-UCENTER
  21.         uri: lb://SERVICE-UCENTER
  22.         predicates:
  23.         - Path=/ucenter/** # 路径匹配
  24.     nacos:
  25.       discovery:
  26.         server-addr: 127.0.0.1:8848

4、编写启动类

  1. @SpringBootApplication
  2. public class ApiGatewayApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(ApiGatewayApplication.class, args);
  5.     }
  6. }

三、网关相关配置

1、网关解决跨域问题

（1）创建配置类

25718906-9518-4e35-9848-d2f10c079389.png

  1. @Configuration
  2. public class CorsConfig {
  3.     @Bean
  4.     public CorsWebFilter corsFilter() {
  5.         CorsConfiguration config = new CorsConfiguration();
  6.         config.addAllowedMethod("*");
  7.         config.addAllowedOrigin("*");
  8.         config.addAllowedHeader("*");
  10.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
  11.         source.registerCorsConfiguration("/**", config);
  13.         return new CorsWebFilter(source);
  14.     }
  15. }

2、全局Filter，统一处理会员登录与外部不允许访问的服务

fb0f4296-96e9-4141-a1f5-52e69f1929b8.png

  1. import com.google.gson.JsonObject;
  2. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  3. import org.springframework.cloud.gateway.filter.GlobalFilter;
  4. import org.springframework.core.Ordered;
  5. import org.springframework.core.io.buffer.DataBuffer;
  6. import org.springframework.http.server.reactive.ServerHttpRequest;
  7. import org.springframework.http.server.reactive.ServerHttpResponse;
  8. import org.springframework.stereotype.Component;
  9. import org.springframework.util.AntPathMatcher;
  10. import org.springframework.web.server.ServerWebExchange;
  11. import reactor.core.publisher.Mono;
  13. import java.nio.charset.StandardCharsets;
  14. import java.util.List;
  16. /**
  17.  * <p>
  18.  * 全局Filter，统一处理会员登录与外部不允许访问的服务
  19.  * </p>
  20.  */
  21. @Component
  22. public class AuthGlobalFilter implements GlobalFilter, Ordered {
  24.     private AntPathMatcher antPathMatcher = new AntPathMatcher();
  26.     @Override
  27.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  28.         ServerHttpRequest request = exchange.getRequest();
  29.         String path = request.getURI().getPath();
  30.         //谷粒学院api接口，校验用户必须登录
  31.         if(antPathMatcher.match("/api/**/auth/**", path)) {
  32.             List<String> tokenList = request.getHeaders().get("token");
  33.             if(null == tokenList) {
  34.                 ServerHttpResponse response = exchange.getResponse();
  35.                 return out(response);
  36.             } else {
  37. //                Boolean isCheck = JwtUtils.checkToken(tokenList.get(0));
  38. //                if(!isCheck) {
  39.                     ServerHttpResponse response = exchange.getResponse();
  40.                     return out(response);
  41. //                }
  42.             }
  43.         }
  44.         //内部服务接口，不允许外部访问
  45.         if(antPathMatcher.match("/**/inner/**", path)) {
  46.             ServerHttpResponse response = exchange.getResponse();
  47.             return out(response);
  48.         }
  49.         return chain.filter(exchange);
  50.     }
  52.     @Override
  53.     public int getOrder() {
  54.         return 0;
  55.     }
  57.     private Mono<Void> out(ServerHttpResponse response) {
  58.         JsonObject message = new JsonObject();
  59.         message.addProperty("success", false);
  60.         message.addProperty("code", 28004);
  61.         message.addProperty("data", "鉴权失败");
  62.         byte[] bits = message.toString().getBytes(StandardCharsets.UTF_8);
  63.         DataBuffer buffer = response.bufferFactory().wrap(bits);
  64.         //response.setStatusCode(HttpStatus.UNAUTHORIZED);
  65.         //指定编码，否则在浏览器中会中文乱码
  66.         response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
  67.         return response.writeWith(Mono.just(buffer));
  68.     }
  69. }

3、自定义异常处理

服务网关调用服务时可能会有一些异常或服务不可用，它返回错误信息不友好，需要我们覆盖处理
6205ef83-361e-4864-92ed-1727edbab720.png

ErrorHandlerConfig：

  1. import org.springframework.beans.factory.ObjectProvider;
  2. import org.springframework.boot.autoconfigure.web.ResourceProperties;
  3. import org.springframework.boot.autoconfigure.web.ServerProperties;
  4. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  5. import org.springframework.boot.web.reactive.error.ErrorAttributes;
  6. import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.core.Ordered;
  11. import org.springframework.core.annotation.Order;
  12. import org.springframework.http.codec.ServerCodecConfigurer;
  13. import org.springframework.web.reactive.result.view.ViewResolver;
  15. import java.util.Collections;
  16. import java.util.List;
  18. /**
  19.  * 覆盖默认的异常处理
  20.  *
  21.  */
  22. @Configuration
  23. @EnableConfigurationProperties({ServerProperties.class, ResourceProperties.class})
  24. public class ErrorHandlerConfig {
  26.     private final ServerProperties serverProperties;
  28.     private final ApplicationContext applicationContext;
  30.     private final ResourceProperties resourceProperties;
  32.     private final List<ViewResolver> viewResolvers;
  34.     private final ServerCodecConfigurer serverCodecConfigurer;
  36.     public ErrorHandlerConfig(ServerProperties serverProperties,
  37.                                      ResourceProperties resourceProperties,
  38.                                      ObjectProvider<List<ViewResolver>> viewResolversProvider,
  39.                                         ServerCodecConfigurer serverCodecConfigurer,
  40.                                      ApplicationContext applicationContext) {
  41.         this.serverProperties = serverProperties;
  42.         this.applicationContext = applicationContext;
  43.         this.resourceProperties = resourceProperties;
  44.         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
  45.         this.serverCodecConfigurer = serverCodecConfigurer;
  46.     }
  48.     @Bean
  49.     @Order(Ordered.HIGHEST_PRECEDENCE)
  50.     public ErrorWebExceptionHandler errorWebExceptionHandler(ErrorAttributes errorAttributes) {
  51.         JsonExceptionHandler exceptionHandler = new JsonExceptionHandler(
  52.                 errorAttributes,
  53.                 this.resourceProperties,
  54.                 this.serverProperties.getError(),
  55.                 this.applicationContext);
  56.         exceptionHandler.setViewResolvers(this.viewResolvers);
  57.         exceptionHandler.setMessageWriters(this.serverCodecConfigurer.getWriters());
  58.         exceptionHandler.setMessageReaders(this.serverCodecConfigurer.getReaders());
  59.         return exceptionHandler;
  60.     }
  61. }

JsonExceptionHandler：

  1. import org.springframework.boot.autoconfigure.web.ErrorProperties;
  2. import org.springframework.boot.autoconfigure.web.ResourceProperties;
  3. import org.springframework.boot.autoconfigure.web.reactive.error.DefaultErrorWebExceptionHandler;
  4. import org.springframework.boot.web.reactive.error.ErrorAttributes;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.web.reactive.function.server.*;
  9. import java.util.HashMap;
  10. import java.util.Map;
  12. /**
  13.  * 自定义异常处理
  14.  *
  15.  * <p>异常时用JSON代替HTML异常信息<p>
  16.  *
  17.  */
  18. public class JsonExceptionHandler extends DefaultErrorWebExceptionHandler {
  20.     public JsonExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties,
  21.                                 ErrorProperties errorProperties, ApplicationContext applicationContext) {
  22.         super(errorAttributes, resourceProperties, errorProperties, applicationContext);
  23.     }
  25.     /**
  26.      * 获取异常属性
  27.      */
  28.     @Override
  29.     protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
  30.         Map<String, Object> map = new HashMap<>();
  31.         map.put("success", false);
  32.         map.put("code", 20005);
  33.         map.put("message", "网关失败");
  34.         map.put("data", null);
  35.         return map;
  36.     }
  38.     /**
  39.      * 指定响应处理方法为JSON处理的方法
  40.      * @param errorAttributes
  41.      */
  42.     @Override
  43.     protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
  44.         return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
  45.     }
  47.     /**
  48.      * 根据code获取对应的HttpStatus
  49.      * @param errorAttributes
  50.      */
  51.     @Override
  52.     protected HttpStatus getHttpStatus(Map<String, Object> errorAttributes) {
  53.         return HttpStatus.OK;
  54.     }
  55. }