SpringCloud学习之旅

已于 2022-02-20 17:06:36 修改
阅读量495 收藏
点赞数
分类专栏： java 文章标签： java
于 2020-12-24 12:21:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49349430/article/details/111619307
版权

1587880250279

Author：Eric

Version：9.0.0

文章目录

一、SpringCloud介绍

1.1 微服务架构

微服务架构的提出者：马丁福勒

https://martinfowler.com/articles/microservices.html

简而言之，微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法，每个小服务都在自己的进程中运行并与轻量级机制（通常是HTTP资源API）进行通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有，它可以用不同的编程语言编写并使用不同的数据存储技术。

1、 微服务架构只是一个样式，一个风格。

2、 将一个完成的项目，拆分成多个模块去分别开发。

3、 每一个模块都是单独的运行在自己的容器中。

4、 每一个模块都是需要相互通讯的。 Http，RPC，MQ。

5、 每一个模块之间是没有依赖关系的，单独的部署。

6、 可以使用多种语言去开发不同的模块。

7、 使用MySQL数据库，Redis，ES去存储数据，也可以使用多个MySQL数据库。

总结：将复杂臃肿的单体应用进行细粒度的划分，每个拆分出来的服务各自打包部署。

1.2 SpringCloud介绍

  • SpringCloud是微服务架构落地的一套技术栈。

  • SpringCloud中的大多数技术都是基于Netflix公司的技术进行二次研发。

  • SpringCloud的中文社区网站：http://springcloud.cn/

  • SpringCloud的中文网：http://springcloud.cc/

  • 八个技术点：

    • Eureka - 服务的注册与发现
    • Ribbon - 服务之间的负载均衡
    • Feign - 服务之间的通讯
    • Hystrix - 服务的线程隔离以及断路器
    • Zuul - 服务网关
    • Stream - 实现MQ的使用
    • Config - 动态配置
    • Sleuth - 服务追踪

二、服务的注册与发现-Eureka【重点】

2.1 引言

Eureka就是帮助我们维护所有服务的信息，以便服务之间的相互调用

Eureka
1587887319057
2.2 Eureka的快速入门
2.2.1 创建EurekaServer

创建一个父工程，并且在父工程中指定SpringCloud的版本，并且将packaing修改为pom

<packaging>pom</packaging>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

创建eureka的server，创建SpringBoot工程，并且导入依赖，在启动类中添加注解，编写yml文件

导入依赖

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

启动类添加注解

@SpringBootApplication
@EnableEurekaServer //服务端的启动类，可以接受别人注册进来
public class EurekaApplication {

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

}

编写yml配置文件

server:
  port: 8761      # 端口号
#Eureka配置
eureka:
  instance:
    hostname: localhost   # Eureka服务器的实例名称
  client:
    # 当前的eureka服务是单机版的
    registerWithEureka: false  #表示是否向Eureka注册中心注册自己
    fetchRegistry: false   #fetchRegistry如果为false，则表示自己为注册中心
    serviceUrl: #与Eureka服务中心交互的地址，就是监控页面
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
2.2.2 创建EurekaClient

创建Maven工程，修改为SpringBoot

导入依赖

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

在启动类上添加注解

@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到Eureka中
public class CustomerApplication {

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

}

编写配置文件

# 指定Eureka服务地址，当前服务注册到Eureka服务端
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

#指定服务的名称
spring:
  application:
    name: CUSTOMER

1587912052479

2.2.3 测试Eureka

创建了一个Search搜索模块，并且注册到Eureka

使用到EurekaClient的对象去获取服务信息

//在search模块
@RestController
public class SearchController {
    @Autowired
    private EurekaClient eurekaClient;

    @GetMapping("/search")
    public String search(){
        return "search";
    }
}

在customer模块，正常RestTemplate调用即可

@RestController
public class CustomerController {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private EurekaClient eurekaClient;

    @RequestMapping("/customer")
    public String show() {
        //1.通过eurekaclient获取SEARCH服务的信息
        InstanceInfo info = eurekaClient.getNextServerFromEureka("SEARCH", false);

        //2.获取访问的地址
        String url = info.getHomePageUrl();
        System.out.println(url);//http:localhost:8082

        //3.通过restTemplate访问
        String result = restTemplate.getForObject(url + "/search", String.class);

        return result;
    }
}

修改customer的启动类

@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到Eureka中
public class SpringCloudCustomer02Application {

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

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
2.3 Eureka的安全性

实现Eureka认证

导入依赖

<!--eureka认证-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

编写配置类

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 忽略掉/eureka/**
        http.csrf().ignoringAntMatchers("/eureka/**");
        super.configure(http);
    }
}

编写配置文件

# 指定用户名和密码
spring:
  security:
    user:
      name: root
      password: root

其他服务想注册到Eureka上需要添加用户名和密码

eureka:
  client:
    service-url:
      defaultZone: http://用户名:密码@localhost:8761/eureka
2.4 Eureka的高可用

如果程序的正在运行，突然Eureka宕机了。

  • 如果调用方访问过一次被调用方了，Eureka的宕机不会影响到功能。

  • 如果调用方没有访问过被调用方，Eureka的宕机就会造成当前功能不可用。

搭建Eureka高可用

准备多台Eureka

采用了复制的方式，删除iml和target文件，并且修改pom.xml中的项目名称，再给父工程添加一个module

让服务注册到多台Eureka

eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

让多台Eureka之间相互通讯

eureka:
  client:
    registerWithEureka: true      # 注册到Eureka上
    fetchRegistry: true           # 从Eureka拉取信息
    serviceUrl:
      defaultZone: http://root:root@localhost:8762/eureka/

Eureka01的yml文件

server:
  port: 8761  # 端口号

eureka:
  instance:
    hostname: localhost  # Eureka服务器的实例名称
  client:
    # 当前的eureka服务是单机版的
    register-with-eureka: true  #表示是否向Eureka注册中心注册自己
    fetch-registry: true  #fetchRegistry如果为false，则表示自己为注册中心
    service-url:  #与Eureka服务中心交互的地址，就是监控页面
      defaultZone: http://root:root@localhost:8762/eureka/

#eureka认证
spring:
  security:
    user:
      name: root
      password: root
  application:
    name: EUREKA1-8761

Eureka02的yml文件

server:
  port: 8762  # 端口号

eureka:
  instance:
    hostname: localhost  # Eureka服务器的实例名称
  client:
    # 当前的eureka服务是单机版的
    register-with-eureka: true  #表示是否向Eureka注册中心注册自己
    fetch-registry: true  #fetchRegistry如果为false，则表示自己为注册中心
    service-url:  #与Eureka服务中心交互的地址，就是监控页面
      defaultZone: http://root:root@localhost:8761/eureka/

#eureka认证
spring:
  security:
    user:
      name: root
      password: root
  application:
    name: EUREKA2-8762

customer的yml文件

# 指定Eureka服务地址，当前服务注册到Eureka服务端
eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

#指定服务的名称
spring:
  application:
    name: CUSTOMER

search的yml文件

server:
  port: 8082

spring:
  application:
    name: SEARCH

eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
2.5 Eureka的细节

EurekaClient启动时，将自己的信息注册到EurekaServer上，EurekaSever就会存储上EurekaClient的注册信息。

当EurekaClient调用服务时，本地没有注册信息的缓存时，去EurekaServer中去获取注册信息。

EurekaClient会通过心跳的方式去和EurekaServer进行连接。（默认30sEurekaClient会发送一次心跳请求，如果超过了90s还没有发送心跳信息的话，EurekaServer就认为你宕机了，将当前EurekaClient从注册表中移除）

eureka:
  instance:
    lease-renewal-interval-in-seconds: 30      #心跳的间隔
    lease-expiration-duration-in-seconds: 90    # 多久没发送，就认为你宕机了

EurekaClient会每隔30s去EurekaServer中去更新本地的注册表

eureka:
  client:
    registry-fetch-interval-seconds: 30 # 每隔多久去更新一下本地的注册表缓存信息

Eureka的自我保护机制，统计15分钟内，如果一个服务的心跳发送比例低于85%，EurekaServer就会开启自我保护机制

  • 不会从EurekaServer中去移除长时间没有收到心跳的服务。
  • EurekaServer还是可以正常提供服务的。
  • 网络比较稳定时，EurekaServer才会开始将自己的信息被其他节点同步过去
eureka:
  server:
    enable-self-preservation: true  # 开启自我保护机制

CAP定理，C - 一致性，A-可用性，P-分区容错性，这三个特性在分布式环境下，只能满足2个，而且分区容错性在分布式环境下，是必须要满足的，只能在AC之间进行权衡。

如果选择CP，保证了一致性，可能会造成你系统在一定时间内是不可用的，如果你同步数据的时间比较长，造成的损失大。

Eureka就是一个AP的效果，高可用的集群，Eureka集群是无中心，Eureka即便宕机几个也不会影响系统的使用，不需要重新的去推举一个master，也会导致一定时间内数据是不一致。

三、服务间的负载均衡-Ribbon【重点】

3.1 引言

Ribbon是帮助我们实现服务和服务负载均衡，Ribbon属于客户端负载均衡

客户端负载均衡：customer客户模块，将2个Search模块信息全部拉取到本地的缓存，在customer中自己做一个负载均衡的策略，选中某一个服务。

服务端负载均衡：在注册中心中，直接根据你指定的负载均衡策略，帮你选中一个指定的服务信息，并返回。

Ribbon
1587977965492
3.2 Ribbon的快速入门

启动两个search模块 vm options设置值为-Dserver.port=8082

在customer导入ribbon依赖

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

配置整合RestTemplate和Ribbon

//配置负载均衡实现RestTemplate
@Bean
@LoadBalanced //Ribbon设置负载均衡，默认轮询方式
public RestTemplate restTemplate(){
    return new RestTemplate();
}

在customer中去访问search

@GetMapping("/customer")
public String customer(){
    String result = restTemplate.getForObject("http://SEARCH/search", String.class);

    //4. 返回
    return result;
}

在IDEA加一个测试端口操作

![image-20201102174115898](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201102174115898.png)

![image-20201102174014707](https://gitee.com/com_mallow/pictures/raw/master/img/image-20201102174014707.png)
3.3 Ribbon配置负载均衡策略

负载均衡策略

  • RandomRule：随机策略
  • RoundRibbonRule：轮询策略
  • WeightedResponseTimeRule：默认会采用轮询的策略，后续会根据服务的响应时间，自动给你分配权重
  • BestAvailableRule：根据被调用方并发数最小的去分配
  • RetryRule：会先按照轮询获取服务，如果获取失败，则会在指定时间内进行重试

采用注解的形式，所有的服务都采用这个负载均衡策略

@Bean
public IRule ribbonRule(){
    return new RandomRule();
}

配置文件去指定负载均衡的策略（推荐）

# 指定具体服务的负载均衡策略
SEARCH:      # 编写服务名称
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule  # 具体负载均衡使用的类,设置策略的实现类全路径名

四、服务间的调用-Feign【重点】

4.1 引言

Feign可以帮助我们实现面向接口编程，就直接调用其他的服务，简化开发。是在客户端

4.2 Feign的快速入门

导入依赖

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

在启动类添加一个注解

@EnableFeignClients

创建一个接口，并且和Search模块做映射

@FeignClient("SEARCH")   // 指定服务名称
public interface SearchClient {
    
    // value -> 目标服务的请求路径，method -> 映射请求方式
    @RequestMapping(value = "/search",method = RequestMethod.GET)
    String search();

}

测试使用

@Autowired
private SearchClient searchClient;

@GetMapping("/customer")
public String customer(){
    String result = searchClient.search();
    return result;
}

fegin底层使用了ribbon作为负载均衡

SEARCH:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
4.3 Feign的传递参数方式

注意事项

  • 如果你传递的参数，比较复杂时，默认会采用POST的请求方式。
  • 传递单个参数时，推荐使用@PathVariable，如果传递的单个参数比较多，这里也可以采用@RequestParam，不要省略value属性
  • 传递对象信息时，统一采用json的方式，添加@RequestBody
  • Client接口必须采用@RequestMapping

在Search模块下准备三个接口

@GetMapping("/search/{id}")
public Customer findById(@PathVariable("id") Integer id){
    return new Customer(id,"张三",23);
}

@GetMapping("/getCustomer")
public Customer getCustomer(@RequestParam("id") Integer id,@RequestParam("name") String name){
    return new Customer(id,name,25);
}

@PostMapping("/save") //对象           
public Customer save(@RequestBody Customer customer){
    return customer;
}

封装Customer模块下的Controller

@GetMapping("/customer/{id}")
public Customer findById(@PathVariable("id") Integer id){
    return searchClient.findById(id);
}

@GetMapping("/getCustomer")
public Customer getCustomer(@RequestParam("id") Integer id, @RequestParam("name") String name){
    return searchClient.getCustomer(id,name);
}

@GetMapping("/save")            // 会自动转换为POST请求  405
public Customer save(@RequestBody Customer customer){
    return searchClient.save(customer);
}

Customer模块再封装Client接口

@RequestMapping(value = "/search/{id}",method = RequestMethod.GET)//占位符
Customer findById(@PathVariable(value = "id") Integer id);

@RequestMapping(value = "/getCustomer",method = RequestMethod.GET)
Customer getCustomer(@RequestParam(value = "id") Integer id, @RequestParam(value = "name") String name);//多个参数

@RequestMapping(value = "/save",method = RequestMethod.POST)
Customer save(@RequestBody Customer customer);//对象，默认有@RequestBody

测试

image-20201102200236073

image-20201102200155922

image-20201102204348396

4.4 Feign的Fallback

Fallback可以帮助我们在使用Feign去调用另外一个服务时，如果出现了问题，走服务降级，返回一个错误数据，避免功能因为一个服务出现问题，全部失效。

4.4.1 FallBack方式

创建一个POJO类，实现Client接口。

@Component
public class SearchClientFallBack implements SearchClient {
    @Override
    public String search() {
        return "出现问题啦！！！";
    }

    @Override
    public Customer findById(Integer id) {
        return null;
    }

    @Override
    public Customer getCustomer(Integer id, String name) {
        return null;
    }

    @Override
    public Customer save(Customer customer) {
        return null;
    }
}

修改CLient接口中的注解，添加一个属性。

@FeignClient(value = "SEARCH",fallback = SearchClientFallBack.class)

customer模块的yml文件添加一个配置文件。

# feign和hystrix组件整合
feign:
  hystrix:
    enabled: true
4.4.1 FallBackFactory方式

调用方无法知道具体的错误信息是什么，通过FallBackFactory的方式去实现这个功能

FallBackFactory基于Fallback

创建一个POJO类，实现FallBackFactory

@Component
public class SearchClientFallBackFactory implements FallbackFactory<SearchClient> {

    @Autowired
    private SearchClientFallBack searchClientFallBack;

    @Override
    public SearchClient create(Throwable throwable) {
        throwable.printStackTrace();
        return searchClientFallBack;
    }
}

修改Client接口中的属性

@FeignClient(value = "SEARCH",fallbackFactory = SearchClientFallBackFactory.class)

五、服务的隔离及断路器-Hystrix【重点】

5.1 引言
Hystrix
1588044427589
5.2 降级机制实现

导入依赖

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

启动类添加一个注解

@EnableCircuitBreaker

在CustomerController中针对某一个接口去编写他的降级方法

@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack")
public Customer findById(@PathVariable Integer id){
    int i = 1/0;
    return searchClient.findById(id);
}

// findById的降级方法  方法的描述要和接口一致
public Customer findByIdFallBack(Integer id){
    return new Customer(-1,"",0);
}

在接口的方法添加注解，在接口上加注解会一直降级

@HystrixCommand(fallbackMethod = "findByIdFallBack")

5、 测试一下

效果
1588048924123
5.3 线程隔离

如果使用Tomcat的线程池去接收用户的请求，使用当前线程去执行其他服务的功能，如果某一个服务出现了故障，导致tomcat的线程大量的堆积，导致Tomcat无法处理其他业务功能。

  • Hystrix的线程池（默认），接收用户请求采用tomcat的线程池，执行业务代码，调用其他服务时，采用Hystrix的线程池。
  • 信号量，使用的还是Tomcat的线程池，帮助我们去管理Tomcat的线程池。

Hystrix的线程池的配置（具体配置的name属性要查看HystixCommandProperties类）

配置信息namevalue
线程隔离策略execution.isolation.strategyTHREAD //线程池
指定超时时间execution.isolation.thread.timeoutInMilliseconds1000
是否开启超时时间配置execution.timeout.enabledtrue
超时之后是否中断线程execution.isolation.thread.interruptOnTimeouttrue
取消任务后是否中断线程execution.isolation.thread.interruptOnCancelfalse

代码实现

@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack",commandProperties = {
        @HystrixProperty(name = "execution.isolation.strategy",value = "THREAD"),
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000")//超时时间
})
public Customer findById(@PathVariable Integer id) throws InterruptedException {
    System.out.println(Thread.currentThread().getName());//输出线程名称
    Thread.sleep(3000);
    return searchClient.findById(id);
}

信号量的配置信息

配置信息namevalue
线程隔离策略execution.isolation.strategySEMAPHORE //信号量
指定信号量的最大并发请求数execution.isolation.semaphore.maxConcurrentRequests10

代码实现

@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack",commandProperties = {
        @HystrixProperty(name = "execution.isolation.strategy",value = "SEMAPHORE")
})//信号量
public Customer findById(@PathVariable Integer id) throws InterruptedException {
    System.out.println(Thread.currentThread().getName());
    return searchClient.findById(id);
}

熔断

在search模块的controller，在customer模块调用

    @Value("${server.port}")//有两个端口8082，8083
    private Integer port;

    @HystrixCommand(fallbackMethod = "searchHystrix")//
    @GetMapping("/search")
    public String search() {//发生异常时采用下面的方法响应
        int i = 1 / 0;
        return "search:" + port;
    }

    public String searchHystrix() {
        return "出现问题了，端口为:" + port;
    }
5.4 断路器
5.4.1 断路器介绍

马丁福勒断路器论文：https://martinfowler.com/bliki/CircuitBreaker.html

在调用指定服务时，如果说这个服务的失败率达到你输入的一个阈值，将断路器从closed状态，转变为open状态，指定服务时无法被访问的，如果你访问就直接走fallback方法，在一定的时间内，open状态会再次转变为half open状态，允许一个请求发送到我的指定服务，如果成功，转变为closed，如果失败，服务再次转变为open状态，会再次循环到half open，直到断路器回到一个closed状态。

断路器
1588075354295
5.4.2 配置断路器的监控界面

导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

在启动类中添加注解

@EnableHystrixDashboard

配置一个Servlet路径，指定上Hystrix的Servlet

@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet {
}

//------------------------------------------------------------
// 在启动类上，添加扫描Servlet的注解
@ServletComponentScan("com.qf.servlet")

测试直接访问http://host:port/hystrix

监控界面
1588078651357

在当前位置输入映射好的servlet路径

检测效果
1588078701738
5.4.3 配置断路器的属性

断路器的属性（默认10s秒之内请求数）

配置信息namevalue
断路器的开关circuitBreaker.enabledtrue
失败阈值的总请求数circuitBreaker.requestVolumeThreshold20
请求总数失败率达到%多少时circuitBreaker.errorThresholdPercentage50
断路器open状态后，多少秒是拒绝请求的circuitBreaker.sleepWindowInMilliseconds5000
强制让服务拒绝请求circuitBreaker.forceOpenfalse
强制让服务接收请求circuitBreaker.forceClosedfalse

具体配置方式

@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack",commandProperties = {
    @HystrixProperty(name = "circuitBreaker.enabled",value = "true"),
    @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"),//总请求数
    @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "70"),//失败率
    @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "5000")//
})
public Customer findById(@PathVariable Integer id) throws InterruptedException {
        System.out.println(Thread.currentThread().getName());
        if(id==1){
            int i = 1/0;
        }
//        Thread.sleep(3000);
//        int i=1/0;
        return searchClient.findById(id);
    }
5.5 请求缓存
5.5.1 请求缓存介绍

  • 请求缓存的生命周期是一次请求，不同的请求会被覆盖

  • 请求缓存是缓存当前线程中的一个方法，将方法参数作为key，方法的返回结果作为value

  • 在一次请求中，目标方法被调用过一次，以后就都会被缓存。

请求缓存
1588127678866
5.5.2 请求缓存的实现

创建一个Service，在Service中调用Search服务。

@Service
public class CustomerService {

    @Autowired
    private SearchClient searchClient;

 
    @CacheResult //返回缓存
    @HystrixCommand(commandKey = "findById")//标识
    public Customer findById(@CacheKey Integer id) throws InterruptedException {
        return searchClient.findById(id);
    }

    @CacheRemove(commandKey = "findById") //清除缓存，将刚刚存进去的缓存清除
    @HystrixCommand
    public void clearFindById(@CacheKey Integer id){
        System.out.println("findById被清空");
    }

}

使用请求缓存的注解

@CacheResult：帮助我们缓存当前方法的返回结果（必须@HystrixCommand配合使用）
@CacheRemove：帮助我们清除某一个缓存信息（基于commandKey）
@CacheKey：指定哪个方法参数作为缓存的标识

修改Search模块的返回结果

return new Customer(1,"张三",(int)(Math.random() * 100000));

编写Filter，去构建HystrixRequestContext

@WebFilter("/*")
public class HystrixRequestContextInitFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //每来一次新的请求，都清空缓存
        HystrixRequestContext.initializeContext();
        //放行
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

Customer项目启动类加上扫描filter包 @ServletComponentScan({“com.qf.customer.servlet”,“com.qf.customer.filter”})

修改Controller

public Customer findById(@PathVariable Integer id) throws InterruptedException {
    System.out.println(customerService.findById(id));
    System.out.println(customerService.findById(id));
    customerService.clearFindById(id);
    System.out.println(customerService.findById(id));
    System.out.println(customerService.findById(id));
    return searchClient.findById(id);
}

测试结果

1588133189886

六、服务的网关-Zuul【重点】

6.1 引言
  • 客户端维护大量的ip和port信息，直接访问指定服务
  • 认证和授权操作，需要在每一个模块中都添加认证和授权的操作
  • 项目的迭代，服务要拆分，服务要合并，需要客户端进行大量的变化
  • 统一的把安全性校验都放在Zuul中
  • Zuul=route+filter
zuul
1588145514669
6.2 Zuul的快速入门

创建Maven项目，修改为SpringBoot

导入依赖

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

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

启动类添加一个注解

@EnableEurekaClient
@EnableZuulProxy

编写配置文件

# 指定Eureka服务地址
eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

#指定服务的名称
spring:
  application:
    name: ZUUL

server:
  port: 80

直接测试

测试效果
1588148029538
6.3 Zuul常用配置信息
6.3.1 Zuul的监控界面

导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

编写配置文件

# 查看zuul的监控界面（开发时，配置为*，上线，不要配置）
management:
  endpoints:
    web:
      exposure:
        include: "*"

直接访问 localhost/actuator/routes

1588157803975

6.3.2 忽略服务配置
# zuul的配置
zuul:
  # 基于服务名忽略服务，无法查看 ，如果要忽略全部的默认服务，ignored-services可以配置"*"，但对自定义服务的配置，是无法忽略的
  # ignored-patterns 对自定义服务的配置，是可以忽略的
  ignored-services: eureka
  # 监控界面依然可以查看，在访问的时候，404，地址的忽略方法会忽略自定义的服务配置
  ignored-patterns: /**/search/**

测试，访问http://localhost/search/search/2，会报404

6.3.3 自定义服务配置
# zuul的配置
zuul:
  # 指定自定义服务(方式一 ， key（服务名）：value（路径）)
#  routes:
#    search: /ss/**
#    customer: /cc/**
  # 指定自定义服务(方式二)
  routes:
    kehu:   # 自定义名称
      path: /ccc/**     # 映射的路径
      serviceId: customer   # 服务名称
6.3.4 灰度发布

旧版和新版本都发布，一部分访问新的，一部分访问旧版本，待新版本ok将旧版的访问全都引入新版本

在Zuul的启动类中添加一个配置类

@Bean
public PatternServiceRouteMapper serviceRouteMapper() {
    return new PatternServiceRouteMapper(
        "(?<name>^.+)-(?<version>v.+$)",
        "${version}/${name}");
}

在Customer模块中的application.yml文档编写如下配置

version: v1

#指定服务的名称
spring:
  application:
    name: CUSTOMER-${version}

再复制一个Customer服务，VM options=-Dversion=v2 -Dserver.port=9001

修改Zuul的配置

# zuul的配置
zuul:
  # 基于服务名忽略服务，无法查看  ， 如果需要用到-v的方式，一定要去掉
  # ignored-services: "*"

CustomerController代码

    @Value("${version}")
    private String version;


    @GetMapping("/version")
    public String version() throws InterruptedException {
        return version;
    }

测试

测试效果
1588165064217
6.4 Zuul的过滤器执行流程 routes filter

客户端请求发送到Zuul服务上，首先通过PreFilter链，如果登录，认证等正常放行，会把请求再次转发给RoutingFilter，请求转发到一个指定的服务，在指定的服务响应一个结果之后，再次走一个PostFilter的过滤器链，最终再将响应信息交给客户端。

过滤器
1588172828199
6.5 Zuul过滤器入门

创建POJO类，继承ZuulFilter抽象类

@Component //交由Spring管理
public class TestZuulFilter extends ZuulFilter {}

指定当前过滤器的类型

@Override
public String filterType() {
    return FilterConstants.PRE_TYPE;
}

指定过滤器的执行顺序，数值越小，优先级越高，前提条件是同一类型的过滤器而言

@Override
public int filterOrder() {
    return FilterConstants.PRE_DECORATION_FILTER_ORDER - 1;
}

配置是否启用，是否使用当前过滤器

@Override
public boolean shouldFilter() {
    // 开启当前过滤器
    return true;
}

指定过滤器中的具体业务代码

@Override
public Object run() throws ZuulException {
    System.out.println("prefix过滤器执行~~~");
    return null;
}

测试

效果
1588175034889
6.6 PreFilter实现token校验

准备访问路径，请求参数传递token

http://localhost/v1/customer/version?token=123

创建AuthenticationFilter

@Component
public class AuthenticationFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        return PRE_DECORATION_FILTER_ORDER - 2;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        //..
    }
    
}

在run方法中编写具体的业务逻辑代码

@Override
public Object run() throws ZuulException {
    //1. 获取Request对象
    RequestContext requestContext = RequestContext.getCurrentContext();
    //得到httpServletRequest对象
    HttpServletRequest request = requestContext.getRequest();

    //2. 获取token参数
    String token = request.getParameter("token");

    //3. 对比token
    if(token == null || !"123".equalsIgnoreCase(token)) {
        //不继续往下执行
        requestContext.setSendZuulResponse(false);
        //4. token校验失败，直接响应数据，返回状态码401,404...
        requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
    }
    return null;
}

测试

效果
image-20201103191306094
6.7 Zuul的降级

创建POJO类，实现接口FallbackProvider

@Component //交由Spring管理
public class ZuulFallBack implements FallbackProvider {}

重写两个方法

@Override//设置出现问题的服务需要走降级的处理
public String getRoute() {
    return "*";   // 代表指定全部出现问题的服务，都走这个降级方法
}

@Override//
public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
    System.out.println("降级的服务：" + route);
    cause.printStackTrace();//错误信息

    return new ClientHttpResponse() {
        @Override
        public HttpStatus getStatusCode() throws IOException {
            // 指定具体的HttpStatus
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }

        @Override
        public int getRawStatusCode() throws IOException {
            // 返回的状态码
            return HttpStatus.INTERNAL_SERVER_ERROR.value();
        }

        @Override//返回文本
        public String getStatusText() throws IOException {
            // 指定错误信息
            return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase();
        }

        @Override
        public void close() {

        }

        @Override//兜底数据
        public InputStream getBody() throws IOException {
            // 给用户响应的信息
            String msg = "当前服务：" + route + "出现问题！！！";
            return new ByteArrayInputStream(msg.getBytes());
        }

        @Override
        public HttpHeaders getHeaders() {
            // 指定响应头信息
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            return headers;
        }
    };
}

测试

效果
1588180538336
6.8 Zuul动态路由

不用在yml文件修改配置，在程序中设置

创建一个过滤器,执行顺序最好放在Pre过滤器的最后面

@Component
public class DynamicRouting extends ZuulFilter {
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;//前置过滤器
    }

    @Override//执行顺序
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER+2;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();
		//自定义名称
        String redisKey = request.getParameter("redisKey");
        if(redisKey!=null && "customer".equals(redisKey)){
            //如果携带的redisKey是customer，则跳转到以下地址
            // http://localhost:8080/customer
            requestContext.put(FilterConstants.SERVICE_ID_KEY,"customer-v1");//相当于Zuul的yml配置中的serviceId
            requestContext.put(FilterConstants.REQUEST_URI_KEY,"/customer");//地址，相当于Zuul的yml配置中的path
        }else if(redisKey!=null && "search".equals(redisKey)){
            // http://localhost:8081/search/1
            requestContext.put(FilterConstants.SERVICE_ID_KEY,"search");
            requestContext.put(FilterConstants.REQUEST_URI_KEY,"/search/1");
        }
        return null;
    }
}

测试

效果
1588185307172

七、多语言支持-Sidecar

相当于代理微服务

7.1 引言

在SpringCloud的项目中，需要接入一些非Java的程序，第三方接口，无法接入eureka，hystrix，feign等等组件。启动一个代理的微服务，代理微服务去和非Java的程序或第三方接口交流，通过代理的微服务去接入SpringCloud的相关组件。

sidecar
1588234895867
7.2 Sidecar实现
7.2.1 创建一个第三方的服务，创建一个SpringBoot工程 other_serivce

在application.properties文件中配置项目的端口号

server.port=7001

编写Controller

@RestController
public class TestController {

    @GetMapping("/list")
    public String list(){
        return "other-service:list";
    }
}
7.2.2 创建maven工程06_sidecar，修改为SpringBoot

导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-netflix-sidecar</artifactId>
</dependency>

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

启动类添加注解@EnableSidecar，访注解为复合注解，这个注解包括@EnableCircuitBreaker，@EnableDiscoveryClient，和@EnableZuulProxy

@EnableSidecar

编写配置文件

server:
  port: 81

# 指定Eureka服务地址
eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
# 指定服务名称
spring:
  application:
    name: sidecar

# 指定代理的第三方服务
sidecar:
  port: 7001
7.3.3 Customer项目中添加Feign和Controller

Feign的编写

@FeignClient("SIDECAR")
public interface OtherSeriviceFeign {

    @GetMapping("/list")
    String list();
}

Controller中的编写

    @Autowired
    private OtherSeriviceFeign otherSeriviceFeign;

    @GetMapping("/list")
    public String list(){
        return otherSeriviceFeign.list();
    }

通过customer通过feign调用第三方服务

效果
1588237130846

八、服务间消息传递-Stream

8.1 引言

Stream就是在消息队列的基础上，对其进行封装，让咱们更方便的去操作MQ消息队列。

效果
1588245420362
8.2 Stream快速入门,服务间的消息传递

启动RabbitMQ

在Search项目中添加消费者-导入依赖

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

消费者-配置文件

spring:
  # 连接RabbitMQ
  rabbitmq:
    host: 192.168.206.142
    port: 5672
    username: test
    password: 123
    virtual-host: /test

创建消息通道绑定的接口 @Input接口表示作为消息的消费者，监听的是myMessage的交换机。Spring会自动帮我们创建队列并绑定到交换机上。

public interface StreamClient {
    @Input("myMessage")//交换机名称，指定消息的消费者，会自动创建队列绑定到这个交换机
    SubscribableChannel input();//订阅通道
}

创建 监听类来监听队列，获取消息。@EnableBinding注解绑定定义了 @Input注解的接口，以此实现对消息通道（Channel）的绑定。@StreamListener用在方法上，用来监听指定的交换机，因为会默认创建一个队列绑定到交换机，所以监听交换机实际上就是监听队列

@Component
@EnableBinding(StreamClient.class)//绑定消息通道接口
public class StreamReceiver {
    
    @StreamListener("myMessage")//监听消息，写交换机名称，实际是消费队列
    public void msg(Object msg){
        System.out.println("接收到消息： " + msg);
    }
}

生产者-导入依赖

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

生产者-配置文件

spring:
  # 连接RabbitMQ
  rabbitmq:
    host: 192.168.199.109
    port: 5672
    username: test
    password: test
    virtual-host: /test

创建消息通道绑定的接口 @Output注解表示作为消息的生产者，会将消息发送到名称为myMessage的交换机

public interface StreamClient {
    @Output("myMessage")//消息生产者
    MessageChannel output();
}

启动类添加注解 ,绑定定义了 @Output注解的接口，以此实现对消息通道（Channel）的绑定

@EnableBinding(StreamClient.class)

Controller的实现

@RestController
public class MessageController {

    @Autowired
    private StreamClient streamClient;

    @GetMapping("/send")
    public String send(){
        streamClient.output().send(MessageBuilder.withPayload("hello,Stream!!").build());
        return "消息发送成功";
    }
}
8.3 Stream重复消费问题

在消费方Search项目中需要添加一个配置，指定消费者组

指定消费者组后，只会有一个消费者接收和消费。所以之前会出现重复消费的问题，是由于默认情况下，任何消费者都会产生一个匿名消费组，所以每个消费者实例都会有自己的消费组，从而当有消息发送的时候，就形成了广播的模式。

spring:
  cloud:
    stream:
      bindings:
        myMessage:				# 队列名称(交换机名称)
          group: customer      # 消费者组，自定义名称
8.4 Stream的消费者手动ack

在Search项目编写配置

spring:
  cloud:
    stream:
      # 实现手动ACK
      rabbit:
        bindings:
          myMessage: #交换机名称
            consumer: #消费者
              acknowledgeMode: MANUAL

image-20201104165408190

Search项目修改消费端方法

@StreamListener("myMessage")
public void msg(Object msg,
                @Header(name = AmqpHeaders.CHANNEL) Channel channel,
                @Header(name = AmqpHeaders.DELIVERY_TAG) Long deliveryTag) throws IOException {
    System.out.println("接收到消息： " + msg);
    //手动ack
    channel.basicAck(deliveryTag,false);
}

九、服务的动态配置-Config【重点】

9.1 引言

  • 配置文件分散在不同的项目中，不方便维护。

  • 配置文件的安全问题。

  • 修改完配置文件，无法立即生效。

config
1588257620824
9.2 搭建Config-Server

创建Maven工程，修改为SpringBoot

导入依赖

<!--Config-Server的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>
<!--Eureka客户端的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

启动类添加注解

@EnableConfigServer

编写配置文件（Git的操作）

spring:
  cloud:
    config:
      server:
        git:
          basedir: D:\basedir    # 本地仓库的地址
          username: chenzetao666    #  远程仓库用户名
          password: czt136204   #   远程仓库密码
          uri: https://gitee.com/chenzetao666/config_test.git       # 远程仓库地址

http访问格式

/ {application} / {profile} [/ {label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

测试（http://localhost:port/{label}/{application}-{profile}.yml）

效果
1588260114740
9.3 搭建Config-Client

customer模块导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-client</artifactId>
</dependency>

编写配置文件

# 指定Eureka服务地址
eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

#指定服务的名称
spring:
  application:
    name: CUSTOMER-${version}
  cloud:
    config:
      discovery:
        enabled: true
        service-id: CONFIG
      profile: dev  #拼接，构成完整的名称，customer-v1-dev.yml

version: v1


# CONFIG -> CUSTOMER-v1-dev.yml

修改配置名称

修改为bootstrap.yml 
//最优先读取bootstrap.yml 文件，再读取application.yml文件

测试发布消息到RabbitMQ

效果
1588263245773
9.4 实现动态配置
9.4.1 实现原理
实现原理
1588268131944
9.4.2 服务连接RabbitMQ

Config项目和Customer项目均要导入依赖

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

Config项目编写配置文件连接RabbitMQ信息

spring:
  rabbitmq:
    host: 192.168.206.142
    port: 5672
    username: test
    password: 123
    virtual-host: /test
9.4.3 实现手动刷新

Config项目和Customer项目均要导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Config项目和Customer项目均要编写配置文件，yml设置开放访问地址，默认情况下都不允许访问

management:
  endpoints:
    web:
      exposure:
        include: "*"

为customer添加一个controller，不要忘记加@RefreshScope注解，不要手动刷新无效

@RestController
@RefreshScope
public class CustomerController {

    @Value("${env}")
    private String env;

    @GetMapping("/env")
    public String env(){
        return env;
    }
}

测试，发送请求http://localhost:8888，注意是post请求，config默认端口8888

1. CONFIG在Gitee修改之后，自动拉取最新的配置信息。
2. 其他模块需要更新的话，手动发送一个请求http://ip:port/actuator/bus-refresh，不重启项目，即可获取最新的配置信息

手动刷新数据请求

操作步骤：在git的yml文件更新数据，然后刷新网页http://localhost:8888/customer-v1-dev.yml查看config-server服务器是否拿到数据，获取到数据使用customer发送请求获取数据http://localhost:8080/env，此时数据看到未更新到最新数据，谷歌浏览器的扩展程序插件，发送post请求http://localhost:8888/actuator/bus-refresh

再次发送请求http://localhost:8080/env即可获取到数据

在git编辑，修改数据
image-20201105113937416
image-20201105114112318
获取config-server数据，刷新网页http://localhost:8888/customer-v1-dev.yml
image-20201105114255112
发送刷新请求，查看发送状态
image-20201105114625259
再次发送请求http://localhost:8080/env即可获取到数据
image-20201105114711447
9.4.4 内网穿透

为了能让git webhooks访问本地的http://ip:port/actuator/bus-refresh地址，需要把localhost:8888的地址改为外网地址，因此需要使用内网穿透。内网穿透官网https://natapp.cn/

注册登录

购买一个免费的隧道。

配置隧道
1588317871876

下载客户端，并复制config.ini文件，在文件中指定authtoken

netapp软件
image-20201105092620461
1588317944258

image-20201105092136809

启动exe文件，并测试使用域名访问config接口

效果
1588317929937
9.4.5 实现自动刷新

配置Gitee中的WebHooks

配置Gitee中的WebHooks
1588319227917

给Config添加一个过滤器，注意要在启动类中放行filter

@ServletComponentScan("com.qf.filter")

UrlFilter

@WebFilter("/*")
public class UrlFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        HttpServletResponse httpServletResponse = (HttpServletResponse)response;

        String url = new String(httpServletRequest.getRequestURI());

        //只过滤/actuator/bus-refresh请求
        if (!url.endsWith("/actuator/bus-refresh")) {
            chain.doFilter(request, response);
            return;
        }

        //获取原始的body
        String body = readAsChars(httpServletRequest);

        System.out.println("original body:   "+ body);

        //使用HttpServletRequest包装原始请求达到修改post请求中body内容的目的
        CustometRequestWrapper requestWrapper = new CustometRequestWrapper(httpServletRequest);

        chain.doFilter(requestWrapper, response);

    }

    @Override
    public void destroy() {

    }

    private class CustometRequestWrapper extends HttpServletRequestWrapper {
        public CustometRequestWrapper(HttpServletRequest request) {
            super(request);
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            byte[] bytes = new byte[0];
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

            return new ServletInputStream() {
                @Override
                public boolean isFinished() {
                    return byteArrayInputStream.read() == -1 ? true:false;
                }

                @Override
                public boolean isReady() {
                    return false;
                }

                @Override
                public void setReadListener(ReadListener readListener) {

                }

                @Override
                public int read() throws IOException {
                    return byteArrayInputStream.read();
                }
            };
        }
    }

    public static String readAsChars(HttpServletRequest request){

        BufferedReader br = null;
        StringBuilder sb = new StringBuilder("");
        try{
            br = request.getReader();
            String str;
            while ((str = br.readLine()) != null){
                sb.append(str);
            }
            br.close();
        }
        catch (IOException e){
            e.printStackTrace();
        }
        finally{
            if (null != br){
                try{
                    br.close();
                }
                catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
}

测试

测试
1588319255162

十、服务的追踪-Sleuth【重点】

10.1 引言

在整个微服务架构中，微服务很多，一个请求可能需要调用很多很多的服务，最终才能完成一个功能，如果说，整个功能出现了问题，在这么多的服务中，如何去定位到问题的所在点，出现问题的原因是什么。

  • Sleuth可以获得到整个服务链路的信息。

  • Zipkin通过图形化界面去看到信息。

  • Sleuth将日志信息存储到数据库中。

Sleuth
1588325099243
10.2 Sleuth的使用

在customer和search工程导入依赖

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

在customer和search工程编写配置文件，配置日志输出级别

logging:
  level:
    org.springframework.web.servlet.DispatcherServlet: DEBUG

测试

日志信息
1588336398785
SEARCH：服务名称
e9c：总链路id （traceId）
f07：当前服务的链路id （spanId）
false：不会将当前的日志信息，输出其他系统中

traceId相同，表示当前的一个请求。spanId不同，表示经过不同的服务进行处理。同一个请求，traceId只有一个，但spanId却可以有多个。如果重新发送一个请求，则traceId会改变。
10.3 Zipkin的使用

通过Docker-compose安装zipkin图形画界面 zipkin官网 https://zipkin.io/

version: "3.1"
services:
  zipkin:
   image: daocloud.io/daocloud/zipkin:latest
   restart: always
   container_name: zipkin
   ports:
     - 9411:9411

导入依赖，把Customer项目和Search项目中的spring-cloud-starter-sleuth改为spring-cloud-starter-zipkin

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

Customer项目和Search项目编写配置文件

#指定服务的名称
spring:
  sleuth:
    sampler:
      probability: 1   # 百分之百的sleuth信息需要输出到zipkin中
  zipkin:
    base-url: http://192.168.206.142:9411/  # 指定zipkin的地址
    sender:
      type: web    #服务要发送http请求到zipkin，zipkin才能得到sleuth信息

测试

测试
1588341969002
10.4 整合RabbitMQ

导入RabbitMQ依赖

在customer模块修改配置yml文件

spring:
  zipkin:
    sender:
      type: rabbit

在/opt/docker_zipkin目录下，重新修改zipkin的yml文件，docker-compose.yml

version: "3.1"
services:
  zipkin:
   image: daocloud.io/daocloud/zipkin:latest
   restart: always
   container_name: zipkin
   ports:
     - 9411:9411
   environment:
     - RABBIT_ADDRESSES=192.168.206.142:5672
     - RABBIT_USER=test
     - RABBIT_PASSWORD=123
     - RABBIT_VIRTUAL_HOST=/test

测试

测试
1588348586217
10.5 Zipkin存储数据到ES

在/opt/docker_zipkin目录下，重新修改zipkin的yml文件，docker-compose.yml

version: "3.1"
services:
  zipkin:
   image: daocloud.io/daocloud/zipkin:latest
   restart: always
   container_name: zipkin
   ports:
     - 9411:9411
   environment:
     - RABBIT_ADDRESSES=192.168.199.109:5672
     - RABBIT_USER=test
     - RABBIT_PASSWORD=test
     - RABBIT_VIRTUAL_HOST=/test
     - STORAGE_TYPE=elasticsearch
     - ES_HOSTS=http://192.168.206.142:9200
测试
页面请求数据
image-20201104230941532
Zipkin展示效果
image-20201104231037338
在ES存储数据
image-20201104230329034
ES数据展示
image-20201104230859870

十一、完整SpringCloud架构图【重点】

完整架构图
1588351313922
Masol126
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springcloud学习文档和代码（springcloud从入门到精通）
01-08
SpringCloud是中国最流行的微服务框架之一，它基于Spring Boot实现，为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、...希望这个压缩包能成为你SpringCloud学习之旅的重要参考资料。
SpringCloud示例：Spring Cloud学习教程
01-29
《Spring Cloud学习教程详解》 在当今的微服务架构领域，Spring Cloud以其强大的功能和易用性成为开发者首选的框架之一。本教程旨在深入解析Spring Cloud的各项核心组件，帮助开发者全面掌握这一技术栈。 首先，...
SpringCloud 笔记
普通还不自信的程序员
09-17 305
文章目录一、SpringCloud介绍1.1 微服务架构1.2 SpringCloud介绍二、服务的注册与发现-Eureka【`重点`】2.1 引言2.2 Eureka的快速入门2.2.1 创建EurekaServer2.2.2 创建EurekaClient2.2.3 测试Eureka2.3 Eureka的安全性2.4 Eureka的高可用2.5 Eureka的细节三、服务间的负载均衡-Robbin【`重点`】3.1 引言3.2 Robbin的快速入门3.3 Robbin配置负载均衡策略四、服务间的调用-F
ZULL图解+代码 ZuulFilter执行顺序
weixin_44684812的博客
09-07 787
ZULL图解+代码 ZuulFilter执行顺序
ZuulFilter 执行顺序
weixin_45380450的博客
10-24 1180
1 按照filterType决定顺序 Pre 优先 Post执行，此时filterOrder没有作用。 2 filterType相同 filterOrder有作用，数字越小，越先执行。（负数也是这个规则，0和-1的话，-1先执行） 3 相同filterType,相同filterOrder，都执行，执行顺序不清楚。 prefilter先执行了，post后执行了。 ...
zuul的filter执行顺序
lilang的博客
03-19 6949
抛开zuul将自定义以及默认filter初始化到FilterRegistry的ConcurrentHashMap中不谈，记录一下zuul的过滤器执行顺序。 1.在ZuulServlet类中的service方法，先给请求创建一个线程局部变量“RequestContext”，其生命周期结束时间为“post”类型的zuul执行完毕之后。 2.首先执行pre类型的filter（默认的pre filte...
SpringCloud-Zuul执行流程分析
esunlang的博客
02-10 421
前言 如果使用了微服务的springcloud中间件，可能前期早些时候的项目还是在使用zuul，后期的项目基本都要是选择了gateway，但是这里还是想理一理这个zull的流程，毕竟是一个开创网关先补补祖。 知识前提 我们知道，HTTP请求是受HttpServlet接收的，早期项目中其实也是由HttpServlet的doGet doPost方法接收请求进行初始处理并且进行相关逻辑处理。那个年代的项目写到真是想吐。 而zuul是继承了这个HttpServlet，之后便是通过相关的type获取要执行的filte
Spring Cloud ，Spring Cloud Alibaba 系列学习教程.zip
07-03
无论是 Springboot 、SpringCloud 还是 SSM ，我们都为您提供了全面而系统的学习路径。跟随教程，您将逐步建立起坚实的知识体系，能够独立开发出高效、稳定的项目。 不要再犹豫，立即下载开启您的技术提升之旅！ ...
Spring Cloud 入门教程.zip
最新发布
07-03
无论是 Springboot 、SpringCloud 还是 SSM ，我们都为您提供了全面而系统的学习路径。跟随教程，您将逐步建立起坚实的知识体系，能够独立开发出高效、稳定的项目。 不要再犹豫，立即下载开启您的技术提升之旅！ ...
Spring Cloud Tutorial.《Spring Cloud 教程》.zip
07-03
无论是 Springboot 、SpringCloud 还是 SSM ，我们都为您提供了全面而系统的学习路径。跟随教程，您将逐步建立起坚实的知识体系，能够独立开发出高效、稳定的项目。 不要再犹豫，立即下载开启您的技术提升之旅！ ...
spring 4.3.29 所有jar包
09-21
spring 4.3.29 所有jar包
Spring4.3完整官网下载的完整包
01-23
官网下载的资源包含Spring4.3版本！包含全部的jar文件和源码文件以及文档文件
SpringCloud中的Zuul的工作原理(四大过滤器链的执行流程pre、routing、post、error)
m0_56245143的博客
05-11 729
首先的zuul的底层是通过各种的Filter来实现的，zuul中的filter按照执行顺序分为了“pre”前置（"custom"自定义一般是前置），"routing"路由，“post"后置，以及"error"异常Filter组成的，当各种Filter出现了异常，请求会跳转到"error filter”，然后再经过"post filter"最后返回结果。
zuul 网关过滤器 zuulFilter
搬砖农民工的博客
02-02 4430
继承zuulFilter需要实现四个方法，filterType、filterOrder、shouldFilter、run。Spring Cloud Netflix Zuul 中实现过滤器必须包含 4 个基本特征：过滤器类型，执。行顺序，执行条件，动作（具体操作）。这些步骤都是 ZuulFilter 接口中定义的。：请求被路由到源服务器之前执行的过滤器。：处理将请求发送到源服务器的过滤器。：响应从源服务器返回时执行的过滤器。：上述阶段中出现错误时执行的过滤器。将响应以流的方式发送回客户端。
十九.SpringCloud源码剖析-Zuul的执行流程
墨家巨子@俏如来
01-27 753
前言 在之前的章节我们详细分析了Zuul的Filter，这一章节我们来详细跟一下Zuul的执行流程 Zuul的执行流程是这样的 首先请求进来会先到达ZuulController ，ZuulController把请求交给ZuulServlet去处理 在ZuulServelt会调用 ZuulRunner 依次执行： init初始化，pre前置filter，route路由filter,post后置filter, error 异常filter ZuulRunner通过 FilterProcessor 去执行各
网关zuul的执行流程
weixin_37862824的博客
08-26 1417
自定义路由 既然是网关那么就一定要有路由，那么在zuul中怎么设置我们自定义的路由呢，下面介绍下，通过bean设置路由。 public class CustomRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator{ //刷新路由 @Override public void refresh(){ this.routes.set(this.locateRoutes());
SpringCloud全家桶 （第四期：Zuul网关之ZuulFilter过滤器）
男人要霸气的博客
01-14 504
一： 什么是SpringCloud Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems (e.g. configuration management, service discovery, circuit breakers, i...
SpringCloud Zuul执行流程与源码分析
Logger
12-27 316
文章目录请求在网关内的执行流程过滤器的具体调用逻辑 请求在网关内的执行流程 用户请求大致上是按这个顺序来进行的，我们再看具体内部这四种Filter的执行顺序，搬一段ZuulServlet.service()源码： public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException
服务网关zuul之二：过滤器--请求过滤执行过程（源码分析）
weixin_34061042的博客
09-18 681
Zuul的核心是一系列的过滤器，这些过滤器可以完成以下功能： 身份认证与安全：识别每个资源的验证要求，并拒绝那些与要求不符的请求。 审查与监控：在边缘位置追踪有意义的数据和统计结果，从而带来精确的生成视图。 动态路由：动态地将请求路由到不同的后端集群。 压力测试：逐渐增加执行集群的流量，以了解性能。 负载分配：为每一种负载类型分配对应容量，并弃用超出限定值得请求。 静态响应处理：在...
spring cloud学习
05-30
Spring Cloud是一组开源框架，它提供了一系列...2. 《Spring Cloud微服务实战》：该书是学习Spring Cloud的经典书籍，对于初学者来说非常友好。 3. Spring Cloud示例代码：https://github.com/spring-cloud-samples
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值