微服务--熟练把握网关（包罗权限认证）

目次
一、网关的路由
二、网关登录的校验
2.1.鉴权思绪分析
2.2.网关过滤器
2.3 自界说过滤器
2.3.1 自界说GatewayFilter
2.3.2 自界说GlobalFilter
2.4 登陆校验
具体的实现步调：
一、在微服务中，我们在微服务的网关模块，就要进行验证。对请求的信息进行剖析。
二、拦截器获取用户
三、OpenFeign通报用户​编辑

---

问题：我们把单体项目划分为多个微服务，在微服务之间的端口号不同，服务的名称也不同，在与前端联调的时候我们会发现一些问题。对于请求不同的数据要访问不同的入口，需要维护多个端口地址，前端无法调用nacos，无法实现更新的服务列表。我们应该怎么处置惩罚?
带着问题学习：
对于登录校验，我们只需要完成一次登录、身份校验就可以在所以的业务中获取用户的信息。而微服务拆分后，每个微服务都独立部署，这就存在一些问题？

• 每个微服务都需要编写登录校验、用户信息的获取功能吗？
  
• 当微服务之间调用时，该假如通报用户的信息？
  

通过本日的学习你将把握下列能力：

• 会利用微服务网关做请求路由
  
• 会利用微服务网关做登录身份校验
  
• 会利用Nacos实现统一配置管理
  
• 会利用Nacos实现配置热更新
  

• 第一章：网关路由，解决前端请求入口的问题。
  
• 第二章：网关鉴权，解决统一登录校验和用户信息获取的问题。
  
• 第三章：统一配置管理，解决微服务的配置文件重复和配置热更新问题。
  

好了，接下来我们就一起进入本日的学习吧。
一、网关的路由

1.1  什么是网关？网关就是负责数据的路由和转发以及数据安全的校验。
        他就像是小区门口的大爷，当你告诉大爷，你需要找谁，大爷会对你的身份进行验证，验证成功后，大爷会帮你带路，找到你需要找的人。

• 网关可以做安全控制，也就是登录身份校验，校验通过才放行
  
• 通过认证后，网关再根据请求判定应该访问哪个微服务，将请求转发过去
  

对于的网站：https://spring.io/projects/spring-cloud-gateway#learn
1.2 网关的快速入门

• 创建网关微服务
  
• 引入SpringCloudGateway、NacosDiscovery依赖
  
• 编写启动类
  
• 配置网关路由
  

(1)在微服务中创建一个模块，在模块中写添加对应的依赖

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <parent>
6.         <artifactId>hmall</artifactId>
7.         <groupId>com.heima</groupId>
8.         <version>1.0.0</version>
9.     </parent>
10.     <modelVersion>4.0.0</modelVersion>
12.     <artifactId>hm-gateway</artifactId>
14.     <properties>
15.         <maven.compiler.source>11</maven.compiler.source>
16.         <maven.compiler.target>11</maven.compiler.target>
17.     </properties>
18.     <dependencies>
19.       
20.         <!--网关-->
21.         <dependency>
22.             <groupId>org.springframework.cloud</groupId>
23.             <artifactId>spring-cloud-starter-gateway</artifactId>
24.         </dependency>
25.         <!--nacos discovery-->
26.         <dependency>
27.             <groupId>com.alibaba.cloud</groupId>
28.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
29.         </dependency>
30.         <!--负载均衡-->
31.         <dependency>
32.             <groupId>org.springframework.cloud</groupId>
33.             <artifactId>spring-cloud-starter-loadbalancer</artifactId>
34.         </dependency>
35.     </dependencies>
36.     <build>
37.         <finalName>${project.artifactId}</finalName>
38.         <plugins>
39.             <plugin>
40.                 <groupId>org.springframework.boot</groupId>
41.                 <artifactId>spring-boot-maven-plugin</artifactId>
42.             </plugin>
43.         </plugins>
44.     </build>
45. </project>

复制代码

(2)编写启动类
(3)配置对应的网关路由 (端口号，名称，网关路由)

1. server:
2.   port: 8080
3. spring:
4.   application:
5.     name: gateway
6.   cloud:
7.     nacos:
8.       server-addr: 192.168.150.101:8848
9.     gateway:
10.       routes:
11.         - id: item # 路由规则id，自定义，唯一
12.           uri: lb://item-service # 路由的目标服务，lb代表负载均衡，会从注册中心拉取服务列表
13.           predicates: # 路由断言，判断当前请求是否符合当前规则，符合则路由到目标服务
14.             - Path=/items/**,/search/** # 这里是以请求路径作为判断规则
15.         - id: cart
16.           uri: lb://cart-service
17.           predicates:
18.             - Path=/carts/**
19.         - id: user
20.           uri: lb://user-service
21.           predicates:
22.             - Path=/users/**,/addresses/**
23.         - id: trade
24.           uri: lb://trade-service
25.           predicates:
26.             - Path=/orders/**
27.         - id: pay
28.           uri: lb://pay-service
29.           predicates:
30.             - Path=/pay-orders/**

复制代码

1.3 路由的过滤规则

1. spring:
2.   cloud:
3.     gateway:
4.       routes:
5.         - id: item
6.           uri: lb://item-service
7.           predicates:
8.             - Path=/items/**,/search/**

复制代码

• id：路由的唯一标示
  
• predicates：路由断言，其实就是匹配条件
  
• filters：路由过滤条件，后面讲
  
• uri：路由目标地址，lb://代表负载均衡，从注册中心获取目标微服务的实例列表，而且负载均衡选择一个访问。
  

这里我们重点关注predicates，也就是路由断言。SpringCloudGateway中支持的断言范例有很多：
  名称
  阐明
  示例
  After
  是某个时间点后的请求
  - After=2037-01-20T17:42:47.789-07:00[America/Denver]
  Before
  是某个时间点之前的请求
  - Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai]

  Between
  是某两个时间点之前的请求
  - Between=2037-01-20T17:42:47.789-07:00[America/Denver], 2037-01-21T17:42:47.789-07:00[America/Denver]
  Cookie
  请求必须包含某些cookie
  - Cookie=chocolate, ch.p
  Header
  请求必须包含某些header
  - Header=X-Request-Id, \d+
  Host
  请求必须是访问某个host（域名）
  - Host=**.somehost.org,**.anotherhost.org
  Method
  请求方式必须是指定方式
  - Method=GET,POST
  Path
  请求路径必须符合指定规则
  - Path=/red/{segment},/blue/**
  Query
  请求参数必须包含指定参数
  - Query=name, Jack或者- Query=name
  RemoteAddr
  请求者的ip必须是指定范围
  - RemoteAddr=192.168.1.1/24
  weight
  权重处置惩罚
  
  二、网关登录的校验

单体架构时我们只需要完成一次用户登录、身份校验，就可以在所有业务中获取到用户信息。而微服务拆分后，每个微服务都独立部署，不再共享数据。也就意味着每个微服务都需要做登录校验，这显然不可取。
2.1.鉴权思绪分析

我们的登录是基于JWT来实现的，校验JWT的算法复杂，而且需要用到秘钥。假如每个微服务都去做登录校验，这就存在着两大问题：

• 每个微服务都需要知道JWT的秘钥，不安全
  
• 每个微服务重复编写登录校验代码、权限校验代码，麻烦
  

既然网关是所有微服务的入口，统统请求都需要先经过网关。我们完全可以把登录校验的工作放到网关去做，这样之前说的问题就解决了：

• 只需要在网关和用户服务生存秘钥
  
• 只需要在网关开辟登录校验功能
  

此时，登录校验的流程如图：

不过，这里存在几个问题：

• 网关路由是配置的，请求转发是Gateway内部代码，我们如安在转发之前做登录校验？
  
• 网关校验JWT之后，如何将用户信息通报给微服务？
  
• 微服务之间也会相互调用，这种调用不经过网关，又该如何通报用户信息？
  

2.2.网关过滤器

登录校验必须在请求转发到微服务之前做，否则就失去了意义。而网关的请求转发是Gateway内部代码实现的，要想在请求转发之前做登录校验，就必须了解Gateway内部工作的基本原理。

如图所示：

• 客户端请求进入网关后由HandlerMapping对请求做判定，找到与当前请求匹配的路由规则（Route），然后将请求交给WebHandler去处置惩罚。
  
• WebHandler则会加载当前路由下需要实验的过滤器链（Filter chain），然后按照顺序逐一实验过滤器（后面称为Filter）。
  
• 图中Filter被虚线分为左右两部分，是由于Filter内部的逻辑分为pre和post两部分，分别会在请求路由到微服务之前和之后被实验。
  
• 只有所有Filter的pre逻辑都依次顺序实验通过后，请求才会被路由到微服务。
  
• 微服务返回结果后，再倒序实验Filter的post逻辑。
  
• 最终把响应结果返回。
  

如图中所示，最终请求转发是有一个名为NettyRoutingFilter的过滤器来实验的，而且这个过滤器是整个过滤器链中顺序最靠后的一个。假如我们可以或许界说一个过滤器，在其中实现登录校验逻辑，而且将过滤器实验顺序界说到NettyRoutingFilter之前，这就符合我们的需求了！
那么，该如何实现一个网关过滤器呢？
网关过滤器链中的过滤器有两种：

• GatewayFilter：路由过滤器，作用范围比较灵活，可以是任意指定的路由Route.
  
• GlobalFilter：全局过滤器，作用范围是所有路由，不可配置。
  

其实GatewayFilter和GlobalFilter这两种过滤器的方法签名完全一致：

1. /**
2. * 处理请求并将其传递给下一个过滤器
3. * @param exchange 当前请求的上下文，其中包含request、response等各种数据
4. * @param chain 过滤器链，基于它向下传递请求
5. * @return 根据返回值标记当前请求是否被完成或拦截，chain.filter(exchange)就放行了。
6. */
7. Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);

复制代码

FilteringWebHandler在处置惩罚请求时，会将GlobalFilter装饰为GatewayFilter，然后放到同一个过滤器链中，排序以后依次实验。
Gateway中内置了很多的GatewayFilter，详情可以参考官方文档：
https://docs.spring.io/spring-cloud-gateway/docs/3.1.7/reference/html/#gatewayfilter-factories
Gateway内置的GatewayFilter过滤器利用起来非常简朴，无需编码，只要在yaml文件中简朴配置即可。而且其作用范围也很灵活，配置在哪个Route下，就作用于哪个Route.
例如，有一个过滤器叫做AddRequestHeaderGatewayFilterFacotry，顾明思议，就是添加请求头的过滤器，可以给请求添加一个请求头并通报到下游微服务。
利用的利用只需要在application.yaml中这样配置：

1. spring:
2.   cloud:
3.     gateway:
4.       routes:
5.       - id: test_route
6.         uri: lb://test-service
7.         predicates:
8.           -Path=/test/**
9.         filters:
10.           - AddRequestHeader=key, value # 逗号之前是请求头的key，逗号之后是value

复制代码

假如想要让过滤器作用于所有的路由，则可以这样配置：

1. spring:
2.   cloud:
3.     gateway:
4.       default-filters: # default-filters下的过滤器可以作用于所有路由
5.         - AddRequestHeader=key, value
6.       routes:
7.       - id: test_route
8.         uri: lb://test-service
9.         predicates:
10.           -Path=/test/**

复制代码

2.3 自界说过滤器

无论是GatewayFilter还是GlobalFilter都支持自界说，只不过编码方式、利用方式略有差异。
2.3.1 自界说GatewayFilter

自界说GatewayFilter不是直接实现GatewayFilter，而是实现AbstractGatewayFilterFactory。最简朴的方式是这样的：

1. @Component
2. public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
3.     @Override
4.     public GatewayFilter apply(Object config) {
5.         return new GatewayFilter() {
6.             @Override
7.             public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
8.                 // 获取请求
9.                 ServerHttpRequest request = exchange.getRequest();
10.                 // 编写过滤器逻辑
11.                 System.out.println("过滤器执行了");
12.                 // 放行
13.                 return chain.filter(exchange);
14.             }
15.         };
16.     }
17. }

复制代码

  注意：该类的名称肯定要以GatewayFilterFactory为后缀！
   然后在yaml配置中这样利用：

1. spring:
2.   cloud:
3.     gateway:
4.       default-filters:
5.             - PrintAny # 此处直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器

复制代码

别的，这种过滤器还可以支持动态配置参数，不过实现起来比较复杂，示例：

2. @Component
3. public class PrintAnyGatewayFilterFactory // 父类泛型是内部类的Config类型
4.                 extends AbstractGatewayFilterFactory<PrintAnyGatewayFilterFactory.Config> {
6.     @Override
7.     public GatewayFilter apply(Config config) {
8.         // OrderedGatewayFilter是GatewayFilter的子类，包含两个参数：
9.         // - GatewayFilter：过滤器
10.         // - int order值：值越小，过滤器执行优先级越高
11.         return new OrderedGatewayFilter(new GatewayFilter() {
12.             @Override
13.             public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
14.                 // 获取config值
15.                 String a = config.getA();
16.                 String b = config.getB();
17.                 String c = config.getC();
18.                 // 编写过滤器逻辑
19.                 System.out.println("a = " + a);
20.                 System.out.println("b = " + b);
21.                 System.out.println("c = " + c);
22.                 // 放行
23.                 return chain.filter(exchange);
24.             }
25.         }, 100);
26.     }
28.     // 自定义配置属性，成员变量名称很重要，下面会用到
29.     @Data
30.     static class Config{
31.         private String a;
32.         private String b;
33.         private String c;
34.     }
35.     // 将变量名称依次返回，顺序很重要，将来读取参数时需要按顺序获取
36.     @Override
37.     public List<String> shortcutFieldOrder() {
38.         return List.of("a", "b", "c");
39.     }
40.         // 返回当前配置类的类型，也就是内部的Config
41.     @Override
42.     public Class<Config> getConfigClass() {
43.         return Config.class;
44.     }
46. }

复制代码

然后在yaml文件中利用：

1. spring:
2.   cloud:
3.     gateway:
4.       default-filters:
5.             - PrintAny=1,2,3 # 注意，这里多个参数以","隔开，将来会按照shortcutFieldOrder()方法返回的参数顺序依次复制

复制代码

上面这种配置方式参数必须严酷按照shortcutFieldOrder()方法的返回参数名顺序来赋值。
还有一种用法，无需按照这个顺序，就是手动指定参数名：

1. spring:
2.   cloud:
3.     gateway:
4.       default-filters:
5.             - name: PrintAny
6.               args: # 手动指定参数名，无需按照参数顺序
7.                 a: 1
8.                 b: 2
9.                 c: 3

复制代码

2.3.2 自界说GlobalFilter

自界说GlobalFilter则简朴很多，直接实现GlobalFilter即可，而且也无法设置动态参数：

1. @Component
2. public class PrintAnyGlobalFilter implements GlobalFilter, Ordered {
3.     @Override
4.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
5.         // 编写过滤器逻辑
6.         System.out.println("未登录，无法访问");
7.         // 放行
8.         // return chain.filter(exchange);
10.         // 拦截
11.         ServerHttpResponse response = exchange.getResponse();
12.         response.setRawStatusCode(401);
13.         return response.setComplete();
14.     }
16.     @Override
17.     public int getOrder() {
18.         // 过滤器执行顺序，值越小，优先级越高
19.         return 0;
20.     }
21. }

复制代码

2.4 登陆校验

逻辑：
1.获取Request
2.判定是否需要拦截
3.获取请求头的tocken
4.校验而且剖析对应的token
5.假如有效获取用户的学习
6. 放行

具体的实现步调：

一、在微服务中，我们在微服务的网关模块，就要进行验证。对请求的信息进行剖析。

我们在网关服务中的filter包中界说一个AuthGlobalFilter的类：
代码如下：(生存用户到请求头中)

1. @Component
2. @RequiredArgsConstructor
3. @EnableConfigurationProperties(AuthProperties.class)
4. public class AuthGlobalFilter implements GlobalFilter, Ordered {
6.     private final JwtTool jwtTool;
8.     private final AuthProperties authProperties;
10.     private final AntPathMatcher antPathMatcher = new AntPathMatcher();
12.     @Override
13.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
14.         // 1.获取Request
15.         ServerHttpRequest request = exchange.getRequest();
16.         // 2.判断是否不需要拦截
17.         if(isExclude(request.getPath().toString())){
18.             // 无需拦截，直接放行
19.             return chain.filter(exchange);
20.         }
21.         // 3.获取请求头中的token
22.         String token = null;
23.         List<String> headers = request.getHeaders().get("authorization");
24.         if (!CollUtils.isEmpty(headers)) {
25.             token = headers.get(0);
26.         }
27.         // 4.校验并解析token
28.         Long userId = null;
29.         try {
30.             userId = jwtTool.parseToken(token);
31.         } catch (UnauthorizedException e) {
32.             // 如果无效，拦截
33.             ServerHttpResponse response = exchange.getResponse();
34.             response.setRawStatusCode(401);
35.             return response.setComplete();
36.         }
38.         //  5.如果有效，传递用户信息
39.         // System.out.println("userId = " + userId);
40.         String userInfo = userId.toString();
41.         ServerWebExchange ex = exchange.mutate()
42.                 .request(b->b.header("user-info",userInfo))
43.                 .build();
44.         
45.         // 6.放行
46.         return chain.filter(exchange);
47.     }
49.     private boolean isExclude(String antPath) {
50.         for (String pathPattern : authProperties.getExcludePaths()) {
51.             if(antPathMatcher.match(pathPattern, antPath)){
52.                 return true;
53.             }
54.         }
55.         return false;
56.     }
58.     @Override
59.     public int getOrder() {
60.         return 0;
61.     }
62. }

复制代码

二、拦截器获取用户

有个工具类生存登任命户的ThreadLocal工具：以及提供了生存和获取用户的方法

1. public class UserContext {
2.     private static final ThreadLocal<Long> tl = new ThreadLocal<>();
4.     /**
5.      * 保存当前登录用户信息到ThreadLocal
6.      * @param userId 用户id
7.      */
8.     public static void setUser(Long userId) {
9.         tl.set(userId);
10.     }
12.     /**
13.      * 获取当前登录用户信息
14.      * @return 用户id
15.      */
16.     public static Long getUser() {
17.         return tl.get();
18.     }
20.     /**
21.      * 移除当前登录用户信息
22.      */
23.     public static void removeUser(){
24.         tl.remove();
25.     }
26. }

复制代码

 由于每个微服务都需要获取登任命户的需求，利用拦截器直接卸载common包中：
在common包中界说一个interceptor包中界说一个UserInfoInterceptor:

1. public class UserInfoInterceptor implements HandlerInterceptor {
2.     @Override
3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
4.         // 1.获取请求头中的用户信息
5.         String userInfo = request.getHeader("user-info");
6.         // 2.判断是否为空
7.         if (StrUtil.isNotBlank(userInfo)) {
8.             // 不为空，保存到ThreadLocal
9.                 UserContext.setUser(Long.valueOf(userInfo));
10.         }
11.         // 3.放行
12.         return true;
13.     }
15.     @Override
16.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
17.         // 移除用户
18.         UserContext.removeUser();
19.     }
20. }

复制代码

在common中进行编写SpringMvc的配置类和配置登录的拦截器:
 在config包中创建一个MvcConfig：

1. @Configuration
2. @ConditionalOnClass(DispatcherServlet.class)
3. public class MvcConfig implements WebMvcConfigurer {
4.     @Override
5.     public void addInterceptors(InterceptorRegistry registry) {
6.         registry.addInterceptor(new UserInfoInterceptor());
7.     }
8. }

复制代码

不过，需要注意的是，这个配置类默认是不会见效的，由于它地点的包是com.hmall.common.config，与别的微服务的扫描包不一致，无法被扫描到，因此无法见效。
基于SpringBoot的自动装配原理，我们要将其添加到resources目次下的META-INF/spring.factories文件中：

1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
2.   com.hmall.common.config.MyBatisConfig,\
3.   com.hmall.common.config.MvcConfig

复制代码

三、OpenFeign通报用户

 
。但是，订单服务调用购物车时并没有通报用户信息，购物车服务无法知道当前用户是谁！
由于微服务获取用户信息是通过拦截器在请求头中读取，因此要想实现微服务之间的用户信息通报，就必须在微服务发起调用时把用户信息存入请求头。
这里要借助Feign中提供的一个拦截器接口：feign.RequestInterceptor

 

 在com.hmall.api.config.DefaultFeignConfig中添加一个Bean：

1. @Bean
2. public RequestInterceptor userInfoRequestInterceptor(){
3.     return new RequestInterceptor() {
4.         @Override
5.         public void apply(RequestTemplate template) {
6.             // 获取登录用户
7.             Long userId = UserContext.getUser();
8.             if(userId == null) {
9.                 // 如果为空则直接跳过
10.                 return;
11.             }
12.             // 如果不为空则放入请求头中，传递给下游微服务
13.             template.header("user-info", userId.toString());
14.         }
15.     };
16. }

复制代码

好了，如今微服务之间通过OpenFeign调用时也会通报登任命户信息了。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。