SpringCloud-实用篇


实用篇包含微服务治理(注册发现,远程调用,配置管理,网关路由)、Docker技术、异步通信、分布式缓存、分布式搜索

小简从 0 开始学 Java 知识之 Java-学习路线 中的《SpringCloud-实用篇》,不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!>

  • 🚩时间安排:预计5天更新完
  • 🎯开始时间:09-20
  • 🎉结束时间:09-25
  • 🍀总结:
学习安排
技术分类

1.微服务

①架构对比

架构 单体架构 分布式架构
描述 将业务的所有功能集中在一个项目中开发,打成一个包部署。 根据业务功能对系统做拆分,每个业务功能模块作为独立项目开发。
图示
优点 架构简单、部署成本低 降低服务耦合、有利于服务升级和拓展
缺点 耦合度高(维护困难、升级困难) 服务调用关系错综复杂

分布式架构虽然降低了服务耦合,但是服务拆分时也有很多问题需要思考:

  • 服务拆分的粒度如何界定?
  • 服务集群地址如何维护?
  • 服务的调用关系如何管理?
  • 服务健康状态如何感知?

人们需要制定一套行之有效的标准来约束分布式架构。因此微服务来啦!!!

②微服务简介

微服务的架构特征:

  • 单一职责:微服务拆分粒度更小,每一个服务都对应唯一的业务能力,做到单一职责
  • 自治:团队独立、技术独立、数据独立,独立部署和交付
  • 面向服务:服务提供统一标准的接口,与语言和技术无关
  • 隔离性强:服务调用做好隔离、容错、降级,避免出现级联问题

微服务的上述特性其实是在给分布式架构制定一个标准,进一步降低服务之间的耦合度,提供服务的独立性和灵活性。做到高内聚,低耦合。因此微服务是一种经过良好架构设计的分布式架构方案

微服务架构

但方案该怎么落地?选用什么样的技术栈?其中在Java领域最引人注目的就是SpringCloud提供的方案了。

③微服务方案

目前国内使用最广泛的微服务方案:Dubbo、SpringCloud、SpringCloudAlibaba

方案对比

⑤案例引入

下方的讲解都基于此案例进行,请提前搭建好此项目。项目cloud-demo 密码:1399

搭建方式:1.使用IDEA 打开 cloud-demo项目 2.创建两个数据库cloud_ordercloud_user 3.将提供的cloud-order.sqlcloud-user.sql导入对应库中 4.修改项目中数据库密码

项目结构:

cloud-demo  # 父工程,管理依赖
├── order-service # 订单微服务,负责订单相关业务
└── user-service  # 用户微服务,负责用户相关业务

项目特征:

  • 订单微服务和用户微服务有各自的数据库,相互独立
  • 订单服务和用户服务都对外暴露Restful的接口
  • 订单服务如果需要查询用户信息,只能调用用户服务的Restful接口,不能查询用户数据库

基础概念:

在服务调用关系中,会有两个不同的角色:

  • 服务提供者:一次业务中,被其它微服务调用的服务。(提供接口给其它微服务)

  • 服务消费者:一次业务中,调用其它微服务的服务。(调用其它微服务提供的接口)

  • 服务提供者与服务消费者的角色并不是绝对的,而是相对于业务而言。

目前需求:修改order-service中的查询订单业务,要求在查询订单的同时,根据订单中包含的userId查询出用户信息,一起返回。

2.服务远程调用①

①RestTemplate

要实现上方需求,我们需要在order-service中向user-service发起一个http的请求,调用http://localhost:8081/user/{userId}接口。

步骤如下:

  • 注册一个RestTemplate的实例到Spring容器
  • 修改order-service服务中的OrderService类中的queryOrderById方法,根据Order对象中的userId查询User
  • 将查询的User填充到Order对象,一起返回

步骤一:注册RestTemplate

@MapperScan("cn.xxxx.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

步骤二:实现远程调用

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
  
    @Autowired
    private RestTemplate restTemplate 

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.远程查询user
        // 2.1 url地址
                String url = "http://localhost:8081/user/" + order.getUserId();
        // 2.2 发起调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

3.服务注册发现

①Eureka

假如我们的服务提供者user-service部署了多个实例,如图:

思考几个问题:

  • order-service在发起远程调用的时候,该如何得知user-service实例的ip地址和端口?
  • 有多个user-service实例地址,order-service调用时该如何选择?
  • order-service如何得知某个user-service实例是否依然健康,是不是已经宕机?

❶Eureka原理分析

这些问题都需要利用SpringCloud中的注册中心来解决,其中最广为人知的注册中心就是Eureka,其结构如下:

问题1:order-service如何得知user-service实例地址?

  • user-service服务实例启动后,将自己的信息注册到eureka-server(Eureka服务端)。这个叫服务注册
  • eureka-server保存服务名称到服务实例地址列表的映射关系
  • order-service根据服务名称,拉取实例地址列表。这个叫服务发现或服务拉取

问题2:order-service如何从多个user-service实例中选择具体的实例?

  • order-service从实例列表中利用负载均衡算法选中一个实例地址
  • 并向该实例地址发起远程调用

问题3:order-service如何得知某个user-service实例是否依然健康,是不是已经宕机?

  • user-service会每隔一段时间(默认30秒)向eureka-server发起请求,报告自己状态,称为心跳
  • 当超过一定时间没有发送心跳时,eureka-server会认为微服务实例故障,将该实例从服务列表中剔除
  • order-service拉取服务时,就能将故障实例排除了

使用步骤

❷搭建eureka-server

步骤一:创建eureka-server模块

在cloud-demo父工程下,创建一个maven子模块 eureka-server

步骤二:引入eureka依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

步骤三:编写启动类

编写一个启动类,添加@EnableEurekaServer注解,开启eureka的注册中心功能

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

步骤四:编写配置文件

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url: 
      defaultZone: http://127.0.0.1:10086/eureka

步骤五:启动服务

启动微服务,然后在浏览器访问:http://127.0.0.1:10086,看到Web页面表示成功了

❸服务注册

下面,我们将user-service注册到eureka-server中去。

步骤一:引入依赖

在user-service的pom文件中,引入eureka-client依赖:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

步骤二:配置文件

在user-service中,修改application.yml文件,添加服务名称、eureka地址:

spring:
  application:
    name: userservice
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

步骤三:启动多个user-service实例

为了演示一个服务有多个实例的场景,可以通过SpringBoot的启动配置,再启动一个user-service。

1.复制原来的user-service启动配置: 2.在弹出的窗口中,填写信息:
3.出现两个user-service实例 4.启动两个user-service实例

查看eureka-server管理页面:

❹服务发现

下面,我们将order-service的逻辑修改:实现向eureka-server拉取user-service的信息,即服务发现。

步骤一:引入依赖

服务发现、服务注册统一都封装在eureka-client依赖,因此这一步与服务注册时一致。

在order-service的pom文件中,引入eureka-client依赖:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

步骤二:配置文件

服务发现也需要知道eureka地址,在order-service中,修改application.yml文件,添加服务名称、eureka地址:

spring:
  application:
    name: orderservice
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

步骤三:服务拉取和负载均衡

最后,我们要去eureka-server中拉取user-service服务的实例列表,并且实现负载均衡。

在order-service的OrderApplication中,给RestTemplate这个Bean添加一个@LoadBalanced注解:

@MapperScan("cn.xxxx.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }

    @Bean
    @LoadBalanced //添加注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

修改order-service服务中的OrderService类中的queryOrderById方法。修改访问的url路径,用服务名代替ip、端口:

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
  
    @Autowired
    private RestTemplate restTemplate 

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.远程查询user
        // 2.1 url地址
                //String url = "http://localhost:8081/user/" + order.getUserId();
        String url = "http://userservice/user/" + order.getUserId();
        // 2.2 发起调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

spring会自动帮助我们从eureka-server端,根据userservice这个服务名称,获取实例列表,而后完成负载均衡。

❺总结

  • 1.搭建EurekaServer

    • 引入eureka-server依赖

    • 添加@EnableEurekaServer注解

    • 在application.yml中配置eureka地址

  • 2.服务注册

    • 引入eureka-client依赖
    • 在application.yml中配置eureka地址
  • 3.服务发现

    • 引入eureka-client依赖
    • 在application.yml中配置eureka地址
    • 给RestTemplate添加@LoadBalanced注解
    • 用服务提供者的服务名称远程调用

②Nacos

Nacos是阿里巴巴的产品,是 SpringCloudAlibaba 中的一个组件。相比 Eureka 功能更加丰富,在国内受欢迎程度较高。

❶安装

下载地址:https://github.com/alibaba/nacos

下载后解压即可,目录说明:

- log           nacos生成日志说明
- bin           nacos服务相关脚本目录,
- conf          nacos的配置文件目录
- target        nacos的启动依赖目录
- data          nacos自带apache-derby数据库,data存放数据内容
# 启动命令 单体启动
sh startup.sh -m standalone

# 关闭命令
sh shutdown.sh

在浏览器输入地址即可访问:http://127.0.0.1:8848/nacos,默认的账号和密码都是nacos

如果你打不开这个网页 !多半是版本问题。

❷服务注册/发现

步骤一:引入依赖

在cloud-demo父工程的pom文件中的<dependencyManagement>中引入SpringCloudAlibaba的依赖:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.6.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

然后在user-service和order-service中的pom文件中引入nacos-discovery依赖:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

注意:不要忘了注释掉eureka的依赖。

步骤二:配置nacos地址

在user-service和order-service的application.yml中添加nacos地址:

spring:
  cloud:
    nacos:
      server-addr: localhost:8848

注意:不要忘了注释掉eureka的地址

步骤三:重启

重启微服务后,登录nacos管理页面,可以看到微服务信息

❸集群配置

⓵分级存储模型

一个服务可以有多个实例,例如我们的user-service,假如这些实例分布于全国各地的不同机房

实例 机房
127.0.0.1:8081 杭州
127.0.0.1:8082 杭州
127.0.0.1:8083 上海

Nacos就将同一机房内的实例划分为一个集群。也就是说,user-service是服务,一个服务可以包含多个集群,如杭州、上海、北京,每个集群下可以有多个实例,形成分级模型,如图:

①一级是服务,例如user-service;②二级是集群,例如杭州或上海;③三级是实例,例如杭州机房的某台部署

微服务互相访问时,应该尽可能访问同集群实例,因为本地访问速度更快。当本集群内实例不可用时,才访问其它集群。例如:杭州机房内的order-service应该优先访问同机房的user-service。

⓶给user-service配置集群

修改user-service的application.yml文件,添加集群配置:

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 集群名称

重启两个user-service实例后,我们可以在nacos控制台看到下面结果:

我们再次复制一个user-service启动配置UserApplication3,复制方式参考【上方搭建eureka-server步骤三】

添加VM属性:

-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH

启动UserApplication3后再次查看nacos控制台:

⓷同集群优先的负载均衡

负载均衡默认规则ZoneAvoidanceRule并不能实现根据同集群优先来实现负载均衡。因此Nacos中提供了一个NacosRule的实现,可以优先从同集群中挑选实例。

步骤一:给order-service配置集群信息

修改order-service的application.yml文件,添加集群配置:

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 集群名称

步骤二:修改负载均衡规则

修改order-service的application.yml文件,修改负载均衡规则:

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则 

NacosRule负载均衡策略

  • ①优先选择同集群服务实例列表

  • ②本地集群找不到提供者,才去其它集群寻找,并且会报警告

  • ③确定了可用实例列表后,再采用随机负载均衡挑选实例

❹权重配置

实际部署中会出现这样的场景:服务器设备性能有差异,部分实例所在机器性能较好,另一些较差,我们希望性能好的机器承担更多的用户请求。但默认情况下NacosRule是同集群内随机挑选,不会考虑机器的性能问题。

因此,Nacos提供了权重配置来控制访问频率,权重越大则访问频率越高。在nacos控制台,找到user-service的实例列表,点击编辑,即可修改权重:

注意:如果权重修改为0,则该实例永远不会被访问,使用场景:进行实例的平滑更新

❺环境隔离

Nacos提供了namespace来实现环境隔离功能。

  • nacos中可以有多个namespace
  • namespace下可以有group、service等
  • 不同namespace之间相互隔离,例如不同namespace的服务互相不可见

步骤一:创建namespace

默认情况下,所有service、group、data都在同一个namespace,名为public

添加一个namespace 设置信息

就能在页面看到一个新的namespace:

步骤二:给微服务配置namespace

给微服务配置namespace只能通过修改配置来实现。例如,修改order-service的application.yml文件:

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间,填ID

重启order-service后,访问控制台,可以看到下面的结果:

此时访问order-service,因为namespace不同,会导致找不到userservice,控制台会报错:

③Nacos与Eureka区别

Nacos的服务实例分为两种类型:

  • 临时实例: 如果实例宕机超过一定时间,会从服务列表剔除,默认的实例类型。

  • 非临时实例:如果实例宕机,不会从服务列表剔除,也可以叫永久实例。

配置一个服务实例为永久实例:

spring:
  cloud:
    nacos:
      discovery:
        ephemeral: false # 设置为非临时实例

Nacos和Eureka整体结构类似,服务注册、服务拉取、心跳等待,但是也存在一些差异:

共同点 不同点
①都支持服务注册和服务拉取
②都支持服务提供者心跳方式做健康检测
①Nacos支持服务端主动检测提供者状态,临时实例采用心跳模式,非临时实例采用主动检测模式
②临时实例心跳不正常会被剔除,非临时实例则不会被剔除
③Nacos支持服务列表变更的消息推送模式,服务列表更新更及时
④Nacos集群默认采用AP方式,当集群中存在非临时实例时,采用CP模式;Eureka采用AP方式

4.负载均衡-Ribbon

①负载均衡原理

SpringCloud底层利用Ribbon来实现负载均衡功能

我们发出的请求明明是http://userservice/user/1,怎么变成了http://localhost:8081/user/1的呢?

显然有人帮我们根据service名称,获取到了服务实例的ip和端口。它就是LoadBalancerInterceptor,这个类会在对RestTemplate的请求进行拦截,然后从Eureka根据服务id获取服务列表,随后利用负载均衡算法得到真实的服务地址信息,替换服务id。我们进行源码跟踪:

❶LoadBalancerIntercepor

可以看到这里的intercept方法,拦截了用户的HttpRequest请求,然后做了几件事:

  • request.getURI():获取请求uri,本例中就是 http://user-service/user/8
  • originalUri.getHost():获取uri路径的主机名,其实就是服务id,user-service
  • this.loadBalancer.execute():处理服务id,和用户请求。

这里的this.loadBalancerLoadBalancerClient类型,我们继续跟入execute方法:

❷LoadBalancerClient

  • getLoadBalancer(serviceId):根据服务id获取ILoadBalancer,而ILoadBalancer会拿着服务id去eureka中获取服务列表并保存起来。
  • getServer(loadBalancer):利用内置的负载均衡算法,从服务列表中选择一个。本例中,可以看到获取了8082端口的服务

放行后,再次访问并跟踪,发现获取的是8081,果然实现了负载均衡。

❸负载均衡策略IRule

在刚才的代码中,可以看到获取服务使通过一个getServer方法来做负载均衡:

我们继续跟入:

继续跟踪源码chooseServer方法,发现这么一段代码:

这里的rule默认值是一个RoundRobinRule,看类的介绍:

这不就是轮询的意思嘛。到这里,整个负载均衡的流程我们就清楚了。

❹总结

Ribbon的底层采用了一个拦截器,拦截了RestTemplate发出的请求,对地址做了修改。用一幅图来总结一下:

基本流程如下:

  • 1.拦截我们的RestTemplate请求http://userservice/user/1
  • 2.RibbonLoadBalancerClient会从请求url中获取服务名称,也就是userservice
  • 3.DynamicServerListLoadBalancer根据userservice到eureka拉取服务列表
  • 4.eureka-server返回列表,localhost:8081、localhost:8082
  • 5.IRule利用内置负载均衡规则,从列表中选择一个,例如localhost:8081
  • 6.RibbonLoadBalancerClient修改请求地址,用localhost:8081替代userservice,得到http://localhost:8081/user/1,发起真实请求

②负载均衡策略

负载均衡的规则都定义在IRule接口中,而IRule有很多不同的实现类:

不同规则的含义如下:

内置负载均衡规则类 规则描述
RoundRobinRule 简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule 对以下两种服务器进行忽略: (1)在默认情况下,这台服务器如果3次连接失败,这台服务器就会被设置为“短路”状态。短路状态将持续30秒,如果再次连接失败,短路的持续时间就会几何级地增加。 (2)并发数过高的服务器。如果一个服务器的并发连接数过高,配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限,可以由客户端的<clientName>.<clientConfigNameSpace>.ActiveConnectionsLimit属性进行配置。
WeightedResponseTimeRule 为每一个服务器赋予一个权重值。服务器响应时间越长,这个服务器的权重就越小。这个规则会随机选择服务器,这个权重值会影响服务器的选择。
ZoneAvoidanceRule 以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类,这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule 忽略那些短路的服务器,并选择并发数较低的服务器。
RandomRule 随机选择一个可用的服务器。
RetryRule 重试机制的选择逻辑

默认的实现就是ZoneAvoidanceRule,是一种轮询方案

自定义负载均衡策略

通过定义IRule实现可以修改负载均衡规则,有两种方式:

  • 1.全局配置:在order-service中的OrderApplication类中,定义一个新的IRule
@Bean
public IRule randomRule(){
    return new RandomRule();
}
  • 2.单个配置:在order-service的application.yml文件中,添加新的配置也可以修改规则:
userservice: # 给某个微服务配置负载均衡规则,这里是userservice服务
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则 

注意,一般用默认的负载均衡规则,不做修改。

③饥饿加载

Ribbon默认是采用懒加载,即第一次访问时才会去创建LoadBalanceClient,请求时间会很长。

而饥饿加载则会在项目启动时创建,降低第一次访问的耗时,通过下面配置开启饥饿加载:

ribbon:
  eager-load:
    enabled: true
    clients: userservice

5.服务远程调用②

②OpenFeign

前面利用RestTemplate发起远程调用的代码

String url = "http://localhost:8081/user/" + order.getUserId();
User user = restTemplate.getForObject(url, User.class);

存在下面的问题:

  • 代码可读性差,编程体验不统一

  • 参数复杂URL难以维护

OpenFeign是一个声明式的http客户端,其作用就是帮助我们优雅的实现http请求的发送,解决上面提到的问题。

❶使用

步骤一:引入依赖

在order-service服务的pom文件中引入openfeign的依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

使用 openfeign 依赖 ribbon,但是最新版的 openfeign 移除了ribbon ,因此如果单独使用openfeign需要引入ribbon,并进行配置。如果配合 eureka 或 nacos 则不用

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
# 这个userservice是加了@FeignClient注解的类的name
userservice:
  ribbon:
    # 服务提供者的地址,不是服务注册中心的地址
    listOfServers: http://localhost:8081

步骤二:添加注解

在order-service的启动类添加注解开启openfeign的功能:

@EnableFeignClients //开启feign
@MapperScan("cn.xxxx.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

步骤三:编写Feign的客户端

在order-service中新建一个接口,内容如下:

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

这个客户端主要是基于SpringMVC的注解来声明远程调用的信息,比如:

  • 服务名称:userservice
  • 请求方式:GET
  • 请求路径:/user/{id}
  • 请求参数:Long id
  • 返回值类型:User

这样,Feign就可以帮助我们发送http请求,无需自己使用RestTemplate来发送了。

步骤四:实现远程调用

修改order-service中的OrderService类中的queryOrderById方法,使用Feign客户端代替RestTemplate:

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
  
    @Autowired
    private UserClient userClient 

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用Feign发起http请求,查询用户
        User user = userClient.findById(order.getUserId());
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

实现过程

总结

使用Feign的步骤:

  • ① 引入依赖

  • ② 添加@EnableFeignClients注解

  • ③ 编写FeignClient接口

  • ④ 使用FeignClient中定义的方法代替RestTemplate

❷配置

Feign可以支持很多的自定义配置,如下表所示:

类型 作用 说明
feign.Logger.Level 修改日志级别 包含四种不同的级别:NONE、BASIC、HEADERS、FULL
feign.codec.Decoder 响应结果的解析器 http远程调用的结果做解析,例如解析json字符串为java对象
feign.codec.Encoder 请求参数编码 将请求参数编码,便于通过http请求发送
feign. Contract 支持的注解格式 默认是SpringMVC的注解
feign. Retryer 失败重试机制 请求失败的重试机制,默认是没有,不过会使用Ribbon的重试

日志的级别分为四种:

  • NONE:不记录任何日志信息,这是默认值。
  • BASIC:仅记录请求的方法,URL以及响应状态码和执行时间(推荐使用)
  • HEADERS:在BASIC的基础上,额外记录了请求和响应的头信息
  • FULL:记录所有请求和响应的明细,包括头信息、请求体、元数据。

一般情况下,默认值就能满足我们使用,如果要自定义时,可以通过修改配置文件或者创建自定义@Bean覆盖默认Bean

修改配置文件方式

  • 针对单个服务:
feign:  
  client:
    config: 
      userservice: # 针对某个微服务的配置
        loggerLevel: FULL #  日志级别 
  • 针对所有服务:
feign:  
  client:
    config: 
      default: # 这里用default就是全局配置,如果是写服务名称,则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别 

自定义Bean覆盖

也可以基于Java代码来修改日志级别,先声明一个类,然后声明一个Logger.Level的对象:

public class DefaultFeignConfiguration  {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

如果要全局生效,将其放到启动类的@EnableFeignClients这个注解中:

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration.class) 

如果是局部生效,则把它放到对应的@FeignClient这个注解中:

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration.class) 

❸优化

Feign底层发起http请求,依赖于其它的框架。其底层客户端实现包括:

  • URLConnection:默认实现,不支持连接池

  • Apache HttpClient :支持连接池

  • OKHttp:支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。这里我们用Apache的HttpClient来演示。

步骤一:引入依赖

在order-service的pom文件中引入Apache的HttpClient依赖:

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

步骤二:配置连接池

在order-service的application.yml中添加配置:

feign:
  client:
    config:
      default: # default全局的配置
        loggerLevel: BASIC # 日志级别,BASIC就是基本的请求和响应信息
  httpclient:
    enabled: true # 开启feign对HttpClient的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数

❹最佳实践

所谓最近实践,就是使用过程中总结的经验,最好的一种使用方式。仔细可以发现,Feign的客户端与服务提供者的controller代码非常相似:

UserClient UserController

有没有一种办法简化这种重复的代码编写呢?

方案一:继承方式

一样的代码可以通过继承来共享:

  • 1.定义一个API接口,利用定义方法,并基于SpringMVC注解做声明。
  • 2.Feign客户端和Controller都集成该接口

优点:

  • 简单
  • 实现了代码共享

缺点:

  • 服务提供方、服务消费方紧耦合

  • 参数列表中的注解映射并不会继承,因此Controller中必须再次声明方法、参数列表、注解

方案二:抽取方式

将Feign的Client抽取为独立模块,并且把接口有关的POJO、默认的Feign配置都放到这个模块中,提供给所有消费者使用。

例如,将UserClient、User、Feign的默认配置都抽取到一个feign-api包中,所有微服务引用该依赖包,即可直接使用。

步骤一:抽取

首先创建一个module,命名为feign-api,在feign-api中然后引入feign的starter依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

然后,order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中

步骤二:在order-service中使用feign-api

首先,删除order-service中的UserClient、User、DefaultFeignConfiguration等类或接口。在order-service的pom文件中中引入feign-api的依赖:

<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

修改order-service中的所有与上述三个组件有关的导包部分,改成导入feign-api中的包

步骤三:重启测试

重启后,发现服务报错了:

这是因为UserClient现在在cn.itcast.feign.clients包下,而order-service的@EnableFeignClients注解是在cn.itcast.order包下,不在同一个包,无法扫描到UserClient。

步骤四:解决扫描包问题

方式一:指定Feign应该扫描的包:

@EnableFeignClients(basePackages = "cn.itcast.feign.clients")

方式二:指定需要加载的Client接口:

@EnableFeignClients(clients = {UserClient.class})

6.统一配置管理

①Nacos

Nacos除了可以做注册中心,同样可以做配置管理来使用。当微服务部署的实例越来越多,达到数十、数百时,逐个修改微服务配置就会让人抓狂,而且很容易出错。我们需要一种统一配置管理方案,可以集中管理所有实例的配置。

Nacos一方面可以将配置集中管理,另一方可以在配置变更时,及时通知微服务,实现配置的热更新。

❶统一配置管理

步骤一:在nacos中添加配置文件

1.在Nacos中添加配置信息 2.在弹出表单中填写配置信息

步骤二:从微服务拉取配置

微服务要拉取nacos中管理的配置,并且与本地的application.yml配置合并,才能完成项目启动。

但如果尚未读取application.yml,又如何得知nacos地址呢?

因此spring引入了一种新的配置文件:bootstrap.yaml文件,会在application.yml之前被读取,流程如下:

传统读取配置
nacos管理配置

1.引入Nacos的配置管理客户端依赖

<!--nacos配置管理依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

2.在userservice的resource目录添加一个bootstrap.yml文件,这个文件是引导文件,优先级高于application.yml:

spring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev #开发环境,这里是dev 
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名

这里会根据spring.cloud.nacos.server-addr获取nacos地址,再根据

${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}作为文件id,来读取配置。本例中,就是去读取userservice-dev.yaml

3.在user-service中的UserController中添加业务逻辑,读取pattern.dateformat配置

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Value("${pattern.dateformat}")
    private String dateformat;

    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }
}

访问页面http://127.0.0.1:8081/user/now即可看到时间

总结:将配置交给Nacos管理的步骤

  • ①在Nacos中添加配置文件

  • ②在微服务中引入nacos的config依赖

  • ③在微服务中添加bootstrap.yml,配置nacos地址、当前环境、服务名称、文件后缀名。

❷配置热更新

我们最终的目的,是修改nacos中的配置后,微服务无需重启即可让配置生效,也就是配置热更新

要实现配置热更新,可以使用两种方式:

方式一:通过 Spring Cloud 原生注解 @RefreshScope 实现配置自动更新

@RefreshScope //添加注解
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Value("${pattern.dateformat}")
    private String dateformat;

    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }
}

方式二:使用@ConfigurationProperties注解代替@Value注解

在user-service服务中,添加一个类,读取patterrn.dateformat属性:

@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}

在UserController中使用这个类代替@Value:

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private PatternProperties patternProperties;

    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
    }
}

❸配置共享

其实微服务启动时,会去nacos读取多个配置文件,例如:

  • [spring.application.name]-[spring.profiles.active].yaml,例如:userservice-dev.yaml

  • [spring.application.name].yaml,例如:userservice.yaml

[spring.application.name].yaml不包含环境,因此可以被多个环境共享。

例如:在nacos配置3个文件:userservice-dev.yaml、userservice-test.yaml、userservice.yaml

UserApplication(8081)使用的profile是dev,UserApplication2(8082)使用的profile是test,运行后不管是dev,还是test环境,都读取到了userservice.yaml中属性的值。

但是当nacos和服务本地同时出现相同属性时,优先级有高低之分:userservice-dev.yaml > userservice.yaml > application.yml

多服务共享配置

不同微服务之间可以共享配置文件,通过下面的两种方式来指定

方式一:

spring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev #开发环境,这里是dev
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
        shared-configs: # 多微服务间共享的配置列表
         - dataId: common.yaml # 要共享的配置文件id

方式二:

spring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev #开发环境,这里是dev
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
        extends-configs: # 多微服务间共享的配置列表
         - dataId: extend.yaml # 要共享的配置文件id

多种配置的优先级:

❹搭建Nacos集群

节点 ip port
nacos1 192.168.150.1 8845
nacos2 192.168.150.1 8846
nacos3 192.168.150.1 8847

⓵初始化数据库

Nacos默认数据存储在内嵌数据库Derby中,不属于生产可用的数据库。官方推荐的最佳实践是使用带有主从的高可用数据库集群。这里我们以单点的数据库为例。

首先新建一个数据库,命名为nacos,而后导入官方提供的SQL:nacos/schema.sql

⓶部署配置nacos

下载nacos后,进入nacos的conf目录,修改配置文件cluster.conf.example,重命名为cluster.conf

然后添加内容:

127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847

然后修改application.properties文件,添加数据库配置

spring.datasource.platform=mysql

db.num=1

db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=root

⓷启动nacos集群

将nacos文件夹复制三份,分别命名为:nacos1、nacos2、nacos3;然后分别修改三个文件夹中的application.properties

nacos1:

server.port=8845

nacos2:

server.port=8846

nacos3:

server.port=8847

然后分别启动三个nacos节点:startup.cmd

⓸nginx反向代理

下载nginx后,修改conf/nginx.conf文件,配置如下:

upstream nacos-cluster {
  server 127.0.0.1:8845;
    server 127.0.0.1:8846;
    server 127.0.0.1:8847;
}

server {
    listen       80;
    server_name  localhost;

    location /nacos {
        proxy_pass http://nacos-cluster;
    }
}

而后在浏览器访问:http://localhost/nacos即可。

代码中application.yml文件配置如下:

spring:
  cloud:
    nacos:
      server-addr: localhost:80 # Nacos地址

⓹优化

  • 实际部署时,需要给做反向代理的nginx服务器设置一个域名,这样后续如果有服务器迁移,nacos的客户端也无需更改配置

  • Nacos的各个节点应该部署到多个不同服务器,做好容灾和隔离

7.统一网关路由

①简介

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目,该项目是基于 Spring 5.0,Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关,它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。

Gateway网关是我们服务的守门神,所有微服务的统一入口。网关的核心功能特性

  • 路由和负载均衡
    • 一切请求都必须先经过gateway,但网关不处理业务,而是根据某种规则,把请求转发到某个微服务,这个过程叫做路由。当然路由的目标服务有多个时,还需要做负载均衡。
  • 权限控制
    • 网关作为微服务入口,需要校验用户是是否有请求资格,如果没有则进行拦截。
  • 限流
    • 当请求流量过高时,在网关中按照下流的微服务能够接受的速度来放行请求,避免服务压力过大。
架构图

在SpringCloud中网关的实现包括两种:

  • gateway
  • zuul

Zuul是基于Servlet的实现,属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux,属于响应式编程的实现,具备更好的性能。

②快速入门

下面,我们就演示下网关的基本路由功能。基本步骤如下:

  1. 创建新模块,引入网关依赖
  2. 编写启动类
  3. 编写基础配置和路由规则
  4. 启动网关服务进行测试

❶创建新模块,引入网关依赖

创建服务:

引入依赖:

<!--网关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos服务发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

❷编写启动类

@SpringBootApplication
public class GatewayApplication {

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

❸编写基础配置和路由规则

创建application.yml文件,内容如下:

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos地址
    gateway:
      routes: # 网关路由配置
        - id: user-service # 路由id,自定义,只要唯一即可
          # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
          uri: lb://userservice # 路由的目标地址 lb就是负载均衡,后面跟服务名称
          predicates: # 路由断言,也就是判断请求是否符合路由规则的条件
            - Path=/user/** # 这个是按照路径匹配,只要以/user/开头就符合要求

我们将符合Path 规则的一切请求,都代理到 uri参数指定的地址。

本例中,我们将 /user/**开头的请求,代理到lb://userservice,lb是负载均衡,根据服务名拉取服务列表,实现负载均衡。

❹启动网关服务进行测试

启动网关,访问http://localhost:10010/user/1时,符合/user/**规则,请求转发到uri:http://userservice/user/1,得到了结果:

整个访问的流程如下:

❺总结

网关搭建步骤:

  1. 创建项目,引入nacos服务发现和gateway依赖

  2. 配置application.yml,包括服务基本信息、nacos地址、路由

路由配置包括:

  1. 路由id:路由的唯一标示

  2. 路由目标(uri):路由的目标地址,http代表固定地址,lb代表根据服务名负载均衡

  3. 路由断言(predicates):判断路由的规则

  4. 路由过滤器(filters):对请求或响应做处理

③断言工厂

我们在配置文件中写的断言规则只是字符串,这些字符串会被Predicate Factory读取并处理,转变为路由判断的条件

例如Path=/user/**是按照路径匹配,这个规则是由

org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来

处理的,像这样的断言工厂在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 权重处理

我们只需要掌握Path这种路由工程就可以了。

④过滤工厂

GatewayFilter是网关中提供的一种过滤器,可以对进入网关的请求和微服务返回的响应做处理:

❶路由过滤器的种类

Spring提供了31种不同的路由过滤器工厂。例如:

名称 说明
AddRequestHeader 给当前请求添加一个请求头
RemoveRequestHeader 移除请求中的一个请求头
AddResponseHeader 给响应结果中添加一个响应头
RemoveResponseHeader 从响应结果中移除有一个响应头
RequestRateLimiter 限制请求的流量
…… ……

❷响应头过滤器

下面我们以AddResponseHeader 为例来讲解。

需求:给所有进入userservice的请求添加一个请求头:Truth=This is a test !

只需要修改gateway服务的application.yml文件,添加路由过滤即可:

spring:
  cloud:
    gateway:
      routes:
      - id: user-service 
        uri: lb://userservice 
        predicates: 
        - Path=/user/** 
      - id: order-service
        uri: lb://orderservice
        predicates:
        - Path=/order/**
        filters: # 过滤器
        - AddResponseHeader=Truth, This is a test! # 添加请求头

当前过滤器写在userservice路由下,因此仅仅对访问userservice的请求有效。

❸默认过滤器

如果要对所有的路由都生效,则可以将过滤器工厂写到default下。格式如下:

spring:
  cloud:
    gateway:
      routes:
      - id: user-service 
        uri: lb://userservice 
        predicates: 
        - Path=/user/**
      default-filters: # 默认过滤项
      - AddResponseHeader=Truth, This is a test! 

❹总结

过滤器的作用是什么?

  • ① 对路由的请求或响应做加工处理,比如添加请求头

  • ② 配置在路由下的过滤器只对当前路由的请求生效

defaultFilters的作用是什么?

  • ① 对所有路由都生效的过滤器

⑤全局过滤器

上一节学习的过滤器,网关提供了31种,但每一种过滤器的作用都是固定的。如果我们希望拦截请求,做自己的业务逻辑则没办法实现。

❶全局过滤器作用

全局过滤器的作用也是处理一切进入网关的请求和微服务响应,与GatewayFilter的作用一样。区别在于GatewayFilter通过配置定义,处理逻辑是固定的;而GlobalFilter的逻辑需要自己写代码实现。

定义方式是实现GlobalFilter接口。

public interface GlobalFilter {
    /**
     *  处理当前请求,有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理
     *
     * @param exchange 请求上下文,里面可以获取Request、Response等信息
     * @param chain 用来把请求委托给下一个过滤器 
     * @return {@code Mono<Void>} 返回标示当前过滤器业务结束
     */
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

在filter中编写自定义逻辑,可以实现下列功能:

  • 登录状态判断
  • 权限校验
  • 请求限流等

❷自定义全局过滤器

需求:定义全局过滤器,拦截请求,判断请求的参数是否满足下面条件:

  • 参数中是否有authorization,

  • authorization参数值是否为admin

  • 如果同时满足则放行,否则拦截

实现:在gateway中定义一个过滤器:

package cn.itcast.gateway.filters;

@Order(-1)
@Component
public class AuthorizeFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求参数
        MultiValueMap<String, String> params = exchange.getRequest().getQueryParams();
        // 2.获取authorization参数
        String auth = params.getFirst("authorization");
        // 3.校验
        if ("admin".equals(auth)) {
            // 放行
            return chain.filter(exchange);
        }
        // 4.拦截
        // 4.1.禁止访问,设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
        // 4.2.结束处理
        return exchange.getResponse().setComplete();
    }
}

❸过滤器执行顺序

请求进入网关会碰到三类过滤器:DefaultFilter、当前路由的过滤器、GlobalFilter

请求路由后,会将三个过滤器合并到一个过滤器链(集合)中,排序后依次执行每个过滤器:

排序的规则是什么呢?

  • 每一个过滤器都必须指定一个int类型的order值,order值越小,优先级越高,执行顺序越靠前
  • GlobalFilter通过实现Ordered接口,或者添加@Order注解来指定order值,由我们自己指定
  • 路由过滤器和defaultFilter的order由Spring指定,默认是按照声明顺序从1递增。
  • 当过滤器的order值一样时,会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。

详细内容,可以查看源码:

org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getFilters()方法是先加载defaultFilters,然后再加载某个route的filters,然后合并。

org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()方法会加载全局过滤器,与前面的过滤器合并后根据order排序,组织过滤器链

❹总结

全局过滤器的作用是什么?

  • 对所有路由都生效的过滤器,并且可以自定义处理逻辑

实现全局过滤器的步骤?

  • ①实现GlobalFilter接口

  • ②添加@Order注解或实现Ordered接口

  • ③编写处理逻辑

路由过滤器、defaultFilter、全局过滤器的执行顺序?

  • ①order值越小,优先级越高

  • ②当order值一样时,顺序是defaultFilter > 局部的路由过滤器 > 全局过滤器

⑥跨域问题

❶什么是跨域问题

跨域:域名不一致就是跨域,主要包括:

  • 域名不同: www.taobao.comwww.taobao.org

  • 域名相同,端口不同:localhost:8080localhost8081

跨域问题:浏览器禁止请求的发起者与服务端发生跨域ajax请求,请求被浏览器拦截的问题

解决方案:CORS。不知道的小伙伴可以查看https://www.ruanyifeng.com/blog/2016/04/cors.html

❷模拟跨域问题

编写一个页面,并在VScode中启动 live-server --port=8090

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<pre>这是一个测试!</pre>
</body>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
  axios.get("http://localhost:10010/user/1?authorization=admin")
  .then(resp => console.log(resp.data))
  .catch(err => console.log(err))
</script>
</html>

可以在浏览器控制台看到下面的错误:

localhost:8090访问localhost:10010,端口不同,显然是跨域的请求。

❸解决跨域问题

在gateway服务的application.yml文件中,添加下面的配置:

spring:
  cloud:
    gateway:
      # .......
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]': # 拦截一切请求
            allowedOrigins: # 允许哪些网站的跨域请求 
              - "http://localhost:8090"
              - "https://jwt1399.top"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期

Sponsor❤️

您的支持是我不断前进的动力,如果您感觉本文对您有所帮助的话,可以考虑打赏一下本文,用以维持本博客的运营费用,拒绝白嫖,从你我做起!🥰🥰🥰

支付宝 微信

文章作者: 简简
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 简简 !
评论
填上邮箱会收到评论回复提醒哦!!!
 本篇
SpringCloud-实用篇 SpringCloud-实用篇
实用篇包含微服务治理(注册发现,远程调用,配置管理,网关路由)、Docker技术、异步通信、分布式缓存、分布式搜索 小简从 0 开始学 Java 知识之 Java-学习路线 中的《SpringCloud-实用篇》,不定期更新所学笔记,期
2022-09-20
下一篇 
SpringBoot-整合篇 SpringBoot-整合篇
整合篇包含SpringBoot对各种第三方技术的整合。例如SQL、NoSQL、缓存、消息队列、定时任务、文档操作、认证授权、消息通知等等 小简从 0 开始学 Java 知识之 Java-学习路线 中的《SpringBoot-整合篇》,不
2022-09-15
  目录