【微服务 Day3】SpringCloud实战开发（网关路由 + 网关登录校验 + 自定义过滤器 + 配置共享 + 配置热更新 + 动态路由）

Roye_ack2026-01-01 9:05

目录

一、网关路由

1、什么是网关？

2、快速入门

（1）创建网关微服务

（2）引入依赖

（3）编写启动类

（4）配置网关路由

3、路由属性

[（1）filter 路由过滤器](#（1）filter 路由过滤器)

[（2）predicates 路由断言](#（2）predicates 路由断言)

二、网关登录校验

1、Gateway内部工作原理

2、自定义过滤器

（1）自定义GlobalFilter

（2）自定义GatewayFilter

[① 无参过滤器](#① 无参过滤器)

[② 带参数过滤器](#② 带参数过滤器)

3、登录校验

（1）JWT工具

（2）定义登录校验的过滤器

（3）网关传递用户

（4）OpenFeign传递用户

四、配置管理

1、配置共享

（1）添加共享配置

（2）拉取共享配置

2、配置热更新

（1）添加配置到Nacos

（2）配置热更新

3、动态路由

（1）监听Nacos配置变更

（2）更新路由

（3）实现动态路由

一、网关路由

1、什么是网关？

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

路由：相当于问请求------你找谁？

现在，微服务网关就起到同样的作用。前端请求不能直接访问微服务，而是要请求网关：

  • 网关可以做安全控制，也就是登录身份校验，校验通过才放行

  • 通过认证后，网关再根据请求判断应该访问哪个微服务，将请求转发过去

在SpringCloud当中，提供了两种网关实现方案：

  • Netflix Zuul：早期实现，目前已经淘汰

  • SpringCloudGateway：基于Spring的WebFlux技术，完全支持响应式编程，吞吐能力更强

2、快速入门

接下来，我们先看下如何利用网关实现请求路由。由于网关本身也是一个独立的微服务，因此也需要创建一个模块开发功能。大概步骤如下：

  • 创建网关微服务

  • 引入SpringCloudGateway、NacosDiscovery依赖

  • 编写启动类

  • 配置网关路由

（1）创建网关微服务

首先在hmall下创建一个新的module，命名为hm-gateway，作为网关微服务

（2）引入依赖

在pom.xml中引入依赖

XML 复制代码 
    <dependencies>
        <!--common-->
        <dependency>
            <groupId>com.heima</groupId>
            <artifactId>hm-common</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--网关-->
        <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>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

（3）编写启动类

java 复制代码 
package com.hemall.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);
    }
}

（4）配置网关路由

接下来，在hm-gateway模块的resources目录新建一个application.yaml文件，内容如下：

bash 复制代码 
server:
  port: 8080 # 网关端口号
spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.150.101:8848
    gateway:
      routes:
        - id: item # 路由规则id，自定义，唯一
          uri: lb://item-service # 路由的目标服务，lb代表负载均衡，会从注册中心拉取服务列表
          predicates: # 路由断言，判断当前请求是否符合当前规则，符合则路由到目标服务
            - Path=/items/**,/search/** # 这里是以请求路径作为判断规则
        - id: cart
          uri: lb://cart-service
          predicates:
            - Path=/carts/**
        - id: user
          uri: lb://user-service
          predicates:
            - Path=/users/**,/addresses/**
        - id: trade
          uri: lb://trade-service
          predicates:
            - Path=/orders/**
        - id: pay
          uri: lb://pay-service
          predicates:
            - Path=/pay-orders/**

每一个路由对应一个微服务：

  • id：路由id名
    • 自定义，唯一
  • uri：路由的目标服务
    • lb代表负载均衡，会从注册中心拉取服务列表
    • 填写的服务名称与每个微服务在application.yaml文件中微服务名称一致
  • predicates：断言
    • 判断当前请求是否符合，如果符合，会路由到目标服务（身份通过，带请求到目标微服务）
      • Path=/路径名：每一个微服务下controller层的接口路径（可以有多个，按逗号相隔）

最后配置启动项并测试

启动GatewayApplication，以 http://localhost:8080 拼接微服务接口路径来测试。例如：

http://localhost:8080/items/page?pageNo=1&pageSize=1

此时，启动UserApplication、CartApplication，然后打开前端页面，发现相关功能都可以正常访问

3、路由属性

上一小节讲的是基本网关路由配置，但开发时可能会遇到某些特殊的复杂需求，那么就需要特殊的网关配置。

网关路由对应的Java类型是RouteDefinition，其中常见的属性有:

  • id：路由唯一标示
  • uri：路由目标地址
  • predicates：路由断言，判断请求是否符合当前路由
  • filters：路由过滤器，对请求或响应做特殊处理

（1）filter 路由过滤器

Gateway内置的GatewayFilter过滤器使用起来非常简单，无需编码，只要在yaml文件中简单配置即可。而且其作用范围也很灵活，配置在哪个Route下，就作用于哪个Route。

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

使用时只需要在application.yaml中这样配置：

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

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

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

（2）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 权重处理

二、网关登录校验

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

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

  • 每个微服务都需要知道JWT的秘钥，不安全

  • 每个微服务重复编写登录校验代码、权限校验代码，麻烦

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

  • 只需要在网关和用户服务保存秘钥

  • 只需要在网关开发登录校验功能

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

  • 网关路由是配置的，请求转发是Gateway内部代码，我们如何在转发之前做登录校验？

  • 网关校验JWT之后，如何将用户信息传递给微服务？

  • 微服务之间也会相互调用，这种调用不经过网关，又该如何传递用户信息？

这些问题将在接下来几节一一解决。

1、Gateway内部工作原理

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

如图所示：

  • 路由映射器 - HandlerMapping：请求进入网关后对请求做判断，找到与当前请求匹配的路由规则（Route ），然后将请求交给WebHandler去处理。

  • 请求处理器 - WebHandler：默认实现是FilteringWebHandler。WebHandler会加载当前路由下需要执行的过滤器链（Filter chain ），然后按照顺序逐一执行过滤器（Filter）。

  • 过滤器 - Filter：图中Filter被分为pre和post两部分，分别会在请求路由到微服务之前和之后被执行。

    • 只有所有Filter的pre逻辑都依次顺序执行通过后，请求才会被路由到微服务。

    • 微服务返回结果后，再倒序执行Filter的post逻辑。

  • 路由过滤器 - Netty：负责将请求转发到微服务，当微服务返回结果后存入上下文。

如图中所示，最终请求转发是有一个名为NettyRoutingFilter的过滤器来执行的，而且这个过滤器是整个过滤器链中顺序最靠后的一个。如果我们能够定义一个过滤器，在其中实现登录校验逻辑，并且将过滤器执行顺序定义到NettyRoutingFilter之前，这就符合我们的需求了！

2、自定义过滤器

那么，该如何实现一个网关过滤器呢？

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

  • GatewayFilter ：路由过滤器，作用范围比较灵活，可以是任意指定的路由Route。（默认不生效，要配置到路由后生效）

  • GlobalFilter：全局过滤器，作用范围是所有路由，不可配置。（声明后自动生效）

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

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

（1）自定义GlobalFilter

【1】在hm-gateway下创建GlobalFilter类

【2】编写GlobalFilter逻辑

java 复制代码 
@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {

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

    /**
     * 处理请求并将其传递给下一个过滤器
     * @param exchange 当前请求的上下文，其中包含request、response等各种数据
     * @param chain 过滤器链，基于它向下传递请求
     * @return 根据返回值标记当前请求是否被完成或拦截，chain.filter(exchange)就放行了。
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // TODO 模拟登录校验逻辑
        ServerHttpRequest request = exchange.getRequest();
        HttpHeaders headers = request.getHeaders();
        // 放行
        return chain.filter(exchange);
    }
}

这里继承Ordered是为了让该过滤器的执行顺序，在【完成请求转发的过滤器NettyRoutingFilter】之前去执行。已知NettyRoutingFilter的order值为最大值（约21亿），根据越小越靠前执行的规则，我们只需要给当前过滤器设置一个比最大值小的数即可。

（2）自定义GatewayFilter

自定义GatewayFilter不是直接实现GatewayFilter，而是实现AbstractGatewayFilterFactory。

① 无参过滤器

【1】创建类

该类的名称一定要以GatewayFilterFactory为后缀！

在application.yaml中直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器即可

【2】编写过滤器逻辑

1）下面是【不带顺序】的无参Gateway过滤器（无法指定过滤器执行顺序）

java 复制代码 
@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);
            }
        };
    }
}

2）下面是【带顺序】的无参Gateway过滤器（可以指定执行顺序）

java 复制代码 
@Component
public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
    @Override
    public GatewayFilter apply(Object config) {
        return new OrderedGatewayFilter(new GatewayFilter() {

            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 获取请求
                ServerHttpRequest request = exchange.getRequest();
                // 编写过滤器逻辑
                System.out.println("过滤器执行了");
                // 放行
                return chain.filter(exchange);
            }
        },1);
    }
}
② 带参数过滤器
java 复制代码 
@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;
    }

}

然后在yaml文件中使用：

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

上面这种配置方式参数必须严格按照shortcutFieldOrder()方法的返回参数名顺序来赋值。

还有一种用法，无需按照这个顺序，就是手动指定参数名：

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

3、登录校验

接下来，我们就利用自定义GlobalFilter来完成登录校验。

（1）JWT工具

登录校验需要用到JWT，而且JWT的加密需要秘钥和加密工具。这些在hm-service中已经有了，我们直接拷贝过来：

具体作用如下：

  • AuthProperties：配置登录校验需要拦截的路径，因为不是所有的路径都需要登录才能访问

  • JwtProperties：定义与JWT工具有关的属性，比如秘钥文件位置

  • SecurityConfig：工具的自动装配

  • JwtTool：JWT工具，其中包含了校验和解析token的功能

  • hmall.jks：秘钥文件

其中AuthProperties和JwtProperties所需的属性要在application.yaml中配置：

bash 复制代码 
hm:
  jwt:
    location: classpath:hmall.jks # 秘钥地址
    alias: hmall # 秘钥别名
    password: hmall123 # 秘钥文件密码
    tokenTTL: 30m # 登录有效期
  auth:
    excludePaths: # 无需登录校验的路径
      - /search/**
      - /users/login
      - /items/**

（2）定义登录校验的过滤器

代码如下：

java 复制代码 
@Component
@RequiredArgsConstructor // 用于自动生成构造方法 如下方的AuthProperties用这个注解可以自动生成构造方法
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final AuthProperties authProperties; // 配置登录校验需要拦截的路径,其中excludeath是不需要拦截的路径
    private final JwtTool jwtTool;
    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 (headers != null && !headers.isEmpty()) {
            token = headers.get(0);
        }

        // 4.校验并解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            // 如果无效，拦截，设置响应状态码为401
            ServerHttpResponse response = exchange.getResponse();
            response.setRawStatusCode(HttpStatus.UNAUTHORIZED.value());
            return response.setComplete();
        }

        // TODO 5.传递用户信息
        System.out.println("userId = " + userId);

        // 6.放行
        return chain.filter(exchange);
    }

    // 判断该路径是否放行
    private boolean isExclude(String path) {
        for (String pathPattern : authProperties.getExcludePaths()) {
            if (antPathMatcher.match(pathPattern, path)) {
                return true;
            }
        }
        return false;
    }

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

（3）网关传递用户

现在，网关已经可以完成登录校验并获取登录用户身份信息。但是当网关将请求转发到微服务时，微服务又该如何获取用户身份呢？

由于网关发送请求到微服务依然采用的是Http请求，因此我们可以将用户信息以请求头的方式传递到下游微服务。然后微服务可以从请求头中获取登录用户信息。考虑到微服务内部可能很多地方都需要用到登录用户信息，因此我们可以利用SpringMVC的拦截器来实现登录用户信息获取，并存入ThreadLocal，方便后续使用。

因此，接下来我们要做的事情有：

  • 改造网关过滤器，在获取用户信息后保存到请求头，转发到下游微服务

  • 编写微服务拦截器，拦截请求获取用户信息，保存到ThreadLocal后放行

【1】保存用户信息到请求头

首先，我们修改登录校验过滤器的【传递用户信息】处理逻辑，保存用户信息到请求头中：

java 复制代码 
        // 5.传递用户信息
        String userInfo = userId.toString();
        ServerWebExchange swe = exchange.mutate() // 修改HTTP请求
                .request(b -> b.header("user-info", userInfo))
                .build();

【2】编写微服务拦截器

在hm-common中已经有一个用于保存登录用户的ThreadLocal工具：

其中已经提供了保存和获取用户的方法：

接下来，我们只需要编写拦截器，获取用户信息并保存到UserContext，然后放行即可。

由于每个微服务都有获取登录用户的需求，因此拦截器我们直接写在hm-common中，并写好自动装配。这样微服务只需要引入hm-common就可以直接具备拦截器功能，无需重复编写。

我们在hm-common模块下定义一个拦截器：

代码如下：

java 复制代码 
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.isNotEmpty(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();
    }

}

接着在hm-common模块下编写SpringMVC的配置类，配置登录拦截器

代码如下：

java 复制代码 
@Configuration
@ConditionalOnClass(DispatcherServlet.class) // 根据类路径中是否存在某个类来决定是否创建Bean或启用配置
// 这个配置只在Spring MVC Web应用中生效（SpringMVC的核心API------DispatcherServlet）
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

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

java 复制代码 
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.JsonConfig,\
  com.hmall.common.config.MvcConfig

❗️注意：如果拦截器不加@ConditionalOnClass(DispatcherServlet.class)注解，运行时会报错！

  • 因为网关gateway不是基于SpringMvc的，所以该MvcConfig不应该生效（要将hm-gateway排除在外，否则报错）。
  • 通过使用@ConditionalOnClass(DispatcherServlet.class)，表示仅对包含了springMvc的核心类（DispatcherServlet）的微服务生效。

【3】恢复购物车代码

之前我们无法获取登录用户，所以把购物车服务的登录用户写死了，现在需要恢复到原来的样子。

找到cart-service模块的CartServiceImpl，修改其中的queryMyCarts方法：

（4）OpenFeign传递用户

前端发起的请求都会经过网关再到微服务，由于我们之前编写的过滤器和拦截器功能，微服务可以轻松获取登录用户信息。但有些业务是比较复杂的，请求到达微服务后还需要调用其它多个微服务。比如下单业务，流程如下：

下单的过程中，需要调用商品服务扣减库存，调用购物车服务清理用户购物车。而清理购物车时必须知道当前登录的用户身份。但是，订单服务调用购物车时并没有传递用户信息，购物车服务无法知道当前用户是谁。

由于微服务获取用户信息是通过拦截器在请求头中读取，因此要想实现微服务之间的用户信息传递，就必须在微服务发起调用时把用户信息存入请求头。微服务之间调用是基于OpenFeign来实现的，并不是我们自己发送的请求。我们如何才能让每一个由OpenFeign发起的请求自动携带登录用户信息呢？

这里要借助Feign中提供的一个拦截器接口：feign.RequestInterceptor

java 复制代码 
public interface RequestInterceptor {

  /**
   * 每次请求都会调用。
   * 使用提供的 RequestTemplate 上的方法添加数据。
   */
  void apply(RequestTemplate template);
}

我们只需要实现这个接口，然后实现apply方法，利用RequestTemplate类来添加请求头，将用户信息保存到请求头中。这样以来，每次OpenFeign发起请求的时候都会调用该方法，传递用户信息。

由于FeignClient全部都是在hm-api模块，因此我们在hm-api模块的config.DefaultFeignConfig中编写这个拦截器：

在DefaultFeignConfig中添加一个Bean

java 复制代码 
    @Bean
    public RequestInterceptor requestInterceptor(){
        return new RequestInterceptor() {

            @Override
            public void apply(RequestTemplate requestTemplate) {
                // 获取登录用户
                Long userId = UserContext.getUser();
                if (userId == null) {
                    return;
                }
                // 如果不为空则放入请求头中，传递给下游微服务
                requestTemplate.header("user-info", userId.toString());
            }
        };
    }

现在微服务之间通过OpenFeign调用时也会传递登录用户信息了。

四、配置管理

到目前为止我们已经解决了微服务相关的几个问题：

  • 微服务远程调用 ------ 微服务01

  • 微服务注册、发现 ------ 微服务01

  • 微服务请求路由、负载均衡 ------ 微服务02

  • 微服务登录用户信息传递 ------ 微服务02

不过，现在依然还有几个问题需要解决：

  • 网关路由在配置文件中写死了，如果变更必须重启微服务

  • 某些业务配置在配置文件中写死了，每次修改都要重启服务

  • 每个微服务都有很多重复的配置，维护成本高

这些问题都可以通过统一的配置管理器服务解决。而Nacos不仅仅具备注册中心功能，也具备配置管理的功能。

微服务共享的配置可以统一交给Nacos保存和管理，在Nacos控制台修改配置后，Nacos会将配置变更推送给相关的微服务，并且无需重启即可生效，实现配置热更新。网关的路由同样是配置，因此同样可以基于这个功能实现动态路由功能，无需重启网关即可修改路由配置。

1、配置共享

我们可以把微服务共享的配置抽取到Nacos中统一管理，这样就不需要每个微服务都重复配置了。分为两步：

  • 在Nacos中添加共享配置

  • 微服务拉取配置

（1）添加共享配置

以cart-service为例，看看有哪些配置是重复的，可以抽取的。

① jdbc相关配置

② 日志配置

③ swagger以及OpenFeign的配置

在nacos控制台分别添加这些配置

【1】首先是jdbc相关配置，在配置管理 -> 配置列表 中点击 + 新建一个配置：

在弹出的表单中填写信息

其中详细的配置如下

复制代码 
spring:
  datasource:
    url: jdbc:mysql://${hm.db.host:192.168.150.101}:${hm.db.port:3306}/${hm.db.database}?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: ${hm.db.un:root}
    password: ${hm.db.pw:123}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto

注意这里的jdbc的相关参数并没有写死，例如：

  • 数据库ip ：通过${hm.db.host:192.168.150.101}配置了默认值为192.168.150.101，同时允许通过${hm.db.host}来覆盖默认值

  • 数据库端口 ：通过${hm.db.port:3306}配置了默认值为3306，同时允许通过${hm.db.port}来覆盖默认值

  • 数据库database ：可以通过${hm.db.database}来设定，无默认值

【2】统一的日志配置，命名为shared-log.``yaml，配置内容如下：

复制代码 
logging:
  level:
    com.hmall: debug
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"

【3】统一的swagger配置，命名为shared-swagger.yaml，配置内容如下：

复制代码 
knife4j:
  enable: true
  openapi:
    title: ${hm.swagger.title:黑马商城接口文档}
    description: ${hm.swagger.description:黑马商城接口文档}
    email: ${hm.swagger.email:zhanghuyi@itcast.cn}
    concat: ${hm.swagger.concat:虎哥}
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - ${hm.swagger.package}

注意：这里的swagger相关配置没有写死，例如

  • title ：接口文档标题，我们用了${hm.swagger.title}来代替，将来可以有用户手动指定

  • email ：联系人邮箱，我们用了${hm.swagger.email:``zhanghuyi@itcast.cn``}，默认值是zhanghuyi@itcast.cn，同时允许用户利用${hm.swagger.email}来覆盖。

（2）拉取共享配置

接下来要在微服务拉取共享配置，将拉取到的共享配置与本地的application.yaml配置合并，完成项目上下文的初始化。

但是，application.yaml是属于【SpringBoot上下文​】的配置。在微服务启动的【引导阶段】，SpringBoot上下文​还没初始化，所以无法从 application.yaml中读取 Nacos 的地址，自然也就无法去远程拉取配置。

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

微服务整合Nacos配置管理的步骤如下：

【1】引入依赖

在cart-service模块的pom.xml中引入依赖

XML 复制代码 
  <!--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>

【2】新建bootstrap.yaml

在cart-service中的resources目录新建一个bootstrap.yaml文件

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

【3】修改application.yaml

由于一些配置挪到了bootstrap.yaml，因此application.yaml需要修改为：

XML 复制代码 
server:
  port: 8084
feign:
  okhttp:
    enabled: true # 开启OKHttp连接池支持
hm:
  swagger:
    title: 购物车服务接口文档
    package: com.hmall.cart.controller
  db:
    database: hm-cart

重启服务，发现所有配置都生效了。

2、配置热更新

有很多的业务相关参数，将来可能会根据实际情况临时调整。

例如购物车业务，购物车数量有一个上限，默认是10，对应代码如下：

现在这里购物车是写死的固定值，我们应该将其配置在配置文件中，方便后期修改。

但即便写在配置文件中，修改了配置还是需要重新打包、重启服务才能生效。能不能不用重启，直接生效呢？

这就要用到Nacos的配置热更新能力了，分为两步：

  • 在Nacos中添加配置

  • 在微服务读取配置

（1）添加配置到Nacos

在nacos中添加一个配置文件，将购物车的上限数量添加到配置中

注意文件的dataId格式：

XML 复制代码 
[服务名]-[spring.active.profile].[后缀名]

文件名称由三部分组成：

  • 服务名 ：购物车服务，所以是cart-service

  • spring.active.profile ：就是spring boot中的spring.active.profile，可以省略，则所有profile共享该配置

  • 后缀名：例如yaml

这里我们直接使用cart-service.yaml这个名称，则不管是dev还是local环境都可以共享该配置。

配置内容如下：

XML 复制代码 
hm:
  cart:
    maxAmount: 1 # 购物车商品数量上限

提交配置，在控制台能看到新添加的配置

（2）配置热更新

接着，我们在微服务中读取配置，实现配置热更新。

在cart-service中新建一个属性读取类：

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

接着，在业务中使用该属性加载类

测试，向购物车中添加多个商品：

在nacos控制台，将购物车上限配置为5

无需重启，再次测试购物车功能

加入成功，无需重启服务，配置热更新即可生效

3、动态路由

Spring Cloud Gateway 的默认路由机制是【静态】的

启动时会缓存到内存中的路由表内（一个Map），之后不再变化，即使配置中心有热更新能力，也无法自动触发路由的重新加载，需要自己实现监听和刷新逻辑。

【🎯 动态路由目标】直接在 Nacos 中编辑 gateway-routes.json配置内容的路由规则，无需重启网关服务，即可热配置路由规则！

为了实现动态路由，我们必须监听Nacos的配置变更，然后手动把最新的路由更新到路由表中。这里有两个难点：

  • 如何监听Nacos配置变更？

  • 如何把路由信息更新到路由表？

（1）监听Nacos配置变更

如果希望 Nacos 推送配置变更，可以使用 Nacos 动态监听配置接口来实现。

java 复制代码 
public void addListener(String dataId, String group, Listener listener)
参数名 参数类型 描述
dataId string 配置 ID，保证全局唯一性，只允许英文字符和 4 种特殊字符（"."、":"、"-"、"_"）。不超过 256 字节。
group string 配置分组，一般是默认的DEFAULT_GROUP。
listener Listener 监听器，配置变更进入监听器的回调函数。

示例代码：

java 复制代码 
String serverAddr = "{serverAddr}";
String dataId = "{dataId}";
String group = "{group}";

// 1.创建ConfigService，连接Nacos
Properties properties = new Properties();
properties.put("serverAddr", serverAddr);
ConfigService configService = NacosFactory.createConfigService(properties);

// 2.读取配置
String content = configService.getConfig(dataId, group, 5000); // 5000是读取配置的超时时间

// 3.添加配置监听器
configService.addListener(dataId, group, new Listener() {
        @Override
        public void receiveConfigInfo(String configInfo) {
        // 配置变更的通知处理
                System.out.println("recieve1:" + configInfo);
        }
        @Override
        public Executor getExecutor() {
                return null;
        }
});

这里核心的步骤有2步：

  • 创建ConfigService，目的是连接到Nacos ✅

  • 添加配置监听器，编写配置变更的通知处理逻辑

【1】创建ConfigService，目的是连接到Nacos

由于我们采用了spring-cloud-starter-alibaba-nacos-config自动装配，因此ConfigService已经在com.alibaba.cloud.nacos.NacosConfigAutoConfiguration中自动创建好了：

也就是说，ConfigService已经自动创建好了，无需再手动创建！

NacosConfigManager中是负责管理Nacos的ConfigService的，具体代码如下：

【2】添加配置监听器，编写配置变更的通知处理逻辑

虽然官方提供的SDK是ConfigService中的addListener，不过项目第一次启动时不仅仅需要添加监听器，也需要读取配置，因此建议使用的API是这个：

java 复制代码 
String getConfigAndSignListener(
    String dataId, // 配置文件id
    String group, // 配置组，走默认
    long timeoutMs, // 读取配置的超时时间
    Listener listener // 监听器
) throws NacosException;

既可以配置监听器，并且会根据dataId和group读取配置并返回。我们就可以在项目启动时先更新一次路由，后续随着配置变更通知到监听器，完成路由更新。

（2）更新路由

更新路由要用到org.springframework.cloud.gateway.route.RouteDefinitionWriter这个接口

java 复制代码 
package org.springframework.cloud.gateway.route;

import reactor.core.publisher.Mono;

public interface RouteDefinitionWriter {

        // 更新路由到路由表，如果路由id重复，则会覆盖旧的路由
        Mono<Void> save(Mono<RouteDefinition> route);
        
        // 根据路由id删除某个路由
        Mono<Void> delete(Mono<String> routeId);

}

这里更新的路由，也就是RouteDefinition，之前我们见过，包含下列常见字段：

  • id：路由id

  • predicates：路由匹配规则

  • filters：路由过滤器

  • uri：路由目的地

将来我们保存到Nacos的配置也要符合这个对象结构，将来我们以JSON来保存，格式如下：

java 复制代码 
{
  "id": "item",
  "predicates": [{
    "name": "Path",
    "args": {"_genkey_0":"/items/**", "_genkey_1":"/search/**"}
  }],
  "filters": [],
  "uri": "lb://item-service"
}

以上JSON配置就等同于：

java 复制代码 
spring:
  cloud:
    gateway:
      routes:
        - id: item
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/**

（3）实现动态路由

在网关gateway引入依赖

XML 复制代码 
<!--统一配置管理-->
<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>

在网关gateway的resources目录创建bootstrap.yaml文件，内容如下

bash 复制代码 
spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.150.101
      config:
        file-extension: yaml
        shared-configs:
          - dataId: shared-log.yaml # 共享日志配置

修改gateway的resources目录下的application.yml，把之前的路由移除，最终内容如下：

bash 复制代码 
server:
  port: 8080 # 端口
hm:
  jwt:
    location: classpath:hmall.jks # 秘钥地址
    alias: hmall # 秘钥别名
    password: hmall123 # 秘钥文件密码
    tokenTTL: 30m # 登录有效期
  auth:
    excludePaths: # 无需登录校验的路径
      - /search/**
      - /users/login
      - /items/**

在gateway中定义配置监听器：

java 复制代码 
@Slf4j
@Component
@RequiredArgsConstructor
public class DynamicRouteLoader {
    private final RouteDefinitionWriter writer;
    private final NacosConfigManager nacosConfigManager;

    // 路由配置文件的id和分组
    private final String dataId = "gateway-routes.json";
    private final String group = "DEFAULT_GROUP";
    // 保存更新过的路由id
    private final Set<String> routeIds = new HashSet<>();

    @PostConstruct
    public void initRouteConfigListener() throws NacosException {
        // 1.注册监听器并首次拉取配置
        String configInfo = nacosConfigManager.getConfigService()
                .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                    @Override
                    public Executor getExecutor() {
                        return null;
                    }

                    @Override
                    public void receiveConfigInfo(String configInfo) {
                        updateConfigInfo(configInfo);
                    }
                });
        // 2.首次启动时，更新一次配置
        updateConfigInfo(configInfo);
    }

    private void updateConfigInfo(String configInfo) {
        log.debug("监听到路由配置变更，{}", configInfo);
        // 1.解析配置信息，转为RouteDefinition
        List<RouteDefinition> routeDefinitions = JSONUtil.toList(configInfo, RouteDefinition.class);

        // 2.更新前先清空旧路由
        // 2.1.清除旧路由
        for (String routeId : routeIds) {
            writer.delete(Mono.just(routeId)).subscribe();
        }
        routeIds.clear();
        // 2.2.判断是否有新的路由要更新
        if (CollUtils.isEmpty(routeDefinitions)) {
            // 无新路由配置，直接结束
            return;
        }

        // 3.更新路由
        routeDefinitions.forEach(routeDefinition -> {
            // 3.1.更新路由
            writer.save(Mono.just(routeDefinition)).subscribe();
            // 3.2.记录路由id，方便将来删除
            routeIds.add(routeDefinition.getId());
        });
    }
}

更新路由的逻辑：更新时不需要去查询路由是否被更改，直接删了再save即可。

最后，在Nacos控制台添加路由，路由文件名为gateway-routes.json，类型为json。

配置内容如下

java 复制代码 
[
    {
        "id": "item",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/items/**", "_genkey_1":"/search/**"}
        }],
        "filters": [],
        "uri": "lb://item-service"
    },
    {
        "id": "cart",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/carts/**"}
        }],
        "filters": [],
        "uri": "lb://cart-service"
    },
    {
        "id": "user",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/users/**", "_genkey_1":"/addresses/**"}
        }],
        "filters": [],
        "uri": "lb://user-service"
    },
    {
        "id": "trade",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/orders/**"}
        }],
        "filters": [],
        "uri": "lb://trade-service"
    },
    {
        "id": "pay",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/pay-orders/**"}
        }],
        "filters": [],
        "uri": "lb://pay-service"
    }
]

无需重启网关，稍等几秒钟后，访问http://localhost:8080/search/list?pageNo=1&pageSize=1，会发现成功访问！

相关推荐
杜子不疼.2 小时前
Spring Cloud Alibaba 微服务架构：注册中心 + 配置中心搭建
微服务·云原生·架构
是阿威啊2 小时前
【用户行为归因分析项目】- 【企业级项目开发第一站】项目架构和需求设计
大数据·hive·hadoop·架构·spark·scala
蜀中孤鹰2 小时前
从秒级到毫秒级：一次Redis限流脚本的深度优化实战
redis·spring cloud·lua
消失的旧时光-19432 小时前
Flutter 中 mixin 的完整认知体系——从原理、范式、架构选择到反模式（工程实战版）
flutter·架构
Godspeed Zhao2 小时前
现代智能车机系统1——EEA架构（0）
架构·汽车
lbb 小魔仙2 小时前
【Java】Spring Cloud 核心组件详解：Eureka、Ribbon、Feign 与 Hystrix
java·spring cloud·eureka
小股虫2 小时前
事件驱动架构：如何让实时点击与异步积分在增长中台和谐共舞？
微服务·架构·团队建设·方法论
天天进步20152 小时前
【Nanobrowser源码分析2】架构篇： 探究 Nanobrowser 的核心组件与通信模型
架构
无限大.2 小时前
为什么“微服务“架构流行？——从集中式到分布式
分布式·微服务·架构
热门推荐
01GitHub 镜像站点02Linux下V2Ray安装配置指南03jdk21下载、安装（Windows、Linux、macOS）04Claude Code Skills 实用使用手册05从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击06UV安装并设置国内源07【踩坑笔记】50系显卡适配的 PyTorch 安装082025 最新教程：注册并切换到美区 Apple ID09电脑检测软件—图吧工具箱10Google Antigravity Agent 编辑器操作教程