Spring Could Ribbon实战

最新推荐文章于 2022-11-14 09:29:56 发布
最新推荐文章于 2022-11-14 09:29:56 发布
阅读量135 收藏
点赞数
文章标签： java ribbon nginx eureka zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nathan_csdn/article/details/118248485
版权
本文介绍Spring Cloud中Ribbon组件的应用，包括负载均衡的实现方式与重试机制的配置方法。通过实例展示了如何搭建Eureka Server、Eureka Client-Provider与Eureka Client-Consumer，以及如何实现服务间的负载均衡和重试策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Ribbon

简介

Ribbon是Netflix的一个开源组件，Spring进行了封装，可用实现应用级别的负载均衡、请求重发等功能。

Ribbon负载均衡

应用场景：在高并发请求场景下，为了减轻单个服务节点的压力，将流量分流到不同应用节点，就需要用到负载均衡。

原理：ribbon组件结合RestTemplate来实现负载均衡，只需给restTemplate加上@LoadBalanced注解就可以实现。ribbon是根据服务名称application.name来做负载均衡的。

搭建EurekaServer

  1. 配置pom.xml

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

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <!--   2.3.8版本boot支持cloud Hoxton.SR11 版本，更高的boot需要cloud Hoxton 以上才可 ，详情参考spring.io -->
      <version>Hoxton.SR11</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <!--  jar或war包名称  -->
  <finalName>springcloud-ribbon-eureka-server</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

  2. 配置application.properties

    # 应用名称
spring.application.name=eureka-server
# 服务端口
server.port=8001
# eureka的主机名称
eureka.instance.hostname=eureka1
# 客户端配置-注册中心访问地址, eureka1是在Hosts配置的映射，替代域名的作用。
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka

  3. 添加启动类

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class SpringcloudRibbonEurekaServerApplication {

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

}
搭建EurekaClient-Provider

  1. 配置pom

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

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <!--   2.3.8版本boot支持cloud Hoxton.SR11 版本，更高的boot需要cloud Hoxton 以上才可 ，详情参考spring.io -->
      <version>Hoxton.SR11</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <finalName>springcloud-ribbon-eureka-provider</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

  2. 配置application

    server.port=7001
spring.application.name=provider-service

# 注册到eureka显示IP
eureka.instance.prefer-ip-address=true
# 租期到期间隔，eureka服务器从收到最后一次心跳开始等待的时间(以秒为单位)； 该值必须至少高于“leaseRenewalIntervalInSeconds”中指定的值
eureka.instance.lease-expiration-duration-in-seconds=10
# 租期更新间隔，eureka客户端需要发送心跳到eureka服务器的频率(以秒为单位)
eureka.instance.lease-renewal-interval-in-seconds=5
# 开启健康监测, 必须引入spring-boot-starter-actuator的jar包
eureka.client.healthcheck.enabled=true
# 注册中心地址
eureka.client.service-url.defaultZone=http://eureka1:8001/eureka

  3. 添加启动类

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringcloudRibbonEurekaProviderApplication {

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

}

  4. 添加接口服务

    import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
public class UserController {
    private static List<User> users = new ArrayList<>();

    @GetMapping("getUser")
    public User getUser(@RequestParam String id) throws InterruptedException {
        log.info("provider-service ------getUser 获取用户信息--------id: {}",id);
        TimeUnit.SECONDS.sleep(2);
        return new User("001","张三",18);
    }

    @PostMapping("postUser")
    public List<User> postUser(@RequestBody User requestUser) throws InterruptedException {
        log.info("provider-service ------postUser 获取用户信息--------requestUser: {}", JSON.toJSONString(requestUser));
        TimeUnit.SECONDS.sleep(2);
        users.add(requestUser);
        return users;
    }
}
搭建EurekaClient-Provider-Second

同理，按照搭建EurekaClient-Provider的方式再搭一套服务提供者，这两个服务用同样的服务名称。通过端口号来区分开即可。

  1. 配置pom

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

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <!--   2.3.8版本boot支持cloud Hoxton.SR11 版本，更高的boot需要cloud Hoxton 以上才可 ，详情参考spring.io -->
      <version>Hoxton.SR11</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <finalName>springcloud-ribbon-eureka-provider-second</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

  2. 配置application

    server.port=7002
spring.application.name=provider-service

# 注册到eureka显示IP
eureka.instance.prefer-ip-address=true
# 租期到期间隔，eureka服务器从收到最后一次心跳开始等待的时间(以秒为单位)； 该值必须至少高于“leaseRenewalIntervalInSeconds”中指定的值
eureka.instance.lease-expiration-duration-in-seconds=10
# 租期更新间隔，eureka客户端需要发送心跳到eureka服务器的频率(以秒为单位)
eureka.instance.lease-renewal-interval-in-seconds=5
# 开启健康监测, 必须引入spring-boot-starter-actuator的jar包
eureka.client.healthcheck.enabled=true
# 注册中心地址
eureka.client.service-url.defaultZone=http://eureka1:8001/eureka

  3. 添加启动类

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringcloudRibbonEurekaProviderSecondApplication {

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

}

  4. 添加接口服务

    import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
public class UserController {
    private static List<User> users = new ArrayList<>();

    @GetMapping("getUser")
    public User getUser(@RequestParam String id) throws InterruptedException {
        log.info("provider-second-service ------getUser 获取用户信息--------id: {}",id);
        TimeUnit.SECONDS.sleep(2);
        return new User("001","张三",18);
    }

    @PostMapping("postUser")
    public List<User> postUser(@RequestBody User requestUser) throws InterruptedException {
        log.info("provider-second-service ------postUser 获取用户信息--------requestUser: {}", JSON.toJSONString(requestUser));
        TimeUnit.SECONDS.sleep(2);
        users.add(requestUser);
        return users;
    }
}
搭建EurekaClient-Consumer

  1. 配置pom

    <dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <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-ribbon</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <!--   2.3.8版本boot支持cloud Hoxton.SR11 版本，更高的boot需要cloud Hoxton 以上才可 ，详情参考spring.io -->
      <version>Hoxton.SR11</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <finalName>springcloud-ribbon-eureka-consumer</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

  2. 配置application

    server.port=7003
spring.application.name=consumer-service

# 注册到eureka显示IP
eureka.instance.prefer-ip-address=true
# 租期到期间隔，eureka服务器从收到最后一次心跳开始等待的时间(以秒为单位)； 该值必须至少高于“leaseRenewalIntervalInSeconds”中指定的值
eureka.instance.lease-expiration-duration-in-seconds=10
# 租期更新间隔，eureka客户端需要发送心跳到eureka服务器的频率(以秒为单位)
eureka.instance.lease-renewal-interval-in-seconds=5
# 开启健康监测, 必须引入spring-boot-starter-actuator的jar包
eureka.client.healthcheck.enabled=true
# 注册中心地址
eureka.client.service-url.defaultZone=http://eureka1:8001/eureka

  3. 添加启动类

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringcloudRibbonEurekaConsumerApplication {

    @Bean // 交给spring管理
    @LoadBalanced // 开启负载均衡
    public RestTemplate restTemplate(){
        HttpComponentsClientHttpRequestFactory httpComponentsClientHttpRequestFactory 
          = new HttpComponentsClientHttpRequestFactory();
        httpComponentsClientHttpRequestFactory.setConnectTimeout(10000);
        httpComponentsClientHttpRequestFactory.setConnectionRequestTimeout(10000);
        httpComponentsClientHttpRequestFactory.setReadTimeout(20000);
        return new RestTemplate(httpComponentsClientHttpRequestFactory);
    }

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

}
启动测试

启动所有服务，8001端口服务是Eureka注册中心，7001和7002是模拟同一个服务提供者，7003是服务消费者。

我们来访问注册中心验证一下

访问consumer接口来观察provider控制台打印信息，测试负载均衡：

访问三次http://localhost:7003/get接口

consumer控制台如下：

2021-06-18 16:02:56.914  INFO 66739 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:07:56.920  INFO 66739 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:12:56.930  INFO 66739 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:15:12.584  INFO 66739 --- [nio-7003-exec-1] c.e.s.c.r.e.c.api.ConsumerController     : 成功获取到数据：{"id":"001","name":"张三","age":18}
2021-06-18 16:15:16.285  INFO 66739 --- [nio-7003-exec-2] c.e.s.c.r.e.c.api.ConsumerController     : 成功获取到数据：{"id":"001","name":"张三","age":18}
2021-06-18 16:15:19.572  INFO 66739 --- [nio-7003-exec-3] c.e.s.c.r.e.c.api.ConsumerController     : 成功获取到数据：{"id":"001","name":"张三","age":18}

provider控制台如下：

2021-06-18 16:06:02.594  INFO 68778 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:11:02.600  INFO 68778 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:15:14.259  INFO 68778 --- [nio-7001-exec-1] c.e.s.c.r.e.provider.api.UserController  : provider-service ------getUser 获取用户信息--------id: 001
2021-06-18 16:16:02.612  INFO 68778 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration

Provider-second控制台如下：

2021-06-18 16:02:06.544  INFO 66614 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:07:06.553  INFO 66614 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:12:06.562  INFO 66614 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration
2021-06-18 16:15:10.577  INFO 66614 --- [nio-7002-exec-7] c.e.s.c.r.e.p.second.api.UserController  : provider-second-service ------getUser 获取用户信息--------id: 001
2021-06-18 16:15:17.565  INFO 66614 --- [nio-7002-exec-8] c.e.s.c.r.e.p.second.api.UserController  : provider-second-service ------getUser 获取用户信息--------id: 001

由上可知consumer访问3次接口，分别调用到了provider1次，provider-second2次，实现了负载均衡的效果。

Ribbon Retry重试机制

应用场景：通常在服务调用时可能服务提供者无法正常提供服务，正在重启或服务已经宕机，那么可以利用重试机制来重新发送请求，一直到服务可用，一定程度上保证业务可用。

Spring原生Retry

  1. 配置pom.xml

    <!-- spring 原生retry组件 -->
<dependency>
  <groupId>org.springframework.retry</groupId>
  <artifactId>spring-retry</artifactId>
</dependency>

  2. 编写重试接口

    import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

/**
 * spring原生retry组件测试，
 * 可以通过
 * @see com.example.springcloud.ribbon.retry.SpringcloudRibbonRetryApplicationTests#retryTest() 测试类进行演示。
 */
@Slf4j
@Service
public class UserService {

    @Retryable(
            value = {RemoteAccessException.class},// 发生这个异常进行重试
            maxAttempts = 5,// 重试次数，默认3次
            backoff = @Backoff(delay = 2000L,multiplier = 1) // 延迟3秒进行重试，单线程处理
    )
    public void run(){
        log.info("--------run-------------");
        throw new NullPointerException("执行逻辑空指针了...");
//        throw new RemoteAccessException("远程调用失败...");
    }

    /**
     * 最后一次失败后调用此方法
     * @param e 异常
     */
    @Recover
    public void recover(RemoteAccessException e){
        log.warn("RAE最终处理的结果是:"+e.getMessage());
    }

    /**
     * 如果NullPointerException没用放到Retryable注解的value值内，获取到异常则不会重试，直接执行1次本方法。
     * @param e 异常
     */
    @Recover
    public void recover(NullPointerException e){
        log.warn("NPE最终处理的结果是:"+e.getMessage());
    }
}

  3. 编写测试类

    import com.example.springcloud.ribbon.retry.service.UserService;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringcloudRibbonRetryApplication.class)
class SpringcloudRibbonRetryApplicationTests {

    @Autowired
    private UserService userService;

    /**
     * spring原生retry测试
     * @throws Exception
     */
    @Test
    void retryTest() throws Exception {
        userService.run();
    }
}

  4. 运行查看控制台：因为NullPointerException没有被配置Retryable所以发生异常时就直接调用public void recover(NullPointerException e)方法了。

    2021-06-19 06:12:12.402  INFO 77851 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:12:12.402  WARN 77851 --- [           main] c.e.s.ribbon.retry.service.UserService   : NPE最终处理的结果是:执行逻辑空指针了...

  5. 接下来修改一下UserService的@Retryable值，将NullPointerException也加到配置中，如下：

    @Retryable(
  value = {RemoteAccessException.class,NullPointerException.class},// 发生这些异常进行重试
  maxAttempts = 5,// 重试次数，默认3次
  backoff = @Backoff(delay = 2000L,multiplier = 1) // 延迟3秒进行重试，单线程处理
)

  6. 再次运行测试类：可以看到共进行了5次重试，每隔2秒1次，并且在最后一次重试后调用了reconver()方法。

    2021-06-19 06:16:38.956  INFO 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:16:40.959  INFO 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:16:42.961  INFO 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:16:44.963  INFO 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:16:46.968  INFO 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : --------run-------------
2021-06-19 06:16:46.968  WARN 77944 --- [           main] c.e.s.ribbon.retry.service.UserService   : NPE最终处理的结果是:执行逻辑空指针了...

接下来我们看一下SpringCloud Ribbon的Retry实现。

SpringCloud Ribbon Retry配置

因为cloud的retry是基于HTTP接口进行重试的，所以只要在注册到eureka服务上进行调用即可。

基本原理：

  1. 假设有providerA服、providerB服务、consumerC服务、eurekaServer服务等4个服务。
  2. consumerC去调用providerA和providerB，因为做了负载均衡，不确定调用到哪个提供者。
  3. 我们给consumerC配置HTTP读取超时时间为2秒（2秒内不返回结果认为连接超时）
  4. 同时让其中一个提供者的接口休眠4秒，另一个提供者正常提供服务。
  5. 访问consumerC的接口来测试是否有重试效果。

注意：在E版本之前，要防止hystix断路器超时时间导致retry失效。对于E版本之后，不需要考虑断路器的超时时间了

  1. 配置retry-service（消费端）的application.yml文件

    spring:
  application:
    name: retry-service # 服务名称
  cloud:
    loadbalancer:
      retry:
        enabled: true # 开启重试功能

server:
  port: 7004 # 服务端口
  servlet:
    context-path: / 
# Eureka的相关配置
eureka:
  client:
    healthcheck:
      enabled: true  # 开启健康监测
    service-url:
      defaultZone: http://eureka1:8001/eureka  # 注册中心地址

# 自定义配置：针对所有RestTemplate发起的HTTP请求做超时配置
custom:
  request-factory:
    connect-timeout: 10000 # HTTP连接超时时间
    connection-request-timeout: 10000 # 请求连接超时时间 
    read-timeout: 2000  # HTTP读取时间，如果再2秒内没有得到结果，则认为超时

# 针对某个微服务进行重试策略配置
provider-service:
  ribbon:
    OkToRetryOnAllOperations: true # 对所有请求做重试
    MaxAutoRetriesNextServer: 1 # 切换实例次数
    MaxAutoRetries: 2 # 对当前实例进行重试次数

  2. 配置pom.xml

    <parent>
  <groupId>com.example</groupId>
  <artifactId>springcloud-ribbon</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</parent>

<artifactId>springcloud-ribbon-retry</artifactId>
<version>0.0.1-SNAPSHOT</version>

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <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-ribbon</artifactId>
  </dependency>
  <!-- spring 原生retry组件 -->
  <dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <!--   2.3.8版本boot支持cloud Hoxton.SR11 版本，更高的boot需要cloud Hoxton 以上才可 ，详情参考spring.io -->
      <version>Hoxton.SR11</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <finalName>springcloud-ribbon-retry</finalName>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

  3. 添加启动类

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient
@EnableRetry // 原生spring retry组件
public class SpringcloudRibbonRetryApplication {

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

    @Bean // 交给spring管理
    @LoadBalanced // 开启负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate(httpComponentsClientHttpRequestFactory());
    }

    /**
     * 读取自定义配置
     * @return HttpComponentsClientHttpRequestFactory
     */
    @ConfigurationProperties(prefix = "custom.request-factory")
    @Bean
    public HttpComponentsClientHttpRequestFactory httpComponentsClientHttpRequestFactory(){
        return new HttpComponentsClientHttpRequestFactory();
    }

}

  4. 编写API测试接口

    import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@Slf4j
@RestController
public class RetryController {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 调用provider-service
     * @return
     */
    @GetMapping("retry")
    public String retry(){
        User user = restTemplate.getForObject("http://provider-service/getUser?id={1}", User.class,"001");
        log.info("调用service结果：{}", JSON.toJSONString(user));
        return "成功获取调用结果："+user;
    }
}

  5. 修改provider-service其中的一个接口（让方法耗时大于retry-service配置的HTTP读取超时时间，而触发重试机制去调用另一台provider-service ）

    @GetMapping("getUser")
public User getUser(@RequestParam String id) throws InterruptedException {
  log.info("provider-service ------getUser 获取用户信息--------id: {}",id);
  TimeUnit.SECONDS.sleep(3);// 休眠3秒，retry-service的HTTP readTimeout为2秒
  return new User("001","张三",18);
}

  6. 启动测试

  1. 访问http://localhost:7004/retry 进行测试

    retry-service控制台打印：最终获取到了调用结果，但是浏览器等待很久（因为进行了多次重试）。

    2021-06-18 21:42:24.044  INFO 77045 --- [nio-7004-exec-1] c.netflix.config.ChainedDynamicProperty  : Flipping property: provider-service.ribbon.ActiveConnectionsLimit to use NEXT property: niws.loadbalancer.availabilityFilteringRule.activeConnectionsLimit = 2147483647
2021-06-18 21:42:24.064  INFO 77045 --- [nio-7004-exec-1] c.n.u.concurrent.ShutdownEnabledTimer    : Shutdown hook installed for: NFLoadBalancer-PingTimer-provider-service
2021-06-18 21:42:24.064  INFO 77045 --- [nio-7004-exec-1] c.netflix.loadbalancer.BaseLoadBalancer  : Client: provider-service instantiated a LoadBalancer: DynamicServerListLoadBalancer:{NFLoadBalancer:name=provider-service,current list of Servers=[],Load balancer stats=Zone stats: {},Server stats: []}ServerList:null
2021-06-18 21:42:24.068  INFO 77045 --- [nio-7004-exec-1] c.n.l.DynamicServerListLoadBalancer      : Using serverListUpdater PollingServerListUpdater
2021-06-18 21:42:24.085  INFO 77045 --- [nio-7004-exec-1] c.netflix.config.ChainedDynamicProperty  : Flipping property: provider-service.ribbon.ActiveConnectionsLimit to use NEXT property: niws.loadbalancer.availabilityFilteringRule.activeConnectionsLimit = 2147483647
2021-06-18 21:42:24.086  INFO 77045 --- [nio-7004-exec-1] c.n.l.DynamicServerListLoadBalancer      : DynamicServerListLoadBalancer for client provider-service initialized: DynamicServerListLoadBalancer:{NFLoadBalancer:name=provider-service,current list of Servers=[172.19.137.36:7001, 172.19.137.36:7002],Load balancer stats=Zone stats: {defaultzone=[Zone:defaultzone;	Instance count:2;	Active connections count: 0;	Circuit breaker tripped count: 0;	Active connections per server: 0.0;]
},Server stats: [[Server:172.19.137.36:7002;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]
, [Server:172.19.137.36:7001;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]
]}ServerList:org.springframework.cloud.netflix.ribbon.eureka.DomainExtractingServerList@5545ced6
2021-06-18 21:42:25.073  INFO 77045 --- [erListUpdater-0] c.netflix.config.ChainedDynamicProperty  : Flipping property: provider-service.ribbon.ActiveConnectionsLimit to use NEXT property: niws.loadbalancer.availabilityFilteringRule.activeConnectionsLimit = 2147483647
2021-06-18 21:42:31.145  INFO 77045 --- [nio-7004-exec-1] c.e.s.ribbon.retry.api.RetryController   : 调用service结果：{"age":18,"id":"001","name":"张三"}

    provider-service1控制台：进行了3次重试，但每次都超时。

    2021-06-18 21:42:24.112  INFO 76849 --- [nio-7001-exec-4] c.e.s.c.r.e.provider.api.UserController  : provider-service ------getUser 获取用户信息--------id: 001
2021-06-18 21:42:26.120  INFO 76849 --- [nio-7001-exec-5] c.e.s.c.r.e.provider.api.UserController  : provider-service ------getUser 获取用户信息--------id: 001
2021-06-18 21:42:28.122  INFO 76849 --- [nio-7001-exec-6] c.e.s.c.r.e.provider.api.UserController  : provider-service ------getUser 获取用户信息--------id: 001

    provider-service2控制台：被调用了1次，直接返回结果。

    2021-06-18 21:42:30.124  INFO 76767 --- [nio-7002-exec-6] c.e.s.c.r.e.p.second.api.UserController  : provider-second-service ------getUser 获取用户信息--------id: 001
2021-06-18 21:42:47.104  INFO 76767 --- [trap-executor-0] c.n.d.s.r.aws.ConfigClusterResolver      : Resolving eureka endpoints via configuration

    好了，springcloud的retry就搞定了！

    文中用到的代码示例下载：https://gitee.com/yunnasheng/springcloud-ribbon

留白1108
关注
spring cloud gateway网关和负载均衡框架ribbon实战
进阶的球儿
05-13 6201
通常我们如果有一个服务，会部署到多台服务器上，这些微服务如果都暴露给客户，是非常难以管理的，我们系统需要有一个唯一的出口，API网关是一个服务，是系统的唯一出口。API网关封装了系统内部的微服务，为客户端提供一个定制的API。客户端只需要调用网关接口，就可以调用到实际的微服务，实际的服务对客户不可见，并且容易扩展服务。 API网关可以结合ribbon完成负载均衡的功能，可以自动检查微服务的状况，及时剔除或者加入某个微服务到可用服务列表。此外网关可以完成权限检查、限流、统计等功能。下面我们将一一完成...
springcloud项目小小实战
weixin_44479107的博客
08-05 1053
SpringCloud组件 1.Eureka：注册中心，就是用来管理所有服务的地址 2.Ribbon：是用来做负载均衡的，就是帮助我们选择调用服务集群的那个服务 3.openFeign：帮助我们做服务之间调用的，默认集成了Ribbon 4.Hystrix：断路器，就是为了防止服务雪崩，可以帮助我们快速响应，返回兜底数据，可以对服务进行降级 5.config：配置中心，是管理所有服务的配置的组件，后面使用配置中心改了配置动态刷新 6.Bus：消息总栈，可以给所有服务广播消息，让所有服务进行消费
c.n.d.s.r.aws.ConfigClusterResolver:Resolving eureka endpoints via configuration
qq 117791303
11-14 4247
c.n.d.s.r.aws.ConfigClusterResolver:Resolving eureka endpoints via configuration
springcloud禁止输出日志：ConfigClusterResolver : Resolving eureka endpoints via configuration
11-22 3万+
https://blog.youkuaiyun.com/coolcoffee168/article/details/90665113 springcloud的注册中心客户端会每隔一定时间向注册中心服务端发送心跳，用此来判断注册中心服务端是否运行正常。 这样导致不断进行日志输出，不便查看正常的业务日志输出。 c.n.d.s.r.aws.ConfigClusterResolver : Res...
springcloud禁止输出日志：ConfigClusterResolver : Resolving eureka endpoints via configuration
热门推荐
coolcoffee168的专栏
05-29 10万+
springcloud的注册中心客户端会每隔一定时间向注册中心服务端发送心跳，用此来判断注册中心服务端是否运行正常。 这样导致不断进行日志输出，不便查看正常的业务日志输出。 c.n.d.s.r.aws.ConfigClusterResolver : Resolving eureka endpoints via configuration 看看ConfigClusterResolv...
集成Euraka的SpringBoot工程禁止输出日志：ConfigClusterResolver : Resolving eureka endpoints via configuration的方法
IT- 研究者
02-25 7448
一、问题描述 springcloud的注册中心客户端会每隔一定时间向注册中心服务端发送心跳，用此来判断注册中心服务端是否运行正常。 这样导致不断进行日志输出，不便查看正常的业务日志输出。 c.n.d.s.r.aws.ConfigClusterResolver : Resolving eureka endpoints via configuration 二、问题分析 看...
SpringCloud zuul使用报错
zw0558的专栏
04-14 1639
SpringCloud zuul使用报错
spring boot spring could
12-20
而"springCloud"可能包含了Spring Cloud相关的示例或者配置，如Eureka客户端的配置、Ribbon的使用等。导入Eclipse后，开发者可以查看并学习这些示例，了解如何将Spring Boot与Spring Cloud整合。 5. 学习资源 要...
springcould.rar
05-26
本文将深入探讨SpringCloud的五大核心组件，以及如何从基础到实战，掌握这些组件的使用。 一、Eureka：服务注册与发现 Eureka是SpringCloud中的服务注册与发现组件，它允许各个服务实例在启动时向Eureka Server注册...
微服务 （第二部分）springcould_18
05-23
6. 拼图服务：Spring Cloud Ribbon提供了客户端的负载均衡器，与Eureka结合使用，实现服务间的智能路由。 7. 分布式追踪：Spring Cloud Sleuth配合Zipkin或ELK Stack，提供分布式系统的跟踪和日志分析。 三、云原生...
【九】Spring Cloud Ribbon源码分析
Sid小杰的博客
03-08 696
一、简介及核心原理 Ribbo有两种结合使用的方式，一种是与RestTemplate结合使用，另外一种是与Feign结合使用，下面是结合RestTemplate的配置。 @SpringBootApplication @EnableEurekaClient @EnableFeignClients @EnableHystrix public class OrderApp { public static void main(String[] args) { SpringAppl.
记一次故障引发的线程池使用的思考（转）
zhutianrong520的博客
04-18 993
一、悬案 某日某晚 8 时许，一阵急促的报警电话响彻技术团队的工位，小虎同学，小峰同学纷纷打开监控平台一探究竟。分销员系统某核心应用，接口响应全部超时，dubbo 线程池被全部占满，并堆积了大量待处理任务，整个应用无法响应任何外部请求，处于“夯死”的状态。 正当小虎小峰两位同学焦急的以各种姿势查看应用的各项指标时，5分钟过去了，应用居然自己自动恢复了。看似虚惊一场，但果真如此吗？ 二、勘查线索 ...
Java线程池任务执行完毕后回收线程
Agly_Charlie的博客
02-27 1万+
Java线程池任务执行完毕后回收线程 线程池中的所有任务执行完毕后，线程并没有停止,导致JVM出现OOM问题。后来查找了下面链接的资料，解决问题。 ref: http://www.cnblogs.com/pengineer/p/5011965.html 问题及现象： public static void main(String[] args) { BlockingQueue queu...
tomcat内存溢出全记录
戰士博客
12-16 1878
目录 内存溢出解决记录 内存及GC 的相关参数 内存溢出解决记录 项目平稳运行到1个月5天时候，tomcat服务突然崩溃，首先查看下tomcat的日志，如下： 24-Sep-2019 10:39:06.628 严重 [http-nio-9090-exec-53] org.apache.catalina.core.StandardWrapperValve.invoke...
Spring Cloud之踩坑01 -- Eureka高可用配置
dear_Alice_moon的专栏
02-26 6万+
问题描述： 在进行Eureka高可用配置时，控制台一直出现“”的错误，但是在浏览器中输入地址：peer1:8761是，却可正常运行。对此，我不懂为何控制台出现异常报错，但是浏览器中却可正确运行。 现在，我将我所遇到的现象进行如下描述。 创建的项目：microservice-discovery-eureka-ha ，其application.yml文件配置内容如下：sprin...
spring cloud discovery bootstrap first 非对称加密坑
碧海擎天逍遥仙
04-16 3667
2017-04-16 00:18:17.613 INFO [water-cloud-provider-uac,,,] [water-cloud-provider-uac,,,,] 9096 --- [ main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.a
Spring Cloud - - - 通过消息总线更新配置中心，导致client-config服务实例在注册中心全部丢失的问题
wdg6311的博客
07-19 7603
最近在使用Spring Cloud搭建配置中心的实例以及简易应用的时候，遇到了一个非常奇怪的问题。   项目结构 使用java -jar的方式启动了eureka注册中心集群（3台部署），一台zuul负责转发请求到服务，service-hi服务集群（2台部署），配置中心由一台server服务器和两台client构建而成。   需求 调用zuul,负载均衡到service-hi服务器，在s...
spring cloud eureka高可用配置
无名程序员
01-26 7662
要点：配置2个eureka服务，相互连通即可 配置2份配置【ha-a】 server: port: 8761 spring: profiles: ha-a eureka: instance: hostname: localhost client: service-url: defaultZone: http://admin:admin@loc
Spring Cloud全栈教程：核心技术与实战视频
3. **Ribbon**：Ribbon是Netflix提供的一个客户端负载均衡库，它结合了Hystrix（断路器模式）来处理分布式系统的容错和熔断机制，提高系统的健壮性。 4. **Hystrix**：Hystrix是一个流量控制和熔断工具，它提供了一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值