spring cloud 分布式基础入门

已于 2024-08-12 11:40:36 修改
阅读量634 收藏 6
点赞数 23
文章标签： spring cloud 分布式 spring
于 2024-08-12 11:37:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75216378/article/details/141127129
版权

spring cloud 分布式

一、拆分思想

1、服务拆分原则

  • 什么时候拆？
    • 对于大多数小型项目来说，一般是先采用单体架构，随着用户规模扩大、业务复杂后再逐渐拆分为微服务架构。
    • 而对于一些大型项目，在立项之初目的就很明确，为了长远考虑，在架构设计时就直接选择微服务架构。
  • 怎么拆？
    • 粒度要小
    • 高内聚
    • 低耦合

2、拆分方式

  • 纵向拆分：所谓纵向拆分，就是按照项目的功能模块来拆分。
  • 横向拆分：而横向拆分，是看各个功能模块之间有没有公共的业务部分，如果有将其抽取出来作为通用服务。

二、服务调用

1、注册中心原理

在微服务远程调用的过程中，包括两个角色：

  • 服务提供者：提供接口供其它微服务访问
  • 服务消费者：调用其它微服务提供的接口

注册中心、服务提供者、服务消费者三者间关系如下：

在这里插入图片描述

流程如下：

  • 服务启动时就会注册自己的服务信息（服务名、IP、端口）到注册中心
  • 调用者可以从注册中心订阅想要的服务，获取服务对应的实例列表（1个服务可能多实例部署）
  • 调用者自己对实例列表负载均衡，挑选一个实例
  • 调用者向该实例发起远程调用

2、Nacos注册中心

  • 我们基于Docker来部署Nacos的注册中心，首先我们要准备MySQL数据库表，用来存储Nacos的数据。

  • 编写nacos/custom.env文件中，有一个MYSQL_SERVICE_HOST也就是mysql地址，需要修改为自己的虚拟机IP地址

    PREFER_HOST_MODE=hostname
MODE=standalone
SPRING_DATASOURCE_PLATFORM=mysql
MYSQL_SERVICE_HOST=192.168.179.137
MYSQL_SERVICE_DB_NAME=nacos
MYSQL_SERVICE_PORT=3306
MYSQL_SERVICE_USER=root
MYSQL_SERVICE_PASSWORD=123
MYSQL_SERVICE_DB_PARAM=characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai

  • 进入root目录，然后执行下面的docker命令

    docker run -d \
--name nacos \
--env-file ./nacos/custom.env \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
--restart=always \
nacos/nacos-server:v2.1.0-slim

  • 启动完成后，访问下面地址：http://192.168.150.101:8848/nacos/，注意将192.168.150.101替换为你自己的虚拟机IP地址。

  • 首次访问会跳转到登录页，账号密码都是nacos

3、服务注册

  1. 添加依赖，在单体服务的pom.xml中添加依赖：

    <!--nacos 服务注册发现-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

  2. 配置Nacos，在单体服务的application.yml中添加nacos地址配置：

    spring:
  application:
    name: item-service # 服务名称
  cloud:
    nacos:
      server-addr: 192.168.150.101:8848 # nacos地址

4、服务发现

  1. 引入依赖

    <!--nacos 服务注册发现-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

  2. 配置Nacos地址

    spring:
  application:
    name: item-service # 服务名称
  cloud:
    nacos:
      server-addr: 192.168.150.101:8848 # nacos地址

  3. 发现并调用服务

    1. 根据微服务名称获取到服务列表
    2. 手写负载均衡，从服务列表挑选一个实例
    3. 获取请求路径，利用RestTemplate发起http请求，得到HTTP的响应。

5、服务发现工具OpenFeign

  1. 引入依赖：一个openfeign，一个负载均衡器和性能调优，底层选择okhttp框架（另一个为Apache HttpClient ）

      <!--openFeign-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>
  <!--负载均衡器-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  </dependency>
    <!--OK http 的依赖 -->
    <dependency>
      <groupId>io.github.openfeign</groupId>
      <artifactId>feign-okhttp</artifactId>
    </dependency>

  2. 开启连接池

    feign:
  okhttp:
    enabled: true # 开启OKHttp功能

  3. 启用OpenFeign：在启动类上添加注解@EnableFeignClients并指定扫描包

    @EnableFeignClients(basePackages = "com.hmall.api.client")
@MapperScan("com.hmall.cart.mapper")
@SpringBootApplication
public class CartApplication {
    public static void main(String[] args) {
        SpringApplication.run(CartApplication.class,args);
}

  4. 编写OpenFeign客户端：底层生成代理对象，帮我们完成请求的选择和发送。

    @FeignClient("item-service")
public interface ItemClient {

    @GetMapping("/items")
    List<ItemDTO> queryItemByIds(@RequestParam("ids") Collection<Long> ids);
}

  5. 这里只需要声明接口，无需实现方法。接口中的几个关键信息：

    • @FeignClient("item-service") ：声明服务名称
    • @GetMapping ：声明请求方式
    • @GetMapping("/items") ：声明请求路径
    • @RequestParam("ids") Collection<Long> ids ：声明请求参数
    • List<ItemDTO> ：返回值类型

  6. 示例：在service注入后，调用ItemClient。

    @Service
@RequiredArgsConstructor
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements ICartService {

    	private final ItemClient itemClient;

		/*省略代码*/
        private void handleCartItems(List<CartVO> vos) {
            Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
            //在service注入后，调用ItemClient
            List<ItemDTO> items = itemClient.queryItemByIds(itemIds);
            if (CollUtils.isEmpty(items)) {
                return;
            }
            /*省略代码*/
        }
    /*省略代码*/
}

三、路由网关

1、网关

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

2、网关实现方式

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

3、网关服务编写

  • 网关本身也是一个独立的微服务，因此也需要创建一个模块开发功能。

  • 创建网关微服务

  • 引入SpringCloudGateway、NacosDiscovery依赖

     <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>

  • 编写启动类

  • 配置网关路由

    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/** # 这里是以请求路径作为判断规则
      default-filters:
        - AddRequestHeader=hhhCss, blue

    四个属性含义如下：

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

4、网关登录校验实现

  • 原来的单体springboot项目，登录校验是在拦截器里实现的。但是在spring cloud中，每一个服务在调用时都需要登录校验，也就意味着，需要些多个拦截器，很麻烦。
  • 解决思路：我们可以在网关去进行登录校验，解析token后，将user信息添加到请求头，然后在每个微服务里用拦截器将用户信息提取出来。
  • 这之间存在三个问题：
    • 网关路由是配置的，请求转发是Gateway内部代码，我们如何在转发之前做登录校验？
    • 网关校验JWT之后，如何将用户信息传递给微服务？
    • 微服务之间也会相互调用，这种调用不经过网关，又该如何传递用户信息？
4.1、网关过滤器

  • Gateway内部工作的基本原理

    在这里插入图片描述

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

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

    • GatewayFilter：路由过滤器，作用范围比较灵活，可以是任意指定的路由Route.
    • GlobalFilter：全局过滤器，作用范围是所有路由，不可配置。
4.2、网关登录校验
  • 利用自定义GlobalFilter来完成登录校验。
4.2.1、JWT工具

  • 拷贝登录校验需要用到JWT，而且JWT的加密需要秘钥和加密工具。

    • AuthProperties：配置登录校验需要拦截的路径，因为不是所有的路径都需要登录才能访问
    • JwtProperties：定义与JWT工具有关的属性，比如秘钥文件位置
    • SecurityConfig：工具的自动装配
    • JwtTool：JWT工具，其中包含了校验和解析token的功能
    • hmall.jks：秘钥文件

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

    hm:
  jwt:
    location: classpath:hmall.jks # 秘钥地址
    alias: hmall # 秘钥别名
    password: hmall123 # 秘钥文件密码
    tokenTTL: 30m # 登录有效期
  auth:
    excludePaths: # 无需登录校验的路径
      - /search/**
      - /users/login
      - /items/**
4.2.2、登录校验过滤器
@Component
@EnableConfigurationProperties(AuthProperties.class)
@RequiredArgsConstructor
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final AuthProperties authProperties;
    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> authorization = request.getHeaders().get("authorization");
        if (authorization != null && !authorization.isEmpty()){
            token = authorization.get(0);
        }
        //4、校验解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e){
            //拦截设置响应状态码，为401
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            response.setComplete();
        }
        //5、传递用户信息
        String userInfo = userId.toString();
        ServerWebExchange swe = exchange.mutate()
                .request(builder -> builder.header("user-info", userInfo))
                .build();
        //6、放行
        return chain.filter(swe);
    }

    private boolean isExclude(String path) {
        List<String> excludePaths = authProperties.getExcludePaths();
        for (String excludePath : excludePaths) {
            if (antPathMatcher.match(excludePath,path)) {
                return true;
            }
        }
        return false;
    }

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

  • 首先要继承 GlobalFilter和Ordered 接口

    • GlobalFilter：public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain)，用于登录校验的逻辑编写
    • Ordered：public int getOrder() {return 0;}，过滤器的执行顺序排序，越小优先级越高。比NettyRoutingFilter高就行，NettyRoutingFilter是转发路由的，所以优先级要在它前面。

  • private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    spring提供的一个路径匹配工具antPathMatcher.match(excludePath,path)，用来匹配放行路径

  • 最后调用exchange.mutate()的方法将userId添加到请求头生成新的路由上下文，最后将新的路由上下文传递给下一个过滤器。

4.3、微服务获取用户信息
  • 编写微服务拦截器，拦截请求获取用户信息，保存到ThreadLocal后放行
  • 由于每个微服务都需要从请求头拿到用户信息，所以我们吧拦截器配置到common模块，因为所以微服务引入了common模块，所以写一个都可以生效。

  1. 拷贝ThreadLocal工具

  2. 编写拦截器，获取用户信息并保存到UserContext，然后放行即可。

  3. UserInfoInterceptor拦截器代码：

    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();
    }
}

  4. 编写SpringMVC的配置类，配置登录拦截器，网关也引入了common包，但是网关是响应式编程没有SpringMvc。所以要加一个条件注解，否则网关会报错。

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

  5. 基于SpringBoot的自动装配原理，我们要将其添加到resources目录下的META-INF/spring.factories文件中（新版本是META-INF/spring/下的.import文件）

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.MvcConfig,\
4.4、微服务之间OpenFeign传递用户

  • OpenFeign传递用户：由于微服务获取用户信息是通过拦截器在请求头中读取，因此要想实现微服务之间的用户信息传递，就必须在微服务发起调用时把用户信息存入请求头。

  • 微服务之间调用是基于OpenFeign来实现的，并不是我们自己发送的请求。

  • 所以要借助Feign中提供的一个拦截器接口：feign.RequestInterceptor

    public interface RequestInterceptor {

  /**
   * Called for every request. 
   * Add data using methods on the supplied {@link RequestTemplate}.
   */
  void apply(RequestTemplate template);
}

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

    @Configuration
public class RequestInterceptorConfig {

    @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());
                }
            }
        };
    }
}

  • 基于SpringBoot的自动装配原理，我们要将其添加到resources目录下的META-INF/spring.factories文件中（新版本是META-INF/spring/下的.import文件）

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.api.config.RequestInterceptorConfig

四、配置管理

  • 现在依然还有几个问题需要解决：

    • 网关路由在配置文件中写死了，如果变更必须重启微服务
    • 某些业务配置在配置文件中写死了，每次修改都要重启服务
    • 每个微服务都有很多重复的配置，维护成本高

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

1、共享配置

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

  1. 进入nacos后台的配置列表

    在这里插入图片描述

  2. 点击加号，进行配置

    在这里插入图片描述

  3. 注意需要改变的相关参数不要写死，例如：

    • 数据库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}来设定，无默认值
1.2、拉取共享配置
  • SpringCloud在初始化上下文的时候会先读取一个名为bootstrap.yaml(或者bootstrap.properties)的文件，如果我们将nacos地址配置到bootstrap.yaml中，那么在项目引导阶段就可以读取nacos中的配置了。

在这里插入图片描述

  1. 引入依赖：

      <!--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，注意这里面已经定义的数据，就不要在后续的application.yaml文件中在配置了。

    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

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

2、配置热更新

  • 非常容易简单理解，用到Nacos的配置热更新能力了，分为两步：
    • 在Nacos中添加配置
    • 在微服务读取配置
2.1、添加配置到Nacos

  • 首先，我们在nacos中添加一个配置文件

  • 注意文件的dataId格式：[服务名]-[spring.active.profile].[文件后缀名]

  • spring.active.profile，可以省略，则所有profile（环境）共享该配置

在这里插入图片描述

2.2、在微服务读取配置

  • 使用属性类，来读取数据即可。（一定要是属性类读取）

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

  • 最后在需要使用的地方，将属性类注入，即可完成配置文件热部署。

五、动态路由

  • 监听Nacos的配置变更，然后手动把最新的路由更新到路由表中。这里有两个难点：
    • 如何监听Nacos配置变更？
    • 如何把路由信息更新到路由表？

1、监听Nacos配置变更

  1. NacosConfigAutoConfiguration中自动创建好了NacosConfigManager，而NacosConfigManager中是负责管理Nacos的ConfigService的

  2. 因此，只要我们拿到NacosConfigManager就等于拿到了ConfigService。

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

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

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

2、更新路由信息

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

    package org.springframework.cloud.gateway.route;

import reactor.core.publisher.Mono;

/**
 * @author Spencer Gibb
 */
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来保存，以便配置读取转换成RouteDefinition，格式如下：

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

3、实现动态路由

  1. 首先， 我们在网关gateway引入依赖

    <!--统一配置管理-->
<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. 在网关gateway的resources目录创建bootstrap.yaml文件，拉取配置

    spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.150.101 #nacos地址
      config:
        file-extension: yaml
        shared-configs:
          - dataId: shared-log.yaml # 共享日志配置

  3. 然后，在gateway中定义配置监听器：

    @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.反序列化
        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());
        });
    }
}

  4. 我们直接在Nacos控制台添加路由，路由文件名为gateway-routes.json，类型为json

    在这里插入图片描述

  5. 配置内容如下：

    [
    {
        "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"
    }
]

  6. 无需重启网关，稍等几秒钟后，再次访问地址。

客家话飞过的痕迹
关注
  • 23
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringCloud分布式事务
猿码天地
04-09 7989
我是猿人，一个热爱技术、热爱编程的IT猿。技术是开源的，知识是共享的！写作是对自己学习的总结和记录，如果您对 Java、分布式、微服务、中间件、Spring Boot、Spring Clo...
Spring Cloud Alibaba 从入门到精通1
08-03
【Spring Cloud Alibaba 从入门到精通1】 Spring Cloud Alibaba 是一套基于阿里巴巴集团内部中间件实践经验，为Java开发者提供的微服务解决方案。它旨在简化云原生应用的开发过程，尤其是在Spring Cloud生态中，...
SpringCloud分布式架构详解
靖节先生的博客
12-17 4168
SpringCloud系统架构详解1. SpringCloud概述1.1 SpringCloud概述1.2 SpringBoot与SpringCloud依赖关系1.3 SpringCloud总体架构及组件说明2. Spring Cloud Netflix2.1 Eureka服务注册与发现2.2 Zookeeper服务注册与发现2.3 Consul服务注册与发现2.4 Ribbon负载均衡服务调用2.5 OpenFeign服务接口调用2.6 Hystrix断路器2.7 Zuul服务网关2.8 Gateway新
Spring Cloud 分布式事务管理
a1901149的博客
04-17 1082
易于扩展，使用小的多个服务，更加易于扩展新的功能某个服务的更新部署，不需要重新部署整个应用通过组合多个服务，可以提供一些新的功能因为每个微服务都比较小，重新实现某一个服务或者直接删除该服务都是可操作的微服务间通过REST、RPC等形式交互，相对于单体模式，需要考虑被调用方故障、过载、消息丢失等各种异常情况，代码逻辑更加复杂。对于微服务间的事务性操作，因为不同的微服务采用了不同的数据库，将无法利用数据库本身的事务机制保证一致性，需要引入二阶段提交等技术。
SpringCloud入门教程（全集）
热门推荐
tttalk的博客
03-01 8万+
SpringCloud所有常见组件介绍及使用示例
【Spring Cloud 1】分布式架构入门
学Java，找哪吒
01-03 7650
一、CDN加速静态文件访问 CDN是Content Delivery Network的简称，即“内容分发网络”的意思，一般是指网站加速或用户下载速度加速。 简单来说CDN相当于一个中间代理，原来我们请求百度时，请求会直接发送到百度的服务器，加入请求者在大连，但百度的服务器在北京，这样的话请求和响应都会受到距离的影响而变得慢一些，但有了CDN之后，请求先发到距离请求IP定位最近的CDN服务器上，该服务器缓存了百度页面的一些静态文件，比如CSS、JS、html、图片等，这样对用户来说，获取这些静态资源就比较
SpringCloud分布式微服务链路追踪方案：Zipkin
lucky_fd的博客
06-24 1515
Zipkin 是一个分布式追踪系统，主要用于收集、存储、处理和展示微服务架构中的链路数据。它帮助开发者分析和排查分布式系统中的性能问题，提供完整的请求路径视图。. 在微服务架构中，一个用户请求可能会涉及多个微服务的调用。每个微服务都有可能运行在不同的主机或容器中，传统的日志和监控系统难以提供完整的请求链路视图。而Zipkin能够帮助开发者： 快速定位问题：通过完整的请求路径视图，开发者可以快速找到导致请求延迟或错误的具体服务和代码位置。 优化系统性能：通过分析请求的延迟数据，开发者可以识别系统中的性能瓶颈
Spring Cloud 分布式消息—Spring Cloud Stream 简介与入门
微服务技术栈
09-03 804
目前市面上有许多消息代理中间件（下面简称为消息代理），例如 ActiveMQ RabbitMQ、Kafka 、RocketMQ等，在使用这些框架时，我们需要调用它们的API用于发送和接收消息。本篇博客我们使用RabbitMQ作为示例。在单独使用RabbitMq时，我们需要创建RabbitMQ客户端连接，创建Channel，声明一个队列，然后通过Channel发布消息。代码如下所示：
SpringCloud-分布式配置中心【入门介绍】
2401_84002542的博客
04-12 642
分布式技术专题+面试解析+相关的手写和学习的笔记pdf一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！盖了95%以上Java开发知识点，真正体系化！**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新。
SpringCloud之Config分布式配置中心
light的博客
07-08 434
SpringCloud之Config分布式配置中心
SpringCloud Alibaba 之 Config配置中心,Redis分布式锁详解
qq_43649937的博客
05-11 3906
springcloud java redis 分布式
简易的SpringCloud分布式微服务项目
02-21
本项目名为"简易的SpringCloud分布式微服务项目"，它旨在提供一个简单易懂的入门示例，帮助开发者理解如何利用SpringCloud实现微服务的搭建和管理。 1. **微服务概念**：微服务是一种软件开发方法，它提倡将单一...
SpringCloud分布式微服务架构入门.docx
08-20
SpringCloud分布式微服务架构入门.技术选型，对比Dubbo到底怎么选的好。介绍CAP的基本概念，以及SpringCloud的实现方式
springcloud入门代码基于Spring Cloud实现的分布式配置中心源代码
06-15
在深入研究源代码`springcloud-chapter07-master`时，你可以学习到如何设置Config Server和Config Client，以及如何在微服务之间进行通信以获取配置。这将涉及到Spring Boot的启动类配置、Spring Cloud的相关依赖、...
SpringCloud基础教程
12-31
SpringCloud是中国Java开发者广泛使用的微服务框架之一，它基于Spring Boot进行快速构建，并提供了众多用于构建分布式系统的服务发现、配置管理、负载均衡、断路器等核心功能。本基础教程旨在帮助初学者全面理解并...
微服务实现-sleuth+zipkin分布式链路追踪和nacos配置中心
qq_59099003的博客
08-08 760
sleuth+zipkin实现分布式链路追踪、nacos配置中心
javaweb_04：SpringBoot
最新发布
qq_52200849的博客
08-08 333
1、概念：超文本传输协议，规定了浏览器与服务器之间数据传输的规则。2、特点：基于TCP协议，面向连接、安全；基于请求-响应模型，一次请求对应一次相应；HTTP协议是无状态的协议，对于事务处理没有记忆能力，每次请求响应都是独立的，多次请求间不能共享数据但是速度快。
SpringCloud入门简介
敢问路在何方，路在脚下
08-06 450
SpringCloud是微服务治理方案之一；SpringCloud与SSM框架和SpringBoot没什么关联SSM：web应用的开发框架，包含视图层（模型model+视图view+控制器controller），业务层，持久层SpringBoot：简化SSM的配置，同时提供构建项目的脚手架。
Java之SpringBoot入门(含Spring Mvc)
qq_35639854的博客
08-06 1041
在计算机领域, 会话是⼀个客⼾与服务器之间的不中断的请求响应. 对客⼾的每个请求，服务器能够识 别出请求来⾃于同⼀个客⼾. 当⼀个未知的客⼾向Web应⽤程序发送第⼀个请求时就开始了⼀个会话. 当客⼾明确结束会话或服务器在⼀个时限内没有接受到客⼾的任何请求时，会话就结束了.服务器同⼀时刻收到的请求是很多的. 服务器需要清楚的区分每个请求是从属于哪个⽤⼾, 也就是属于 哪个会话, 就需要在服务器这边记录每个会话以及与⽤⼾的信息的对应关系. Session是服务器为了保存⽤⼾信息⽽创建的⼀个特殊的对象.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值