微服务框架（二）：网关路由、网关鉴权和配置管理

最新推荐文章于 2024-05-16 09:24:19 发布

ruuuler

最新推荐文章于 2024-05-16 09:24:19 发布

阅读量1.3k

点赞数 39

文章标签：微服务架构云原生

本文链接：https://blog.csdn.net/weixin_46302607/article/details/136334346

版权

网关是什么

数据在网络间传输，从一个网络传输到另一网络时就需要经过网关来做数据的路由和转发以及数据安全的校验。

如下图所示，前端需要先请求网关，再访问某个微服务，网关有安全控制，登录校验，还有路由转发，负载均衡的作用。
在这里插入图片描述

本文使用的网关实现方案是基于Spring的WebFlux技术，完全支持响应式编程，吞吐能力更强的SpringCloudGateway

网关使用

引入依赖

创建网关微服务，并且在pom.xml里引入SpringCloudGateway、NacosDiscovery依赖，并且和其他微服务一样，需要一个启动类。

<!--网关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos discovery-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

网关服务的启动类

package top.zhengru.hmall.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

配置路由

在application.yml里配置网关的路由，id是路由规则id，可以自定义且是唯一的，uri是路由的目标服务，lb代表负载均衡，会从注册中心拉取服务列表，predicates是路由断言，判断当前请求是否符合当前规则，符合则路由到目标服务，下面使用的是请求路径作为判断规则

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.88.188:8848
    gateway:
      routes:
        - id: item-service
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/**
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/addresses/**,/users/**
        - id: cart-service
          uri: lb://cart-service
          predicates:
            - Path=/carts/**
        - id: trade
          uri: lb://trade-service
          predicates:
            - Path=/orders/**
        - id: pay
          uri: lb://pay-service
          predicates:
            - Path=/pay-orders/**

路由断言

SpringCloudGateway中支持的断言类型也就是predicates有很多，以下是断言规则的说明

名称	说明	示例
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	权重处理

网关鉴权

实现思路

我们知道，网关是所有微服务的入口，一切请求都需要先经过网关。所以我们完全可以把登录校验的工作放到网关，并且只需要在网关和用户服务保存秘钥和开发登录校验的功能

网关工作原理

下面这张图是Gateway的内部工作原理，而我们需要在请求转发之前完成登录校验，这里值得注意的地方是只有所有Filter的pre逻辑都依次顺序执行通过后，请求才会被路由到微服务，并且微服务返回结果后，还会再倒序执行Filter的post逻辑。

在这里插入图片描述

从图中的过滤器链我们可以知道，请求转发是由过滤器链中最后一个过滤器NettyRoutingFilter实现的，而我们需要在此过滤器之前，完成登录校验的功能。

内置过滤器

Gateway存在内置的GatewayFilter过滤器。只要在yaml文件中简单配置即可，其作用范围就是配置在哪个Route下

例如，有一个过滤器叫做AddRequestHeaderGatewayFilterFacotry，顾明思议，就是添加请求头的过滤器，可以给请求添加一个请求头并传递到下游微服务。

spring:
  cloud:
    gateway:
      routes:
      - id: test_route
        uri: lb://test-service
        predicates:
          -Path=/test/**
        filters:
          - AddRequestHeader=key, value # 逗号之前是请求头的key，逗号之后是value

也可以使用default-filters来作用于所有的路由

spring:
  cloud:
    gateway:
      default-filters: # default-filters下的过滤器可以作用于所有路由
        - AddRequestHeader=key, value
      routes:
      - id: test_route
        uri: lb://test-service
        predicates:
          -Path=/test/**

自定义过滤器

网关过滤器链中的过滤器有两种：

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

自定义GatewayFilter

通过实现AbstractGatewayFilterFactory可以来实现最简单的过滤器，但是注意的是自定义过滤器的类名后缀必须是GatewayFilterFactory

@Component
public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
    @Override
    public GatewayFilter apply(Object config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 获取请求
                ServerHttpRequest request = exchange.getRequest();
                // 编写过滤器逻辑
                System.out.println("过滤器执行了");
                // 放行
                return chain.filter(exchange);
            }
        };
    }
}

然后需要在配置文件中添加这个过滤器

spring:
  cloud:
    gateway:
      default-filters:
            - PrintAny # 自定义的GatewayFilterFactory类名前缀

如果想要实现动态配置参数，可以像下面这样写，不过非常复杂


@Component
public class PrintAnyGatewayFilterFactory // 父类泛型是内部类的Config类型
                extends AbstractGatewayFilterFactory<PrintAnyGatewayFilterFactory.Config> {

    @Override
    public GatewayFilter apply(Config config) {
        // OrderedGatewayFilter是GatewayFilter的子类，包含两个参数：
        // - GatewayFilter：过滤器
        // - int order值：值越小，过滤器执行优先级越高
        return new OrderedGatewayFilter(new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 获取config值
                String a = config.getA();
                String b = config.getB();
                String c = config.getC();
                // 编写过滤器逻辑
                System.out.println("a = " + a);
                System.out.println("b = " + b);
                System.out.println("c = " + c);
                // 放行
                return chain.filter(exchange);
            }
        }, 100);
    }

    // 自定义配置属性，成员变量名称很重要，下面会用到
    @Data
    static class Config{
        private String a;
        private String b;
        private String c;
    }
    // 将变量名称依次返回，顺序很重要，将来读取参数时需要按顺序获取
    @Override
    public List<String> shortcutFieldOrder() {
        return List.of("a", "b", "c");
    }
        // 返回当前配置类的类型，也就是内部的Config
    @Override
    public Class<Config> getConfigClass() {
        return Config.class;
    }

}

配置文件如下，这种配置方式参数必须严格按照shortcutFieldOrder()方法的返回参数名顺序来赋值

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

还有一种用法，无需按照这个顺序

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

自定义GlobalGatewayFilter

刚刚提到了，除了路由过滤器之外，还有一个全局过滤器也就是GlobalGatewayFilter，这个过滤器实现GlobalFilter即可，十分简单

@Component
public class PrintAnyGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 编写过滤器逻辑
        System.out.println("未登录，无法访问");
        // 放行
        // return chain.filter(exchange);

        // 拦截
        ServerHttpResponse response = exchange.getResponse();
        response.setRawStatusCode(401);
        return response.setComplete();
    }

    @Override
    public int getOrder() {
        // 过滤器执行顺序，值越小，优先级越高
        return 0;
    }
}

登录校验

定义一个登录校验的过滤器叫做AuthGlobalFilter，并配置它在过滤器链中的顺序

注意，这里我们获取到用户信息后，会将它添加到请求头中，转发至微服务以便微服务能够获取用户信息

@Component
@RequiredArgsConstructor
@EnableConfigurationProperties(AuthProperties.class)
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final JwtTool jwtTool;

    private final AuthProperties authProperties;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取Request
        ServerHttpRequest request = exchange.getRequest();
        // 2.判断是否不需要拦截
        if(isExclude(request.getPath().toString())){
            // 无需拦截，直接放行
            return chain.filter(exchange);
        }
        // 3.获取请求头中的token
        String token = null;
        List<String> headers = request.getHeaders().get("authorization");
        if (!CollUtils.isEmpty(headers)) {
            token = headers.get(0);
        }
        // 4.校验并解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            // 如果无效，拦截
            ServerHttpResponse response = exchange.getResponse();
            response.setRawStatusCode(401);
            return response.setComplete();
        }

        // 5.如果有效，传递用户信息
        String userInfo = userId.toString();
        ServerWebExchange swe = exchange.mutate()
                .request(builder -> builder.header("user-info", userInfo))
                .build();
        // 6.放行
        return chain.filter(exchange);
    }

    private boolean isExclude(String antPath) {
        for (String pathPattern : authProperties.getExcludePaths()) {
            if(antPathMatcher.match(pathPattern, antPath)){
                return true;
            }
        }
        return false;
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

拦截用户信息

通过上面的过滤器，我们实现了在网关的登录校验，并且把用户信息放在了请求头里，但是微服务还需要获取请求头里的用户信息

所以，我们需要编写一个拦截器，获取用户信息并保存到UserContext，然后再放行，因为所有的微服务都引入了common模块，所以我们把拦截器写在common模块里

public class UserInfoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的用户信息
        String userInfo = request.getHeader("user-info");
        // 2.判断是否为空
        if (StrUtil.isNotBlank(userInfo)) {
            // 不为空，保存到ThreadLocal
                UserContext.setUser(Long.valueOf(userInfo));
        }
        // 3.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserContext.removeUser();
    }
}

然后再写一个配置类生效这个拦截器，注意，想要这个配置类生效，就需要这个类被Spring扫描到，又由于这里是common包，扫不到这里的配置类，想要在不同的包下的配置类生效，还需要在resource/META-INF定义一个spring.factories（早期文件名，不过现在也能生效）文件去记录这个配置类

@Configuration
@ConditionalOnClass(DispatcherServlet.class)
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

spring.factories内容如下

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.MvcConfig,\
  com.hmall.common.config.JsonConfig

这里还有一个比较有意思的点，按照这样配置之后，会发现报错

这里报错的原因是，因为网关微服务也引用了这个common模块，并且WebMvcConfigurer属于WebMvc包下的接口，但是网关的底层是基于WebFlux的非阻塞式响应式的编程，没有Mvc的包。而我们希望的是，这个配置类只在微服务里生效，但不在网关里生效，所以这里使用了SpringBoot自动装配的条件注解，@ConditionalOnClass就是判断一个类是否存在，那么就加上SpringMvc的核心API：DispatcherServlet作为条件，加上@ConditionalOnClass(DispatcherServlet.class)注解，问题就解决了。

OpenFeign传递用户

我们知道可以将用户信息送至第一个微服务，但如果微服务之间存在远程调用的情况，那么这个过程中用户信息就会丢失，因为远程调用是一次新的请求，但这个请求头不会携带用户信息，就会导致被调用的那个微服务获取不到用户信息。想要解决这个问题，必须在微服务发起调用时把用户信息存入请求头。

这里我们借助Feign中提供的一个拦截器接口：feign.RequestInterceptor，并且实现apply方法，利用RequestTemplate类来添加请求头，将用户信息保存到请求头中。

在api模块的DefaultFeignConfig里添加一个Bean

public class DefaultFeignConfig {
    @Bean
    public Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }

    @Bean
    public RequestInterceptor userInfoRequestInterceptor() {
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
                Long userId = UserContext.getUser();
                if (userId != null) {
                    requestTemplate.header("user-info", userId.toString());
                }
            }
        };
    }
}

这样就解决了微服务之间调用没有传递用户信息的问题

配置管理

在我们的项目中，网关路由和某些业务配置在配置文件中写死了，甚至还有重复，那么导致维护成本高，并且每次修改都需要重启微服务，这个问题可以通过统一的配置管理器服务解决。而Nacos不仅仅具备注册中心功能，也具备配置管理的功能：

在这里插入图片描述

微服务共享的配置可以统一交给Nacos保存和管理，在Nacos控制台修改配置后，Nacos会将配置变更推送给相关的微服务，并且无需重启即可生效，实现配置热更新。

添加配置

在nacos控制台配置管理->配置列表中点击+可以新建一个配置

比如下面的JDBC配置信息

在这里插入图片描述

拉取共享配置

下面是SpringCloud项目初始化的流程图

这里注意：读取Nacos配置是SpringCloud上下文（ApplicationContext）初始化时处理的，发生在项目的引导阶段。然后才会初始化SpringBoot上下文，去读取application.yaml。也就是说引导阶段，application.yaml文件尚未读取

让SpringCloud在初始化上下文的时候会先读取一个名为bootstrap.yaml(或者bootstrap.properties)的文件，如果我们将nacos地址配置到bootstrap.yaml中，那么在项目引导阶段就可以读取nacos中的配置了。

在这里插入图片描述

引入依赖

在微服务模块中引入Nacos配置管理和读取bootstrap文件的依赖

  <!--nacos配置管理-->
  <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  </dependency>
  <!--读取bootstrap文件-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-bootstrap</artifactId>
  </dependency>

在resource目录下新建bootstrap.yaml

spring:
  application:
    name: cart-service # 服务名称
  profiles:
    active: dev
  cloud:
    nacos:
      server-addr: 192.168.88.188 # nacos地址
      config:
        file-extension: yaml # 文件后缀名
        shared-configs: # 共享配置
          - dataId: shared-jdbc.yaml # 共享mybatis配置
          - dataId: shared-log.yaml # 共享日志配置
          - dataId: shared-swagger.yaml # 共享日志配置

那么application.xml里的配置就可以简化为

server:
  port: 8082
feign:
  httpclient:
    enabled: true
hm:
  db:
    database: hm-cart
  swagger:
    title: "黑马商城购物车服务文档"
    package: top.zhengru.hmall.cart.controller

配置热更新

我们需要在nacos新建一个配置，并且这个配置的名字必须要符合下面的规范

文件名称由三部分组成：

服务名：我们是购物车服务，所以是cart-service
spring.active.profile：就是spring boot中的spring.active.profile，可以省略，则所有profile共享该配置
后缀名：例如yaml

[服务名]-[spring.active.profile].[后缀名]

以cart-service为例，则不管是dev还是local环境都可以共享该配置

在这里插入图片描述

而读取配置，实现热更新就是在属性读取类

@Data
@Component
@ConfigurationProperties(prefix = "hm.cart")
public class CartProperties {
    private Integer maxAmount;
}

又或者是

@Data
@Component
@RefreshScope
public class CartProperties {
	@Value("${hm.cart.maxItems}")
    private Integer maxAmount;
}

这样就可以实现从nacos热更新配置了

ruuuler

关注

39
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
微服务框架（二）：网关路由、网关鉴权和配置管理

路由过滤器，作用范围比较灵活，可以是任意指定的路由Route：全局过滤器，作用范围是所有路由，不可配置通过实现可以来实现最简单的过滤器，但是注意的是自定义过滤器的类名后缀必须是@Component@Override@Override// 获取请求// 编写过滤器逻辑System.out.println("过滤器执行了");
复制链接

扫一扫