[SpringCloud系列009] SpringCloud之 Ribbon

1.Ribbon的负载均衡策略有：

废话不多说,先上图

策略类	命名	描述
RandomRule	随机策略	随机选择server
RoundRobinRule	轮询策略	轮询选择， 轮询index，选择index对应位置的Server；
RetryRule	重试策略	对选定的负载均衡策略机上重试机制，在一个配置时间段内当选择Server不成功，则一直尝试使用subRule的方式选择一个可用的server；
BestAvailableRule	最低并发策略	逐个考察server，如果server断路器打开，则忽略，再选择其中并发链接最低的server
AvailabilityFilteringRule	可用过滤策略	过滤掉一直失败并被标记为circuit tripped的server，过滤掉那些高并发链接的server（active connections超过配置的阈值）或者使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个Server的运行状态；
ResponseTimeWeightedRule	响应时间加权重策略	根据server的响应时间分配权重，响应时间越长，权重越低，被选择到的概率也就越低。响应时间越短，权重越高，被选中的概率越高，这个策略很贴切，综合了各种因素，比如：网络，磁盘，io等，都直接影响响应时间
ZoneAvoidanceRule	区域权重策略	综合判断server所在区域的性能，和server的可用性，轮询选择server并且判断一个AWS Zone的运行性能是否可用，剔除不可用的Zone中的所有server

可以使用代码配置和属性配置的方式为某一个微服务提供轮询策略，比如A服务使用随即策略，B服务使用轮询策略。。

2.使用方式

代码配置：

代码示例

• 创建一个空类，并在其上添加@Configuration 注解和@RibbonClient 注解。

/**
 * 使用RibbonClient，为特定的目标服务 user 自定义配置。
 * 使用@RibbonClient的configuration属性，指定Ribbon的配置类。
 */
@Configuration
@RibbonClient(name = "user", configuration = RibbonConfiguration.class)
public class TestConfiguration {
}

由代码可知，使用@RibbonClient 注解的configuration属性，即可自定义指定名称Ribbon客户端的配置。

• 创建Ribbon的配置类。

/**
 * 该类为Ribbon的配置类
 * 注意：该类不能放在主应用程序上下文@ComponentScan所扫描的包中，否则配置将会被所有Ribbon Client共享。*/
@Configuration
public class RibbonConfiguration {
  @Bean
  public IRule ribbonRule() {
    // 负载均衡规则，改为随机
    return new RandomRule();
  }
}

注意：该类不能放在主应用程序上下文@ComponentScan所扫描的包中，否则配置将会被所有Ribbon Client共享。

如果放到扫描包里面，那也可以自定义注解，标记不自动扫描类：

public @interface IgnoreScan {
}

然后配置策略，使用不自动扫描注解：

@Configuration
@IgnoreScan //这是自定义的注解
public class CustomLoadBalanceConfig {
    @Bean
    public IRule ribbonRule(){
        return new RandomRule();
    }
}

最后在启动类，定义组件扫码 和 设置服务的负载均衡策略：

@RibbonClient(name = "user", configuration = CustomLoadBalanceConfig.class)//这里指定了使用上面的configuration，name是服务id
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value =IgnoreScan.class)})

属性配置

代码示例：

user:#这个是微服务的id
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #随机策略

属性配置的优先级高于代码配置。

除了上面的针对某一个微服务的细粒度的配置，还可以全局配置，Ribbon只支持使用代码实现全局配置。

全局配置：

//首先定义一个空类，使用@RibbonClients@RibbonClients(defaultConfiguration = DefaultRibbonConfig.class)
public class RibbonClientDefaultConfigurationTestsConfig {
}//然后定义一个config类，指定使用的负载均衡策略
@Configuration
public class DefaultRibbonConfig {
  @Bean
  public IRule ribbonRule() {
    return new RandomRule();
  }
}

UserController

@RestController
public class UserController {
  @Autowired
  private UserRepository userRepository;
  @Autowired
  private Registration registration;

  @GetMapping("/{id}")
  public User findById(@PathVariable Long id) {
    User findOne = userRepository.findOne(id);
    return findOne;
  }
  
  @GetMapping("/getIpAndPort")
  public String findById() {
	  return registration.getHost() + ":" + registration.getPort();
  }
}

**user服务提供者,配置 **

server:
  port: 8001
spring:
  application:
    name: microservice-provider-user
  jpa:
    generate-ddl: false
    show-sql: true
    hibernate:
      ddl-auto: none
  datasource:                           # 指定数据源
    platform: h2                        # 指定数据源类型
    schema: classpath:schema.sql        # 指定h2数据库的建表脚本
    data: classpath:data.sql            # 指定h2数据库的数据脚本
logging:           # 配置日志级别，让hibernate打印出执行的SQL
  level:
    root: INFO
    org.hibernate: INFO
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
    org.hibernate.type.descriptor.sql.BasicExtractor: TRACE
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

服务消费者order

server:
  port: 8010
spring:
  application:
    name: microservice-consumer-order
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

启动类

@LoadBalanced

@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerOrderApplication {
  @Bean
  @LoadBalanced
  public RestTemplate restTemplate() {
    return new RestTemplate();
  }

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

调用user

@RestController
public class OrderController {
  private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class);
  @Autowired
  private RestTemplate restTemplate;
  @Autowired
  private LoadBalancerClient loadBalancerClient;

  @GetMapping("/user/{id}")
  public User findById(@PathVariable Long id) {
    return this.restTemplate.getForObject("http://microservice-provider-user/" + id, User.class);
  }
  
  @GetMapping("/user/getIpAndPort")
  public String getIpAndPort() {
	  return this.restTemplate.getForObject("http://microservice-provider-user/getIpAndPort", String.class);
  }
  
  @GetMapping("/user1/getIpAndPort")
  public String getUserIpAndPort() {
	  return this.restTemplate.getForObject("http://microservice-provider-user222/getIpAndPort", String.class);
  }

  @GetMapping("/log-user-instance")
  public void logUserInstance() {
    ServiceInstance serviceInstance = this.loadBalancerClient.choose("microservice-provider-user");
    // 打印当前选择的是哪个节点
    OrderController.LOGGER.info("{}:{}:{}", serviceInstance.getServiceId(), serviceInstance.getHost(), serviceInstance.getPort());
  }
}

/**
 * 使用RibbonClient，为特定name的Ribbon Client自定义配置.
 * 使用@RibbonClient的configuration属性，指定Ribbon的配置类.
 */
@Configuration
@RibbonClient(name = "microservice-provider-user", 
configuration = RibbonConfiguration.class)
public class ProviderUserConfiguration {}

/**
 * 该类为Ribbon的配置类
 * 注意：该类不应该在主应用程序上下文的@ComponentScan 中。
 */
@Configuration
public class RibbonConfiguration {
  @Bean
  public IRule ribbonRule() {
    // 负载均衡规则，改为随机
    return new RandomRule();
  }
}

包结构图

配置负载均衡策略

server:
  port: 8010
spring:
  application:
    name: microservice-consumer-order
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

microservice-provider-user:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

ribbon脱离eureka实现负载均衡

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

server:
  port: 8010
spring:
  application:
    name: microservice-consumer-order
microservice-provider-user:
  ribbon:
    listOfServers: localhost:8001,localhost:8002
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule