SpringCloud 入门学习实例搭建

最新推荐文章于 2024-09-02 23:44:26 发布
最新推荐文章于 2024-09-02 23:44:26 发布
阅读量237 收藏
点赞数
分类专栏： spring cloud 文章标签： java spring cloud eureka ribbon
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzonemen/article/details/120481697
版权

SpringCloud 学习

1、前言

微服务架构解决的4个核心问题

1、服务很多，客户端该如何访问？

2、这么多服务，服务之前如何通信？

3、这么多服务，如何管理？

4、服务挂了怎么办？

目前的解决方案：

1、Spring Cloud NetFlix 一站式解决方案

api网关：zuul组件

Feign 通讯 ---HttpClient---Http通信方式，同步阻塞

服务注册发现：Eureka

熔断机制： Hystrix

2、Apache Dubbo Zookeeper 半自动，需要整合别人的

api网关: 没有

Dubbo 通信--RPC通讯方式，异步

Zookeeper 服务注册发现

熔断：没有

3、Spring Cloud Alibaba 一站式解决方案

新概念： 服务网格 ~ Server Mesh

istio

需要掌握的：RestTemplate、Eurake、Ribbon、Feign、RestTemplate、Zuul

实现目的结果

1、搭建好eureka服务注册中心

2、配置好两个eureka注册中心集群

3、配置两个微服务模块，注册到集群中

4、创建一个客户端应用，并配置zuul应用网关实现对微服务的调用

5、实现客户端负载均衡Ribbon(客户端配置RestTemplate的bean)

6、实现Ribbon自定义负载均衡算法策略

7、Feign实现接口方式调用服务

8、将FeignClient配置的接口放到公共模块，实现微服务之间的相互调用

9、实现zuul转发时，将用户信息放到header传递到微服务中，以及在多个微服务间的传递

10、Feign转发时，将用户信息放到header传递到微服务中，以及在多个微服务间的传递

10、使用 Hystrix / Spring Cloud Alibaba Sentinel 实现服务熔断机制

11、zuul服务网关是在security过滤器之后跳转的

zuul和feign的应用场景和区别

1、zuul作为整个应用的流量入口，接收所有的请求，如app、网页等，并且将不同的请求转发至不同的处理微服务模块，其作用可视为nginx。

2、feign则是将当前微服务的部分服务接口暴露出来，并且主要用于各个微服务之间的服务调用。

3、两者的应用层次以及原理均不相同。

4、zuul也含有hystrix和ribbon，基于http通讯的，可以直接代理服务就行。在它和服务间增加feign只会增加通讯消耗，没有特别的意义。feign在服务互相调用的时候用就行了，可以仿rpc通讯。

5.Feign主要作客户端流控，Feign的负载均衡是基于Eureka实现的, Zuul主要作服务端流控，并且Zuul的负载均衡结合Eureka实现易用性较好，并且Zuul我一般用在对第三方提供访问接口。

2、服务治理

服务雪崩效应常见场景

  • 硬件故障：如服务器宕机，机房断电，光纤被挖断等。

  • 流量激增：如异常流量，重试加大流量等。

  • 缓存穿透：一般发生在应用重启，所有缓存失效时，以及短时间内大量缓存失效时。大量的缓存不命中，使请求直击后端服务，造成服务提供者超负荷运行，引起服务不可用。

  • 程序BUG：如程序逻辑导致内存泄漏，JVM长时间FullGC等。

  • 同步等待：服务间采用同步调用模式，同步等待造成的资源耗尽。

雪崩效应应对策略

针对造成雪崩效应的不同场景，可以使用不同的应对策略，没有一种通用所有场景的策略，参考如下：

  • 硬件故障：多机房容灾、异地多活等。

  • 流量激增：服务自动扩容、流量控制（限流、关闭重试）等。

  • 缓存穿透：缓存预加载、缓存异步加载等。

  • 程序BUG：修改程序bug、及时释放资源等。

  • 同步等待：资源隔离、MQ解耦、不可用服务调用快速失败等。资源隔离通常指不同服务调用采用不同的线程池；不可用服务调用快速失败一般通过熔断器模式结合超时机制实现。

Hystrix 实现熔断机制

1、pom依耐

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

2、开启熔断

在主启动类上添加注解 @EnableCircuitBreaker // 开启对熔断的支持

3、实现熔断

熔断是在微服务端的配置

@HystrixCommand( fallbackMethod  = "exceptionHandler") // 配置实现熔断降级时的异常处理方法
@GetMapping("/test/{id}")
public Map<String,Object> getTest(@PathVariable("id") Long id){
    Map<String,Object> map = new HashMap<>();
    map.put("code", 200);
    Product product = productService.getById(id);
    if (product == null){
        throw new RuntimeException("未查询到表中的数据,可能传入的id不正确");
    }
    map.put("data", product);
    return map;
}
​
public Map<String,Object> exceptionHandler(@PathVariable("id") Long id ) { // 异常处理方法参数和返回值必须与熔断的方法一直
    Map<String,Object> map = new HashMap<>();
    map.put("code", 400);
    map.put("message", "产品ID不存在！");
    return map;
}

4、实现降级处理

降级是在服务消费端(即客户端)的配置

Spring Cloud Alibaba Sentinel 实现熔断降级、流量限制

1、pom依耐

<!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-sentinel -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

2、搭建Sentinel控制台

下载Sentinel控制台：Releases · alibaba/Sentinel · GitHub

sentinel-dashboard-1.8.1.jar

运行控制台程序

java -Dserver.port=9527 -Dcsp.sentinel.dashboard.server=localhost:9527 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.1.jar

3、为服务整合Sentinel控制台

spring:
    cloud:
        sentinel:
            filter:
                #打开/关闭掉对Spring MVC端点的保护
                enabled: true
            transport:
                #启动服务时，会额外启动一个服务来跟sentinel控制台通信，运行在该端口上
                port: 8719
                #指定sentinel控制台的地址
                dashboard: localhost:8080

到这里，我们就已经配置好服务与Sentinel控制台的整合了，在控制台上可以看到我们的服务，进行相关的流控及降级规则操作。

4、自定义限流及熔断降级处理方法

因为，Sentinel默认的异常处理返回是一段统一的说明信息，而我们实际中可能会根据不同的访问，在被限流或降级后给出不同的异常返回；

// 实现熔断降级时的异常处理

@SentinelResource(value = "product_info", fallback  = "fallbackHandler") 
@GetMapping("/test/{id}")
public Map<String,Object> getProduct(@PathVariable("id") Long id){
​
    Map<String,Object> map = new HashMap<>();
    map.put("code", 200);
    Product product = productService.getById(id);
    if (product == null){
        throw new RuntimeException("未查询到表中的数据,可能传入的id不正确");
    }
    map.put("data", product);
    return map;
}
​
public Map<String,Object> fallbackHandler(@PathVariable("id") Long id ) {
    //ex.printStackTrace();
    Map<String,Object> map = new HashMap<>();
    map.put("code", 400);
    map.put("message", "产品ID不存在！");
    return map;
}

// 实现流量访问限制处理

@SentinelResource(value = "product_info", blockHandler  = "blockHandler") 
@GetMapping("/test/{id}")
public Map<String,Object> getProduct(@PathVariable("id") Long id){
    Map<String,Object> map = new HashMap<>();
    map.put("code", 200);
    Product product = productService.getById(id);
    map.put("data", product);
    return map;
}
​
public Map<String,Object> blockHandler(@PathVariable("id") Long id ) {
    //ex.printStackTrace();
    Map<String,Object> map = new HashMap<>();
    map.put("code", 400);
    map.put("message", "产品ID不存在！");
    return map;
}

Hystrix解决同步等待的雪崩问题

一、项目根路径

因为我们的服务集群会有很多子模块，所以我们要创建一个主项目来管理相关的依赖；

我们思考分析下，我们需要管理的依耐：

springboot : spring-boot-dependencies (2.3.6.RELEASE)

springcloud : spring-cloud-dependencies(Hoxton.SR9)

mysql : mysql-connector-java(8.0.24) , druid( com.alibaba 1.2.6)

mybatis : mybatis-spring-boot-starter(2.1.3)

swagger : springfox-boot-starter(3.0.0)

需要子模块继承的依耐：

lombok （用来通过注解实现编译时自动生成类属性的getter、setter、toString的相关方法）: lombok(1.18.20)

log : spring-boot-starter-logging (版本号受spring-boot-dependencies管理)

1、pom依耐

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>com.chengjun</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud-api</module>
        <module>eureka7001</module>
        <module>eureka7002</module>
        <module>client1</module>
        <module>server-product-8001</module>
        <module>server-product-8003</module>
        <module>server-order-8002</module>
        <module>server-product-8004-hystrix</module>
    </modules>
​
    <!-- 打包方式 -->
    <packaging>pom</packaging>
​
    <properties>
        <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
        <spring-boot.version>2.3.6.RELEASE</spring-boot.version>
        <mysql.version>8.0.24</mysql.version>
        <druid.version>1.2.6</druid.version>
        <mybatis.version>2.1.3</mybatis.version>
        <springfox.version>3.0.0</springfox.version>
    </properties>
​
    <dependencyManagement>
        <dependencies>
            <!--  spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
​
            <!-- spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
​
            <!-- 数据库 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- 数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
​
            <!-- mybatis -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
​
            <!-- swagger -->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-boot-starter</artifactId>
                <version>${springfox.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
​
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
​
        <!--测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
​
        <!-- 日志-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
​
        <!-- 热部署，代码修改后，不需要重新运行程序 -->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
​
    </dependencies>
​
    <!--插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

二、Eureka服务注册中心

1、pom依赖

因为继承了父级根模块，在根模块中有springcloud版本的管理，所以这里引入spring-cloud-starter-netflix-eureka-server、spring-boot-starter-web 我们就不用加版本号了，会自动根据根模块中springcloud版本找到对应的依耐版本的。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.chengjun</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>eureka7001</artifactId>
​
    <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>
</project>

2、application.yml 配置

server:
  port: 7001
spring:
  application:
  	# 注册中心服务名称
    name: eureka7001
eureka:
  instance:
    hostname: eureka7001   	 # Eureka注册中心的主机实例名称
  client:
  	# 表示是否将自己注册在EurekaServer上，默认为true。由于当前应用就是EurekaServer，所以置为false
    register-with-eureka: false  
    # 表示是否从EurekaServer上获取注册信息，由于自己就是服务器，不需要从服务器获取注册信息
    fetch-registry: false        
    # 服务地址
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

3、启动Eureka服务端

在启动类上，添加注解 @EnableEurekaServer // eureka服务端启动

三、微服务的注册

1、pom依耐

将微服务注册到eureka注册中心，需要添加的依耐

<!-- eureka-client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <!-- <version>2.2.6.RELEASE</version> 版本由父级模块来管理 -->
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 用来配置应用模块的描述信息，在application.yml中配置info，在Eureka注册中心页面，点击服务实例会显示本服务配置的info -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2、application.yml 配置

微服务名称：server-order

注册的Eureka服务端：http://eureka.com:7001/eureka/

注册的微服务实例： server.com:8001

server:
  port: 8001
spring:
  application:
    name: server-product
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/  #  注册中心的地址
  instance:
  	# 服务实例ID，应该唯一性，不与注册中心的其他服务实例ID重复
    instance-id: server.com:8001
    # 是否优先使用IP地址访问
    prefer-ip-address: true
    
info:
  app.name: chengjun-springcloud
  company.name: 南京上游软件有限公司

3、启动Eureka客户端

启动类中添加注解： @EnableEurekaClient

将Eureka注册中心启动，然后启动微服务，这时在注册中心页面http://eureka.com:7001/ 就能看到已注册的本服务

使用同样的步骤，我们可以再创建一个微服务模块，application配置只要调整三个配置就可以了：

微服务名称：server-order

注册的Eureka服务端：http://eureka.com:7001/eureka/

注册的微服务实例： server.com:8002

四、Eureka 集群

在实际应用中，如果我们只配置了一个Eureka注册中心，那么当这个注册中心出现问题挂掉后，所有的服务将都无法再连接了。

针对这个问题，我们可以创建多个Eureka注册中心，并将它们相关关联，形成一个集群。

那么，我们如何实现呢？

1、Eureka服务端配置

之前，我们已经创建了一个注册中心，我们现在用同样的方式再创建一个注册中心。

新的注册中心的配置文件：

server:
  port: 7002
spring:
  application:
    name: eureka7002
eureka:
  instance:
    hostname: eureka7002.com  # Eureka服务端的实例名称
  client:
    register-with-eureka: false  # 由于自己就是服务器，不需要注册到自己
    fetch-registry: false        # 由于自己就是服务器，不需要从服务器获取注册信息
    # 服务地址
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/

现在我们有两个eureka注册中心了，我们要将两个注册中心相互关联，需要修改它们的 eureka.client.service-url.defaultZone 属性值

我们将7001的defaultZone 改为 http://eureka7002.com:7002/eureka/

将7002的defaultZone 改为 http://eureka7001.com:7001/eureka/

这样，我们就实现了两个注册中心的互相关联，如果我们还有第三个注册中心，

那么我们就将注册中心1的defaultZone设置为 2,3 ，将2的defaultZone设置为 1,3 ，将3的defaultZone设置为 1,2 ，这样就三个互相关联了。（多个地址之间用逗号）

完成了服务端的集群配置，下面我们来配置下客户端

2、Eureka客户端配置

客户端的配置也相当简单，我们只要将每个微服务都注册到注册中心集群中就可以了，实际的配置，我们只要修改下 defaultZone ，将微服务配置的 defaultZone 设置为多个Eureka服务端的地址，如：

我们要将 server-order 微服务的配置：

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/  #  注册中心的地址

改为

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/  #  注册中心的地址

这样，我们就完成了客户端的配置，很简单吧。

五、服务消费者（客户端）

我们一般把客户端作为服务消费者，因为客户端需要调用注册的微服务，其实，只要是调用微服务的都可以看作为消费者，比如如果一个微服务调用了另一个微服务，那么我们可以说第一个微服务既是服务提供者又是服务消费者。

客户端的配置，与微服务的配置基本一致，只是客户端不需要将自己注册到注册中心，只要从注册中心获取注册信息就可以了，所以 register-with-eureka: false 。

1、pom依耐

客户端要调用微服务，必须把自己也注册到Eureka注册中心才可以，添加eureka客户端依耐包

<!-- eureka客户端依赖包 -->
<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>

2、application.yml 配置

server:
  port: 9001
spring:
  application:
    name: client1
eureka:
  client:
    service-url:
      defaultZone: http://eureka.com:7001/eureka/,http://eureka.com:7002/eureka/
    register-with-eureka: false # 客户端应用不需要注册到服务中心
  instance:
    instance-id: client1.com
    # 是否优先使用IP地址访问
    # prefer-ip-address: true

3、启动Eureka客户端

启动类中添加注解： @EnableEurekaClient

六、zuul 应用网关配置

zuul 可以对访问路由进行转发到对应的微服务中，所以可以用来配置在客户端上，对前端的路径请求，根据不同的路径，转发到对应的微服务接口。

我们以 client1 客户端为例，来实现配置

1、pom依耐

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

2、application.yml 配置

# 应用路由网关配置
zuul:
  routes:
  	# SERVER-PRODUCT服务网关
    product:
      serviceId: SERVER-PRODUCT # 服务应用名称
      path: /product/**			# 网关路由路径
    # SERVER-ORDER服务网关
    order:
      serviceId: SERVER-ORDER
      path: /order/**
  ignored-services: "*" #配置不再允许使用微服务应用名称去访问服务，只能使用配置的路由path来访问
  prefix: /webservice #设置微服务访问公共前缀,相当于访问微服务的路径前都要加上 /webservice

3、开启zuul

添加注解 @EnableZuulProxy

@EnableZuulProxy
public class Client1 {
	....
}

完成zuul的配置后，启动 client1，这时，我们访问地址 http://client1.com:9001/webservice/product/product/get/1 ，实际执行的是 SERVER-PRODUCT 服务中的接口 /product/get/1 , 因为 /webservice 是微服务公共前缀，/product 表示指向SERVER-PRODUCT微服务， /product/get/1 才是微服务里真正的接口路径。

七、Ribbon 实现微服务负载均衡

负载均衡是在客户端实现的，但是配置的是微服务访问的负载，也就是客户端访问微服务的负载处理，所以这里我们还是以客户端 client1 为例；

要实现负载均衡，我们需要将同一个服务模块，运行多个实例，并都注册到注册中心中。

1、pom依耐

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

2、application.yml 配置

因为需要开启两个相同服务的不同实例，才能做负载均衡，所以我们将8001服务复制为一个新的服务模块为8003，修改8003的 application.yml， 只要修改下服务端口号 和 服务实例ID就可以了，两个服务的application.name必须相同。

8003：

server:
  port: 8003
spring:
  application:
    name: server-product
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/  #  注册中心的地址
  instance:
  	# 服务实例ID，应该唯一性，不与注册中心的其他服务实例ID重复
    instance-id: server.com:8003
    # 是否优先使用IP地址访问
    prefer-ip-address: true
    
info:
  app.name: chengjun-springcloud
  company.name: 南京上游软件有限公司

3、开启负载均衡

我们需要定义一个配置类，注入一个 RestTemplate的bean，并添加注解 @LoadBalanced ，这就开启了负载均衡

@Configuration
public class RibbonConfig {

    // 配置负载均衡实现RestTemplate
    // IRule
    // RoundRobinRule 轮询
    // RandomRule 随机
    @Bean
    @LoadBalanced // Ribbon开启负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

}

4、修改负载均衡策略

默认的的策略是循环访问，可修改配置改变策略

1）全局配置，所有的RibbonClient都使用此策略

我们在 RibbonConfig 类中新增一个IRule策略接口bean，返回的是 RandomRule ，这就实现了所有的服务都使用随机策略。

/**
 * 随机原则
 * @return
*/
@Bean
public IRule ribbonRule(){
    return new RandomRule();
}

2）通过配置文件 application.yml 配置单个服务的策略，SERVICE-PRODUCT是服务ID

SERVICE-PRODUCT: 
	ribbon: 
		NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

5、自定义负载均衡策略

前面，我们配置的负载均衡默认使用的是组件包提供的策略机制；

我们现在想要定义自己的策略，我想让当第一个服务被连续访问5次后，再次有访问时就转到第二个服务上，也就是相当于按每个服务5次请求作为一个轮询；

1、首先，我们要在 client1 启动类的上一级目录下创建包为com.chengjun.ribbonrule，在包目录下创建配置类 RibbonRuleConfig

// 负载均衡自定义策略
// 注意不能放在application启动类同级目录，否则会被springboot扫描到，因为我们后面是要通过配置来将此策略配置类对应到某些服务上
@Configuration
public class RibbonRuleConfig {
    @Bean
    public IRule getRule(){
        return new MyRandomRule();
    }
}

MyRandomRule 是我们自定义的策略类 ，继承 AbstractLoadBalancerRule

package com.chengjun.ribbonrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

// 负载均衡策略： 每个服务访问5次后，就转到下一个服务
public class MyRandomRule extends AbstractLoadBalancerRule {

    // 每个服务访问5次后，就转到下一个服务
    private static final int count = 5;
    private int total = 0;  // 每个服务被调用次数
    private int currencyIndex = 0;

    /**
     * Randomly choose from all living servers
     */
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers(); // 获取可访问服务列表(不包含已死掉的服务)
            List<Server> allList = lb.getAllServers(); // 获取全部服务

            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }

            /*int index = chooseRandomInt(serverCount);
            server = upList.get(index);*/

            // =============================================================

            if (total < count){
                total++;
            }else{
                total = 0;
                currencyIndex++;
                if (currencyIndex >= upList.size()){
                    currencyIndex = 0;
                }
            }
            server = upList.get(currencyIndex);

            // =============================================================

            if (server == null) {
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }
            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }
}

注意： 启动类所属包是 com.chengjun.springcloud ，RibbonRuleConfig 不能和启动类在同级包下

2、给服务配置自定义的策略

@SpringBootApplication
@EnableZuulProxy
// 配置自定义的负载均衡策略，在微服务启动时，去加载我们自定义的 MyRandomRule，如果要配置多个服务，使用
/*@RibbonClients(value = {
        @RibbonClient(name = "xxx",configuration = XxxRibbonConfig.class),
        @RibbonClient(name = "demo",configuration = DemoRibbonConfig.class)
})*/
// 注意这边有个坑，当使用zuul配置了服务的路由网关后，这边的name值必须和zuul配置中的serviceId一致，严格区分大小写，否则zuul配置的路由访问时，无法实现负载均衡效果
@RibbonClient(name = "SERVER-PRODUCT",configuration = RibbonRuleConfig.class)
public class Client1 {
    public static void main(String[] args) {
        SpringApplication.run(Client1.class,args);
    }
}

如果，我们想要自定义的策略适用于所有服务，只要把【修改负载均衡策略】的【全局配置】中，将随机策略换成我们自定义的策略类即可。

八、Feign 接口方式调用服务

微服务的调用其实最终都是通过http方式调用 http://微服务地址:端口号/xxx/xxx

微服务的调用方法有三种： zuul，RestTemplate，Feign ;

  • 使用zuul的场景 ：前端调用的需求，有某一个微服务的接口直接处理

  • 使用RestTemplate: 适用于任何场景，但需要在代码中实现请求，不优雅；

  • 使用Feign的场景：服务消费者，在一次执行中，消费了一个服务后，后面还有相关的逻辑时；或者是消费了两个及两个以上的服务时；

其实就是zuul处理不了的就使用Feign，因为zuul只能串联执行，就是每次请求一个消费者只能转到一个服务。

下面是两者一次请求的执行描述：

zuul：

服务消费者 > 服务提供者 > 服务提供者

Feign：

服务消费者 > 服务提供者

> 服务提供者

> ······

1、Zuul

我们前面通过zuul 配置服务网关路由的方式，将前端的请求直接转发到微服务；

2、RestTemplate

通过RestTemplate类的方法在代码中实现去调用服务接口；

定义一个简单的restful接口

@RestController
public class TestController
{
    @RequestMapping(value = "testPost", method = RequestMethod.POST)
    public ResponseBean testPost(@RequestBody RequestBean requestBean)
    {
        ResponseBean responseBean = new ResponseBean();
        responseBean.setRetCode("0000");
        responseBean.setRetMsg("succ");

        return responseBean;
    }
}

使用RestTemplate访问该服务

//请求地址
String url = "http://localhost:8080/testPost";
//入参
RequestBean requestBean = new RequestBean();
requestBean.setTest1("1");
requestBean.setTest2("2");
requestBean.setTest3("3");

RestTemplate restTemplate = new RestTemplate();
ResponseBean responseBean = restTemplate.postForObject(url, requestBean, ResponseBean.class);

从这个例子可以看出，使用restTemplate访问restful接口非常的简单粗暴无脑。(url, requestMap, ResponseBean.class)这三个参数分别代表 请求地址、请求参数、HTTP响应转换被转换成的对象类型。

3、Feign

通过Feign相关配置，增加客户端服务接口ClientService类，实现微服务调用;

3.1、pom依耐

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

3.2、ClientService 接口

我们在 client1 里创建一个服务接口，定义接口方法并映射到微服务 SERVER-PRODUCT 的接口路径

@FeignClient(value = "SERVER-PRODUCT")
public interface ProductClientService {

    @PostMapping("/product/add")
    public boolean addProduct(Product product);

    @GetMapping("/product/get/{id}")
    public Product getProduct(@PathVariable("id") Long id);

    @GetMapping("/product/list")
    public List<Product> getProducts();

    @GetMapping("/user")
    public RequestUserDto getUserInfo();

}

3.3、启动类配置 @EnableFeignClients

basePackages 配置的是 @FeignClient 注解的服务接口的所在包

@ComponentScan 指定要扫描的包

@SpringBootApplication
@EnableFeignClients(basePackages = {"com.chengjun.springcloud"})
@ComponentScan("com.chengjun.springcloud")
public class Client1 {
    public static void main(String[] args) {
        SpringApplication.run(Client1.class,args);
    }
}

九、用户信息在微服务间的传递

我们要想在服务提供者中得到用户信息，需要两个步骤

  • 在服务消费者中，将用户信息包装为一个用户实体类，在header中的定义的一个参数名称（例：X-USER-INFO），将用户信息赋值给该参数

  • 在服务提供者中，获取request中的header中的 X-USER-INFO 的值，转为用户信息实体类；

1、服务消费者将用户信息放入header

这里，我们处理的是zuul和Feign调用微服务时的情况；

两种场景，处理header的方法不同

1.1、zuul

zuul中提供了过滤器抽象类ZuulFilter，给我们定义自己的过滤器，去实现拦截相关逻辑处理

我们要实现在zuul转发时，将用户信息加到header里，只需要定义一个过滤器抽象类ZuulFilter的子类，在子类run方法中实现相关的逻辑。

/**
 * @Project:  <br>
 * @CreateDate: 2021/05/19 15:49 <br>
 * @Author:  <br>
 * @Description: 网关过滤器，在认证完成后，调微服务之前，在请求头设置用户信息
 */
@Slf4j
@Component
public class ZuulUserDetailFilter extends ZuulFilter {
    @Override
    public String filterType() {
        // ROUTE_TYPE
        return FilterConstants.ROUTE_TYPE;
    }

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

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

    @Override
    public Object run() throws ZuulException {
        // 获取请求上下文
        RequestContext context = RequestContext.getCurrentContext();
        // 获取到request
        HttpServletRequest request = context.getRequest();

        String userStr = "";
        // 此处判断header中是否存在用户信息
        if (request.getHeader(RequestUserDto.REQUEST_ATTR_KEY) != null){
            userStr = request.getHeader(RequestUserDto.REQUEST_ATTR_KEY);
        }else{
            // 如果header里没有，那么再从应用安全框架的上下文中获取认证信息
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            if (null != authentication && null != authentication.getPrincipal() && authentication.getPrincipal() instanceof UserDetails) {
                // 从认证信息中得到用户信息
                final UserDetails user = (UserDetails) authentication.getPrincipal();
                if (null != user) {
                    // 将用户信息包装为一个服务件公共用户信息实体类
                    RequestUserDto requestUserDto = new RequestUserDto()
                            .setUserName(user.getUsername())
                            .setUserId(user.getUsername())
                            .setEmail("51521222@qq.com")
                            .setMobile("18662581052")
                            .setRoleId("ROLE_ADMIN");
                    userStr = JSONUtil.toJsonStr(requestUserDto);
                }
            }
        }
        // 将用户信息实体类加到header中，名称为 RequestUserDto.REQUEST_ATTR_KEY定义的常量值
        context.addZuulRequestHeader(RequestUserDto.REQUEST_ATTR_KEY, userStr);

        return null;
    }

}

1.2、feign

feign 提供了RequestInterceptor接口类，查看RequestInterceptor接口类源码，其中的描述如何使用的

Zero or more {@code RequestInterceptors} may be configured for purposes such as adding headers to
* all requests
可以配置零个或多个{@code RequestInterceptors}，以便将headers添加到所有请求中

使用方法,下面的是将currentToken放入header.X-Auth里的代码，很简单
For example: <br>
 * 
 * <pre>
 * public void apply(RequestTemplate input) {
 *   input.header("X-Auth", currentToken);
 * }
 * </pre>

这正是我们需要的，所以我们只要实现RequestInterceptor接口，并实现apply方法逻辑就可以了。

自定义拦截器类 FeignRequestInterceptor ，中间的大部分

@Configuration
public class FeignRequestInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        ServletRequestAttributes attributes = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes());
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            String userStr = "";
            // 此处要判断header中是否存在用户信息
            if (request.getHeader(RequestUserDto.REQUEST_ATTR_KEY) != null){
                userStr = request.getHeader(RequestUserDto.REQUEST_ATTR_KEY);
            }else{
                // 如果header里没有，那么再从当前应用的上下文中获取
                Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
                if (null != authentication && null != authentication.getPrincipal() && authentication.getPrincipal() instanceof UserDetails) {
                    final UserDetails user = (UserDetails) authentication.getPrincipal();
                    if (null != user) {
                        RequestUserDto requestUserDto = new RequestUserDto()
                                .setUserName(user.getUsername())
                                .setUserId(user.getUsername())
                                .setEmail("51521222@qq.com")
                                .setMobile("18662581052")
                                .setRoleId("ROLE_ADMIN");
                        userStr = JSONUtil.toJsonStr(requestUserDto);
                    }
                }
            }
            if (userStr != null && userStr != ""){
                requestTemplate.header(RequestUserDto.REQUEST_ATTR_KEY, userStr);
            }
        }
    }
}

2、服务提供者取出header中的用户信息

在服务提供者中，我们想要在Controller中方法中采用注解的方式注入用户信息，如下：

@GetMapping("/product/userinfo")
public RequestUserDto getUserInfo(@UserAnnotation RequestUserDto CurUser){
    return CurUser;
}

实现步骤：

  • 首先，我们需要定义注解 @UserAnnotation

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface UserAnnotation {
}

  • 然后，定义参数解析器，其中使用到了UserAnnotation

HandlerMethodArgumentResolver的源码中描述为：在给定请求的上下文中将方法参数解析为参数值的策略接口

/**
 * @Project:  <br>
 * @CreateDate: 2021/05/19 16:50 <br>
 * @Author:  <br>
 * @Description: 自定义参数解析器
 */
public class RequestUserHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {

    // 表示解析器是否支持的传入的参数
    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        // 只有参数带有UserAnnotation注解的才支持解析
        return methodParameter.hasParameterAnnotation(UserAnnotation.class);
    }

    // 解析结果
    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
        // 工具类返回用户信息对象
        return UserUtil.getCurrUser();
    }
}

UserUtil类

@Slf4j
public class UserUtil {

    /**
     * 获取当前登录用户，前提是请求从网关进入，并在网关设置了用户信息
     *
     * @return 用户对象，没有返回null
     */
    public static RequestUserDto getCurrUser() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        RequestUserDto requestUserDto = null;

        String userJson = request.getHeader(RequestUserDto.REQUEST_ATTR_KEY);
        if (userJson != null && !userJson.equals("")){
            try{
                requestUserDto = JSONUtil.toBean(userJson, RequestUserDto.class);
            } catch (Exception e) {
                log.error("UserUtil -> getCurUser，获取用户信息失败");
            }
        }

        return requestUserDto;
    }
}

  • 最后，我们要将上面定义的参数解析器，加到SpringWebMVC配置中

创建配置类 WebMvcConfigurer

@Configuration
public class MyWebMvcConfig implements WebMvcConfigurer {
    // 添加参数解析器
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(new RequestUserHandlerMethodArgumentResolver());
    }
}

这样，我们就实现了服务提供者在Controller方法中获取用户信息的功能

@GetMapping("/product/userinfo")
public RequestUserDto getUserInfo(@UserAnnotation RequestUserDto CurUser){
    return CurUser;
}

十、服务熔断降级

蜘蛛上网
关注
专栏目录
springcloud入门基础搭建之config
bfss_11的博客
07-25 647
1.工程目录 springcloud-config-server为config配置中心服务端，端口为9510 springcloud-config-client为config配置中心客户端，端口为9520 2.github准备 config推荐使用github，所以这里也是使用github来测试。 3.config-server服务端 3.1新建子项目springcloud-config-server 端口号为9510...
Spring Cloud Alibaba 从入门到精通1
08-03
5. **Java工程脚手架的使用**：学习如何使用Maven或Gradle等构建工具搭建Spring Cloud Alibaba项目。 6. **Sandbox沙箱环境的使用**：理解如何在模拟环境中进行开发和测试，以便更好地调试和优化服务。 此外，了解...
SpringCloud-Demo:springcloud演示
05-14
spring-cloud-demo 不定期更新与记录在springcloud开发中所遇到的坑以及解决方法 初始化添加 spring-cloud skywalking demo add mqtt suports add 微信小程序 suports mqtt kafka elk支持 20180809 更新 代码结构 新增git配置中心 新增kafka elk demo配置以及文档 文档结构整理 分离注册中心和配置中心 添加zipkin服务跟踪 20180905 自定义注解实现aop日志 自定义注解实现实体类参数校验 添加mybatis自定生成映射实体类、mapper等 添加全局异常处理 添加fegin自定义数据解析 20180907 添加注解，作为参数校验入口 20180910 解决服务之间调用fegin+hystrix 熔断异常拦截处理 20180914 服务调用之间的rest请求，参数为对
SpringCloud简单实例
weixin_43751710的博客
05-16 5859
SpringCloud简单实例 SpringCloud是基于SpringBoot，需要先了解SpringBoot的相关知识。 这里只是一个非常简单的包含注册表、服务提供者、服务消费者三者的例子。 源码见： https://github.com/mengyuxiaofeng/SpringCloud 注册表如下 启动类 package demo; import org.springframewor...
SpringCloud开发实战（一）：搭建SpringCloud框架
最新发布
山不见我，我自见山
09-02 1726
本系列文章主要是记录在工作中用到的微服务的各个组件，以及学习新的微服务组件~如有问题，欢迎大家批评指导。如果本文对你有帮助，还请点个收藏和关注。感谢支持，希望大家写的代码都没有BUG！！
SpringCloud Demo
刚好五个字的博客
09-30 1878
Spring Cloud Demo github：https://github.com/qq443672581/springcloud 基于springboot 1.5.x 包含： springcloud-config-client-bus springcloud-config-client springcloud-config-db springcloud-config-server sprin...
springcloud环境搭建入门
05-20
包含springcloud环境搭建分布式，其中包含eureka服务注册中心、ribbon负载均衡配置、网关zuul配置以及分布式配置中心如何配置等demo
springcloud入门级搭建(一)
CSDN新星计划JAVA赛道TOP5、CSDN内容合伙人、JAVA领域优质创作者、资深JAVA开发深耕JAVA领域。
08-25 779
首先新建一个maven项目springcloud 再分别建子项目Module Spring Initializr建项目 分别建config-server  ,eurake-client ,eurakeserver 项目 1.关于eurake-client的application.yml的配置 service-url: defaultZone: http://localhost:8888/...
springcloud入门代码基于Spring Cloud搭建Eureka高可用集群
06-16
在本文中，我们将深入探讨如何使用Spring Cloud搭建Eureka高可用集群，这是一套用于构建分布式微服务架构的重要工具。Eureka是Netflix公司开源的一款服务注册与发现组件，它允许微服务之间相互发现并进行通信。...
spring-cloud项目_springcloud_springcloud项目_springcloud_spring-clou
10-03
这个项目包含了基本的 Spring Cloud 组件，非常适合新手入门学习。你可以通过这个项目了解如何集成和配置这些组件，以及它们如何协同工作来构建一个完整的微服务架构。在实际开发中，还需要考虑其他方面，如安全性、...
SpringCloud 15个完整例子
12-08
SpringCloud是中国Java开发者广泛...这些示例项目涵盖了SpringCloud的主要应用场景，适合初学者逐步学习和实践。通过每个例子的代码和运行，你可以深入了解每个组件的工作原理，并掌握如何在实际项目中应用这些技术。
springcloud实例demo
10-12
这是springcloud的实例demo，非常适合初学者学习！！！
使用Spring Cloud搭建的微服务示例
04-25
使用Spring Cloud搭建的微服务示例，包含了5个服务：配置服务、注册服务、网关服务、图书服务和评分服务。实现了微服务的配置、服务注册与发现、服务网关路由等功能，是一个基础的框架。
SpringCloud微服务架构Demo案例
04-17
上传的这个microservicecloud工程的主要使用了SpringCloud的5大技术栈做了一个微服务架构案例，涉及到Eureka集群的配置、Ribbon的自定义负载均衡、Feign的声明式接口调用、Hystrix的服务熔断和降级、Zuul的Api GateWay网关和SpringCloud Config 的动态配置中心。SpringCloud的技术栈21种之多,这里只是使用到了主要的核心的5个技术栈，需要做数据线，消息总线，分布式会话、微代理等等的同志,自行添加相应的技术栈组件。
springcloud demo搭建
03-04
亲自搭建，下载直接就可以运行。里面主要包括基本的组件： 注册中心：Spring Cloud Netflix 配置中心：Spring Cloud Config 鉴权中心：Spring Cloud OAuth2 hystrix、feign、Zuul、Eureka等。 所有工程的都实现了负载。
基于spring-cloud2.X的Demo例子
05-15
基于spring-cloud2.X的Demo例子,eureka注册中心,feign,rest+ribbon,config配置中心
springCloud 微服务框架搭建入门（很简单的一个案例不喜勿扰）
weixin_34189116的博客
12-05 284
Spring cloud 实现服务注册及发现 服务注册与发现对于微服务系统来说非常重要。有了服务发现与注册，你就不需要整天改服务调用的配置文件了，你只需要使用服务的标识符，就可以访问到服务。 cloud-eureka-server：eureka注册服务器 cloud-simple-service：一个使用mybatis的数据库应用，服务端 　　服务注册管理器原理如下图所...
spring cloud实例Demo详细搭建（一）
weixin_45131680的博客
06-20 2025
入门篇
搭建SpringCloud 系列demo
qq_36644198的博客
05-05 432
总工程microservice-parent <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xs
Spring Cloud入门：搭建Eureka服务中心
"这是一个关于Spring Cloud入门级项目的搭建教程，适合初学者学习。教程中提到了如何创建Maven项目，管理依赖，配置数据库，编写API模块，以及集成Eureka服务发现组件。" 在Spring Cloud的简单项目搭建过程中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值