Spring Cloud(Finchley.SR1)之服务调用及使用ribbon实现负载均衡(三)

最新推荐文章于 2024-10-16 19:03:08 发布
最新推荐文章于 2024-10-16 19:03:08 发布
阅读量4k 收藏 2
点赞数 1
分类专栏： Spring Cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014401141/article/details/78652101
版权

目录

 

基本介绍

 

1.服务提供者

1.1 被调用的服务controller

1.2 启动类

2.服务调用者

2.1启动类

2.2消费者service

2.3 getForEntity

2.4 getForObject

2.5 POST请求

2.6 消费者controller

3.ribbon

4.自定义Ribbon客户端

4.1通过配置类来实现ribbion自动化配置

4.2使用属性自定义Ribbon客户端

基本介绍

Spring Cloud Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡工具，它基于 Netflix Ribbon 实现。 通过 Spring Cloud 的封装， 可以让我们轻松地将面向服务的 REST 模板请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon 虽然只是一个工具类框架，它不像服务注册中心、 配置中心、 API 网关那样需要独立部署， 但是它几乎存在于每一个Spring Cloud 构建的微服务和基础设施中。 因为微服务间的调用，API 网关的请求转发等内容实际上都是通过Ribbon 来实现的，包括后续我们将要介绍的 Feign, 它也是基于 Ribbon实现的工具。

在微服务架构中，业务都会被拆分成一个独立的服务，服务与服务的通讯是基于http Restful的。Spring Cloud有两种服务调用方式，一种是ribbon+restTemplate，另一种是feign。

我们通常所说的负载均衡都指的是服务端负载均衡， 其中分为硬件负载均衡和软件负载均衡。 硬件负载均衡主要通过在服务器节点之间安装专门用于负载均衡的设备，比如F5等；而软件负载均衡则是通过在服务器上安装 一些具有均衡负载功能或模块的软件来完成请求分发工作， 比如Nginx等。 不论采用硬件负载均衡还是软件负载均衡，硬件负载均衡的设备或是软件负载均衡的软件模块都会维护一个下挂可用的服务端清单，通过心跳检测来剔除故障的服务端节点以保证清单中都是可以正常访问的服务端节点。当客户端发送请求到负载均衡设备的时候， 该设备按某种算法（比如线性轮询、 按权重负载、 按流量负载等）从维护的可用服务端清单中取出 一台服务端的地址， 然后进行转发。而客户端负载均衡和服务端负载均衡最大的不同点在于上面所提到的服务清单所存储的位置。 在客户端负载均衡中， 所有客户端节点都维护着自己要访问的服务端清单， 而这些服务端的清单来自于服务注册中心，比如上一章我们介绍的Eureka服务端。同服务端负载均衡的架构类似， 在客户端负载均衡中也需要心跳去维护服务端清单的健康性， 只是这个步骤需要与服务注册中心配合完成。

所有微服务汇集到了Eureka 之中，这样所有的微服务汇集到了Eureka之中，而客户端的调用也应该通过Eureka完成，这种调用可以通过Ribbon技术来实现。Ribbon是一个服务调用组件，并且是一个客户端实现负载均衡的处理的组件。

 

1.服务提供者

1.1 被调用的服务controller

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @RequestMapping("/hello")
    public String home(@RequestParam Integer age) {
        return helloService.hello(age).toString();
    }

}

 

1.2 启动类

package com.alen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@SpringBootApplication
//通过注解@EnableEurekaClient 表明自己是一个eurekaclient.
@EnableEurekaClient
public class EurekaClientApplication {

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

 pom.xml

<?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>spring-cloud</artifactId>
        <groupId>com.alen</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <artifactId>eureka-client</artifactId>
    <dependencies>
        <!--eureka client -->
           <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>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.properties.yml

server:
  port: 8011
eureka:
    instance:
      hostname: localhost
      # 发呆时间，即服务失效时间（缺省为90s）,就是超过15秒没有续约就会从注册表中剔除
      lease-expiration-duration-in-seconds: 15
      # 心跳时间，即服务续约间隔时间（缺省为30s）
      lease-renewal-interval-in-seconds: 5
    client:
     #设置eureka服务器所在的地址，查询服务和注册服务都需要依赖这个地址。高可用的注册中心时，
      #可以配置多个注册中心，通过逗号隔开
      service-url:
       defaultZone: http://localhost:8010/eureka/
spring:
  application:
     #这在以后的服务与服务之间相互调用一般都是根据这个name
    name: user

 

2.服务调用者

2.1启动类

package com.alen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
//通过注解@EnableEurekaClient 表明自己是一个eurekaclient.
@EnableEurekaClient
public class RibbonServiceApplication {

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

   /**
    * 向程序的ioc注入一个bean: restTemplate;
    * 并通过@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。
    */
   @Bean
   @LoadBalanced
    public     RestTemplate restTemplate() {
      return new RestTemplate();
   }
}

 

 

2.2消费者service

package com.alen.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

/**
 * 测试调用
 *
 * @create 2017-11-27 17:14
 **/
@Service
public class HelloService {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    RestTemplate restTemplate;
    @Value("${consumerURL}")
    private String consumerUrl;

    public String getAge(Integer age) {
        //打印一下到底调用的是哪个
        ServiceInstance serviceInstance = this.loadBalancerClient.choose("user");
        System.out.println("===" + ":" + serviceInstance.getServiceId() + ":" + serviceInstance.getHost() +
                ":" + serviceInstance.getPort());
        System.out.print(consumerUrl);

        return restTemplate.getForObject(consumerUrl + age, String.class);
    }
}

 

2.3 getForEntity

请求参数：url为请求的地址，responseType为请求响应体,body的包装类型，urlVariables为url中的参数绑定。
getForEntity(String url, Class responseType, Object... urlVariables):
GET请求的参数绑定通常使用url中拼接的方式，
比如http://USER-SERVICE/user?name=test我们可以像这样自已将参数拼接到url中,
但更好的方法是在url中使用占位符并配合 urlVariables参数实现GET请求的参数绑定,
比如url定义为http://USER-SERVICE/user?name={1),然后可以这样来调用：
getForEntity("http://USER-SERVICE/user?name={1}", String.class, "test")'
其中第三个参数didi会替换url中的{1} 占位符。 这里需要注意的是，
由于urlVariables参数是一个数组,所以它的顺序会对应url中占位符定义的数字顺序。

getForEntity(String url, Class responseType, Map urlVariables):
该方法提供的参数中， 只有urlVariables 的参数类型与上面的方法不同。
这里使用了Map类型， 所以使用该方法进行参数绑定时需要在占位符中指定Map中参数的key值，
比如url定义为http://USER-SERVICE/user?name={name),在Map类型urlVariables中，
我们就需要put一个key为name的参数来绑定url中{name}占位符的值， 比如：
 

  RestTemplate restTemplate = new RestTemplate();
        Map<String, String> params = new HashMap<>();
        params.put("name", "dada");
        ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://USERSERVICE/user?name={name}", String.class, params);

getForEntity(URI url, Class responseType):
该方法使用URI对象来替代之前的url和urlVariables参数来指定访问地址和参数绑定。
URI是JDK java.net包下的一个类，它表示一个统一资源标识符(Uniform Resource Identifer)引用。 比如下面的例子：


2.4 getForObject

getForObject函数。该方法可以理解为对getForEntity的进一步封装，
它通过HttpMessageConverterExtractor对HTTP的请求响应体body内容进行对象转换， 实现请求直接返回包装好的对象内容。比如：
RestTemplate restTemplate = new RestTemplate();
String result =restTemplate.getForObject(uri, String.class);
当body是一个User对象时， 可以直接这样实现：
RestTemplate restTemplate=new RestTemplate();
User result = restTemplate.getForObject(uri, User.class);
当不需要关注请求响应除 body 外的其他内容时， 该函数就非常好用， 可以少一个从Response中获取body的步骤。 它与getForEnEtity函数类似， 也提供了三种不同的重载实现。

请求参数：url参数指定访问的地址，responseType参数
 getForObject (String url, Class responseType, Object... urlVariables):
与 getForEntity的方法类似，url参数指定访问的地址，responseType参数
定义该方法的返回类型， urlVariables 参数为url中占位符对应的参数。

getForObject(String url, Class responseType, Map urlVariables):
在该函数中，使用 Map 类型的urlVariables替代上面数组形式的urlVariables,
因此使用时在url中需要将占位符的名称与Map类型中的key一对应设置。

getForObject(URI url, Class responseType):
该方法使用URI对象来替代之前的 url和urlVariables参数使用。

2.5 POST请求

在RestTemplate中， 对POST 请求时可以通过如下三个方法进行调用实现。
第一种：postForEntity函数。
该方法同 GET请求中的getForEntity类似， 会在调用后返回ResponseEntity<T>对象， 其中T为请求响应的body类型。 比如下面这个例子， 使用postForEntity提交POST请求到USER-SERVICE服务的/user接口，提交的body内容为user对象， 请求响应返回的body类型为Sting。
 

RestTemplate restTemplate = new RestTemplate();
User user = new User("didi", 30);
ResponseEntity<String> responseEntity=restTemplate.postForEntity("http://USER-SERVICE/user", user, String.class);
String body = responseEntity.getBody();

postForEnEtity 函数也实现了三种不同的重载方法。
• postForEntity(String url, Object request, Class responseType,Object... uriVariables)
• postForEntity(String url, Object request, Class responseType,Map uriVariables)
• postForEntity(URI url, Object request， Class responseType)

这些函数中的参数用法大部分与 getForEntity一致， 比如， 第一个重载函数和第二个重 载 函 数中的 uriVariables 参 数都用 来对 url 中的参 数进行绑定使用；
responseType参数是对请求响应的body内容的类型定义。 这里需要注意的是新增加的request参数， 该参数可以是一个普通对象， 也可以是一个HttpEntity对象。 如果是一个普通对象， 而非HttpEntity对象的时候， RestTemplate会将请求对象转换为一
个HttpEnEtity对象来处理， 其中Object就是 request的类型， request内容会被视作完整的body来处理；而如果 request是一个HttpEnEtity对象， 那么就会被当作一个完成的HTTP请求对象来处理， 这个 request中不仅包含了body的内容， 也包含了header的内容。

第二种： postForObject 函数。 该方法也跟getForObject的类型类似， 它的作用是简化postForEntity的后续处理。 通过直接将请求响应的body内容包装成对象来返回使用， 比如下面的例子：
RestTemplate restTemplate=new RestTemplate();
User user = new User("didi", 20);
String postResult = restTemplate.postForObject("ht七p: //USER-SERVICE/user", user,String.class);
postForObject函数也实现了三种 不同的重载方法：
• postForObject(String url, Object request, Class responseType,Object... uriVariables)
• postForObject(String url, Object request, Class responseType,Map uriVariables)
• postForObject(URI url, Object reques七， Class responseType)
这三个函数除了返回的对象类型不同， 函数的传入参数均与postForEntity一致，
因此可参考之前postForEnEtity的说明。

第三种： postForLocation函数。 该方法实现了以POST请求提交资源， 并返回新
资源的URI, 比如下面的例子：
User user = new User("didi", 40);
URI responseURI = restTemplate.postForLocation("http://USER-SERVICE/user", user);
postForLocation函数也实现了三种不同的重载方法：
• postForLocation(Stringurl, Object request, Object...urlVariables)
• postForLocation(String url, Object request,Map urlVariables)
• postForLocation(URI url, Object request)
由于postForLocation 函数会返回新资源的URI, 该UR就相当于指定了返回类型，所以此方法实现的POST请求不需要像postForEntity和postForObject那样指定responseType。 其他的参数用法 相同。

 

2.6 消费者controller

package com.alen.controller;

import com.alen.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @create 2017-11-27 17:32
 **/
@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    /**
     * 服务调用 消费者
     * @param age
     * @return
     */
    @RequestMapping("/getage")
    public String getConsumer(@RequestParam Integer age) {
        return helloService.getAge(age);
    }
}

 

配置文件application.yml

server:
  port: 8213

eureka:
  instance:
    hostname: localhost
    # 发呆时间，即服务失效时间（缺省为90s）,就是超过15秒没有续约就会从注册表中剔除
    lease-expiration-duration-in-seconds: 15
    # 心跳时间，即服务续约间隔时间（缺省为30s）
    lease-renewal-interval-in-seconds: 5
  client:
   #设置eureka服务器所在的地址，查询服务和注册服务都需要依赖这个地址。高可用的注册中心时，
    #可以配置多个注册中心，通过逗号隔开
    service-url:
     defaultZone: http://localhost:8010/eureka/

spring:
  application:
  #这在以后的服务与服务之间相互调用一般都是根据这个name
    name: ribbon-service

consumerURL: http://USER/hello?age=

 

pom.xml

<?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>spring-cloud</artifactId>
        <groupId>com.alen</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <artifactId>ribbon-service</artifactId>

    <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--spring-cloud-starter-eureka已经引了，所以可引可不引-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

 

 

3.ribbon

Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随即连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

Ribbon提供的主要负载均衡策略介绍

简单轮询负载均衡（RoundRobin）

以轮询的方式依次将请求调度不同的服务器，即每次调度执行i = (i + 1) mod n，并选出第i台服务器。

随机负载均衡 （Random）

随机选择状态为UP的Server

加权响应时间负载均衡 （WeightedResponseTime）

区域感知轮询负载均衡（ZoneAware）

区域感知负载均衡内置电路跳闸逻辑，可被配置基于区域同源关系（Zone Affinity，也就是更倾向于选择发出调用的服务所在的托管区域内，这样可以降低延迟，节省成本）选择目标服务实例。它监控每个区域中运行实例的行 为，而且能够实时的快速丢弃一整个区域。这样在面对整个区域故障时，帮我们提升了弹性。

Ribbon自带负载均衡策略比较

策略名

策略声明

策略描述

实现说明

BestAvailableRule

public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule

选择一个最小的并发请求的server

逐个考察Server，如果Server被tripped了，则忽略，在选择其中ActiveRequestsCount最小的server

AvailabilityFilteringRule

public class AvailabilityFilteringRule extends PredicateBasedRule

过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）

使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个server的运行状态

WeightedResponseTimeRule

public class WeightedResponseTimeRule extends RoundRobinRule

根据相应时间分配一个weight，相应时间越长，weight越小，被选中的可能性越低。

一 个后台线程定期的从status里面读取评价响应时间，为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行，没有形成statas时，使用roubine策略选择 server。

RetryRule

public class RetryRule extends AbstractLoadBalancerRule

对选定的负载均衡策略机上重试机制。

在一个配置时间段内当选择server不成功，则一直尝试使用subRule的方式选择一个可用的server

RoundRobinRule

public class RoundRobinRule extends AbstractLoadBalancerRule

roundRobin方式轮询选择server

该策略实现了按照线性轮询的方式依次选择每个服务实例的功能。

RandomRule

public class RandomRule extends AbstractLoadBalancerRule

随机选择一个server

该策略实现了从服务实例清单中随机选择一个服务实例的功能。

ZoneAvoidanceRule

public class ZoneAvoidanceRule extends PredicateBasedRule

复合判断server所在区域的性能和server的可用性选择server

使 用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server，前一个判断判定一个 zone的运行性能是否可用，剔除不可用的zone（的所有server），AvailabilityPredicate用于过滤掉连接数过多的 Server。

配置properties file (sample-client.properties)

# Max number of retries   
ribbon.MaxAutoRetries=1  
  
# Max number of next servers to retry (excluding the first server) 
ribbon.MaxAutoRetriesNextServer=1 

 # Whether all operations can be retried for this client  
ribbon.OkToRetryOnAllOperations=true  

# Interval to refresh the server list from the source  
ribbon.ServerListRefreshInterval=2000   

# Connect timeout used by Apache HttpClient  
ribbon.ConnectTimeout=3000   

# Read timeout used by Apache HttpClient  
ribbon.ReadTimeout=3000  

# Initial list of servers, can be changed via Archaius dynamic property at runtime  
ribbon.listOfServers=testserver1:80,testserver2 :80,testserver3:80   
ribbon.EnablePrimeConnections=true

4.自定义Ribbon客户端

自定义Ribbon客户端有两种方式：通过配置类或配置文件

您可以使用<client>.ribbon.*中的外部属性来配置Ribbon客户端的某些属性，这与使用Netflix API本身没有什么不同，只能使用Spring Boot配置文件。本机选项可以在CommonClientConfigKey（功能区内核心部分）中作为静态字段进行检查。

Spring Cloud还允许您通过使用@RibbonClient声明其他配置（位于RibbonClientConfiguration之上）来完全控制客户端。例：

@Configuration
@RibbonClient(name = "foo", configuration = FooConfiguration.class)
public class TestConfiguration {
}

在这种情况下，客户端由RibbonClientConfiguration中已经存在的组件与FooConfiguration中的任何组件组成（后者通常会覆盖前者）。

警告

FooConfiguration必须是@Configuration，但请注意，它不在主应用程序上下文的@ComponentScan中，否则将由所有@RibbonClients共享。如果您使用@ComponentScan（或@SpringBootApplication），则需要采取措施避免包含（例如将其放在一个单独的，不重叠的包中，或者指定要在@ComponentScan）。

4.1通过配置类来实现ribbion自动化配置

由于Ribbon中定义的每 一个接口都有多种不同的策略实现，同时这些接口之间又有 一定的 依赖关系，这使得第 一次使用rbbion的开发者很难上手，不知道如何选择具体的实现策略以及如何组织它们 的关系。 Spring Cloud ribbon中的自动化配置恰恰 能够解决这样的痛点，在引入Spring Cloud Ribbon的 依赖之后， 就能够自动化构建下面这些接口的实现。

com.netflix.client.config.IClientConfig：Ribbon的客户端配置，默认采用com.netflix.client.config.DefaultClientConfigImpl实现。
com.netflix.loadbalancer.IRule：Ribbon的负载均衡策略，默认采用com.netflix.loadbalancer.ZoneAvoidanceRule实现，该策略能够在多区域环境下选出最佳区域的实例进行访问。
com.netflix.loadbalancer.IPing：Ribbon的实例检查策略，默认采用com.netflix.loadbalancer.NoOpPing实现，该检查策略是一个特殊的实现，实际上它并不会检查实例是否可用，而是始终返回true，默认认为所有服务实例都是可用的。
com.netflix.loadbalancer.ServerList：

服务实例清单的维护机制，默认采用com.netflix.loadbalancer.ConfigurationBasedServerList实现。
com.netflix.loadbalancer.ServerListFilter：

服务实例清单过滤机制，默认采org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter，该策略能够优先过滤出与请求方处于同区域的服务实例。
com.netflix.loadbalancer.ILoadBalancer：负载均衡器，默认采用com.netflix.loadbalancer.ZoneAwareLoadBalancer实现，它具备了区域感知的能力。

 

1.为了指定服务采用新定的规则，需要在启动类同级目录下添加类“ExcludeComponentScan.java”:

public @interface ExcludeFromComponentScan {

}

2..创建一个类型的bean并将其放置在@RibbonClient配置允许您覆盖所描述的每个bean

@Configuration
@ExcludeFromComponentScan
//使用@RibbonClient注解来实现更细粒度的客户端配置， 比如下
// 面的代码实现了为ribbon-service-provider服务使用MyLoadBalanceConfig中的配 置。
@RibbonClient(name = "ribbon-service-provider", configuration = MyLoadBalanceConfig.class)
public class MyLoadBalanceConfig {

    @Bean
    public IRule ribbonRule() { // 其中IRule就是所有规则的标准
        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略
    }
}

3.启动类

@SpringBootApplication
//通过注解@EnableEurekaClient 表明自己是一个eurekaclient.
@EnableEurekaClient
//@Configuration这个注解是不能@SpringBootApplication的所在扫描到的，
//否则将自定义的配置将失效。所以需要将MyLoadBalanceConfig.java排除在包扫描之外，
//用自定义的注解@ExcludeFromComponentScan，
//然后在启动类加注解
//@ComponentScan(excludeFilters{@ComponentScan.Filter(type=FilterType.ANNOTATION,
//    value=ExcludeFromComponentScan.class)})将其排除。
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {ExcludeFromComponentScan.class})})
public class RibbonServiceApplication {

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

   /**
    * 向程序的ioc注入一个bean: restTemplate;
    * 并通过@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。
    */
   @Bean
   @LoadBalanced
    public     RestTemplate restTemplate() {
      return new RestTemplate();
   }
}

MyLoadBalanceConfig 必须是@Configuration，但请注意，它不在主应用程序上下文的@ComponentScan中，否则将由所有@RibbonClients共享。如果您使用@ComponentScan（或@SpringBootApplication），则需要采取措施避免包含（例如将其放在一个单独的，不重叠的包中，或者指定要在@ComponentScan）。

参考：http://blog.csdn.net/shunhua19881987/article/details/75466797

4.2使用属性自定义Ribbon客户端

从版本1.2.0开始，Spring Cloud Netflix现在支持使用属性与Ribbon文档兼容来自定义Ribbon客户端。

这允许您在不同环境中更改启动时的行为。

支持的属性如下所示，应以<clientName>.ribbon.为前缀：

  • NFLoadBalancerClassName：应实施ILoadBalancer

  • NFLoadBalancerRuleClassName：应实施IRule

  • NFLoadBalancerPingClassName：应实施IPing

  • NIWSServerListClassName：应实施ServerList

  • NIWSServerListFilterClassName应实施ServerListFilter

注意

在这些属性中定义的类优先于使用@RibbonClient(configuration=MyRibbonConfig.class)定义的bean和由Spring Cloud Netflix提供的默认值。

要设置服务名称users的IRule，您可以设置以下内容：

application.yml

users:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule

测试代码：

package com.alen.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

/**
 * 测试调用
 *
 * @create 2017-11-27 17:14
 **/
@Service
public class HelloService {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    RestTemplate restTemplate;
    @Value("${eurekaclientURL}")
    private String eurekaclientURL;
    @Value("${ribbonserviceproviderURL}")
    private String ribbonserviceproviderURL;

    public String getAge(Integer age) {
        //打印一下到底调用的是哪个
        ServiceInstance serviceInstance = this.loadBalancerClient.choose("eureka-client");
        System.out.println("===" + ":" + serviceInstance.getServiceId() + ":" + serviceInstance.getHost() + ":" + serviceInstance.getPort());
        ServiceInstance serviceInstance2 = this.loadBalancerClient.choose("ribbon-service-provider");
        System.out.println("===" + ":" + serviceInstance2.getServiceId() + ":" + serviceInstance2.getHost() + ":" + serviceInstance2.getPort());
        restTemplate.getForObject(ribbonserviceproviderURL + age, String.class);
        return restTemplate.getForObject(eurekaclientURL + age, String.class);
    }
}

 

#端口
server.port=8083
eureka.instance.hostname=localhost
#设置eureka服务器所在的地址，查询服务和注册服务都需要依赖这个地址。
eureka.client.serviceUrl.defaultZone=http\://localhost\:8081/eureka/
#这在以后的服务与服务之间相互调用一般都是根据这个name
spring.application.name=ribbon-service
#eureka.client.register-with-eureka=true
#eureka.client.fetch-registry=true
# 心跳时间，即服务续约间隔时间（缺省为30s）
eureka.instance.lease-renewal-interval-in-seconds= 5
# 发呆时间，即服务续约到期时间（缺省为90s）
eureka.instance.lease-expiration-duration-in-seconds=15     

eurekaclientURL=http://EUREKA-CLIENT/hello?age=
ribbonserviceproviderURL=http://ribbon-service-provider/hello?age=
#consumerURL=http://localhost:8087/hello?age=

#设置ribbon-service-provider服务为随机轮循
ribbon-service-provider.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
#设置eureka-client服务轮询策略  ，轮询index，选择index对应位置的server
eureka-client.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RoundRobinRule

 

所有的服务名字一定要保持致，如果不则会认为是两个无法进行负载均衡。可以启动消费者去调用就能实现负载均衡。

结果

===:eureka-client:localhost:8073
===:ribbon-service-provider:localhost:8065
===:eureka-client:localhost:8073
===:ribbon-service-provider:localhost:8065
===:eureka-client:localhost:8082
===:ribbon-service-provider:localhost:8084
===:eureka-client:localhost:8072
===:ribbon-service-provider:localhost:8084

参考：https://springcloud.cc/spring-cloud-dalston.html#ribbon-child-context-eager-load

https://yq.aliyun.com/articles/61823

Spring Cloud（08）——客户端负载工具Ribbon
Elim的博客
08-28 1272
客户端负载工具Ribbon Ribbon是Netflix公司提供的一个客户端负载工具，Spring Cloud也对其进行了集成支持。使用Ribbon需要在pom.xml中添加如下依赖。 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>sprin...
Spring Cloud Finchley.SR1-Spring Cloud 手册-Spring Cloud 文档
09-28
Spring Cloud Finchley.SR1-Spring Cloud 手册-Spring Cloud 文档，Spring Cloud 2.x手册-Spring Cloud 2.x 文档
SpringCloud(三)Ribbon负载均衡
zzzzzz55300411的博客
01-09 6461
上篇文章我们成功的将providr和consumer注册到eureka上面了。但是有两个问题： 1、 consumer通过rest请求provider的时候，url是硬编码return this.restTemplate.getForEntity("http://localhost:8001/simple/" + id, User.class).getBody(); 2、 provide
SpringCloud第三章：客户端负载均衡与服务调用
最新发布
kelai_6792的博客
10-16 943
自定义策略我们只需要自己创建一个ReactorServiceInstanceLoadBalancer接口的实现类，实现choose方法即可，具体实现的算法需要根据具体需求来确定，一般默认就够了，所以这里就不演示实现算法了，因为实现方式已经知道了，具体实现就不操作了最后编辑于：2024-10-01 17:47:32©著作权归作者所有,转载或内容合作请联系作者。
SpringCloud 负载均衡
Mwt258的博客
07-21 1150
负责均衡 (Load Balance，简称LB)，是高并发、高可用系统必不可少的关键组件。 当服务流量增大时，通常会采用增加机器的方式来进行扩容，负载均衡就是用来在多个机器或者其它资源中按照一定的规则合理分配负载
Spring Cloud 负载均衡
bm1998
09-16 856
文章目录1. Ribbon 客户端负载均衡1.1 Ribbon 概述1.2 Ribbon 远程调用1.3 Ribbon 负载均衡1.4 Ribbon 负载均衡策略 1. Ribbon 客户端负载均衡 1.1 Ribbon 概述 Ribbon 是 Netflix 提供的一个基于 HTTP 和 TCP 的客户端负载均衡工具。 Ribbon主要有两个功能： 简化远程调用 负载均衡 客户端负载均衡和服务端负载均衡的区别 服务端负载均衡 负载均衡算法在服务端 由负载均衡器维护服务地址列表 客户端负
Spring全家桶——SpringCloud之Feign(Finchley版)
Java知音
02-28 811
Feign是一个声明式的Web服务客户端。 是什么？ 例如我在一个服务的interace上注解@FeignClient(value = “eureka-client”） 就是声明服务名称 告诉其他服务等这个就是eureka-client 的服务客户端 它使编写Web服务客户端变得更容易 要使用Feign，请创建接口并注解,有可插入的注解支持，包括Feign注释和JAX-RS注释。 JAX-R...
四：Spring Cloud 之服务发现与调用-Ribbon
Oscar Chen
09-15 1733
Spring Cloud中Ribbon的入门使用。
SpringCloud升级到Finchley的一些坑
芸灵fly的博客
09-11 3658
说明 最近开始使用SpringCloud的Finchley版本，从中踩了一些坑，这里记录一下SpringCloud组件在高版本下的一些变化 快速开始 引入spring-cloud Finchley.SR1 &lt;properties&gt; &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.s...
SpringCloud之服务提供与调用(Ribbon,Feign)
javarrr的博客
03-14 726
本系列介绍的配置均基于 Spring Boot 2.0.1.RELEASE 版本和 Spring Cloud Finchley.SR1 eureka注册续约流程 启动注册中心 服务提供者生产服务并注册到服务中心中 消费者从服务中心中获取服务并执行 服务提供 1.在spring-cloud-manage下创建一个子项目producer-service p...
SpringCloud——负载均衡
日积月累，天道酬勤
11-22 551
负载均衡 客户端负载均衡 优势： 稳定性高 缺点： 升级成本高 服务端负载均衡 优势: 统一维护，成本低 缺点: 一旦出现故障，影响非常大 调度算法 先来先服务 最早截止时间优先 最短保留时间优先 固定优先级 轮询 多级别队列 负载均衡需要具备的特性 非对称负载 ： 负载不一定均衡 分布式拒绝服务攻击保护 直接服务返回 健康检查：检查服务提供方和调用方以及自己的健康程度 优先级队列 N...
SpringCloud-Eureka 服务注册与发现，搭建 服务端和客户端
小哇
03-09 375
注册中心服务端搭建1 新建springboot项目，添加 Spring-cloud-Discovery》》》》》》》Eureka Server依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring...
springcloud负载均衡
qq_36022463的博客
10-03 179
LoadBalance服务调用 创建两个provider01 和 provider02 ，， spring.application.name 配置相同名字 spring: application: name: UserProvider server: port: 3000 eureka: client: service-url: defaultZone: http://localhost:1111/eureka,http://localhost:1112/eurek
【SpringCloud】负载均衡
低调做人，低调编码，神码都是浮云
05-27 2080
SpringCloud负载均衡：Ribbon
springcloud之负载均衡
学海无涯,我用JAVA
07-14 1612
在springcloud中,服务端实现负载均衡,我所知道的是通过ribbon实现的而通过ribbon实现的负载均衡目前在用的比较多的是feign和 restTemplate两种feign:已经集成了ribbon,默认是轮训算法,当然也可以通过配置更改loadbalacned算法restTemplete:需要配置集成ribbon方法如下(在启动类中加入)@Bean@LoadBalanced...
微服务(Spring Cloud)——负载均衡
qq_42282792的博客
03-19 6936
一、概述 负载均衡 组件库: Spring Cloud Netflix 组件库 组件： Ribbon 二、负载均衡介绍 （一）、什么是负载均衡 负载均衡建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。 负载均衡（Load Balance）其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。—— 百度百科 （二）、微服务中客户端负载均
Spring Cloud 实现负载均衡
myNameisdxy的博客
04-01 593
Spring Cloud 实现负载均衡 1.搭建一个springcloud服务端和客户端 服务端： 客户端： 2.配置多个服务端，设置不同的端口启动 spring: application: name: registry server: port: 8762 eureka: client: service-url: defaultZone: http://...
SpringCloud-Finchley.SR1-Eureka学习（Hello World）
笑笑是一个码农
03-31 491
一、源码地址 https://github.com/devilyang123/spring-cloud-learn 二、创建spring-cloud-parent父工程，目录结构如下 父工程会包含三个模块，分别为eureka-server，cloud-producer(生产者)，cloud-consumer(消费者)。 父工程的pom文件如下 <?xml version="1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值