SpringCloud 学习(5)：第一个Ribbon程序

红太狼 2020-11-15 15:33 788阅读 0赞

## 一、简介 ##

Ribbon是netflix公司的一个负载均衡框架，负载均衡就是分发请求，缓解单台服务器压力。

## 二、Ribbon hello world ##

这篇文章主要通过写一个简单Ribbon程序，来了解一下Ribbon的原理。  
第一个Ribbon程序包括以下内容：

*  2个简单的服务，端口分别为1001和1002
 *  1个client程序用来向服务器发送请求，测试负载均衡的效果

**1.首先，新建项目Ribbon-service**  
pom.xml

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

**2.配置文件（这一步是为了启动两个不同端口的服务）**  
application.properties

spring.profiles.active=dev
    
    #spring.profiles.active=pro

application-dev.properties:

server.port=1001

application-pro.properties:

server.port=1002

**3.服务实现(这里返回RequestURL是为了区分请求的服务器)**：RibbonServiceControl.java

import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    
    @RestController
    public class RibbonServiceControl {
    
        @RequestMapping("hello")
        public String helloWorld(HttpServletRequest request){
              return "Hello World Ribbon--"+request.getRequestURL();
        }
    }

**4.最后是sprongBoot启动程序**：Application.java

import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.builder.SpringApplicationBuilder;
    
    @SpringBootApplication
    public class Application { 
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(true).run(args);
        }
    }

**5.新建项目**：Ribbon-client  
直接写一个测试类：

import com.netflix.client.ClientFactory;
    import com.netflix.client.http.HttpRequest;
    import com.netflix.client.http.HttpResponse;
    import com.netflix.config.ConfigurationManager;
    import com.netflix.loadbalancer.AvailabilityFilteringRule;
    import com.netflix.niws.client.http.RestClient;
    
    
    public class test {
    
        public static void main(String[] args) throws Exception {
            ConfigurationManager.getConfigInstance().setProperty(
                    "my-client.ribbon.listOfServers", "localhost:1001,localhost:1002"); //设置服务列表
            RestClient client = (RestClient) ClientFactory.getNamedClient("my-client");
            HttpRequest request = HttpRequest.newBuilder().uri("/hello").build();
            for(int i = 0; i < 10; i++) { 
                HttpResponse response = client.executeWithLoadBalancer(request);
                String json = response.getEntity(String.class);
                System.out.println(json);
            }
        };
    }

**6.最后，先启动2个服务，再执行测试类，可以看到如下效果，说明默认的负载均衡规则就是轮询。**  
![这里写图片描述][70]

**7.当然，我们也可以修改负载均衡的规则**  
可选的策略如下：

| 策略类型                  | 描述                                                         |
| ------------------------- | ------------------------------------------------------------ |
| RoundRobinRule            | 这条规则简单地通过循环法选择服务器。它通常用作默认规则       |
| BestAvailableRule         | 选择一个最小的并发请求的server                               |
| AvailabilityFilteringRule | 过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值） |
| WeightedResponseTimeRule  | 根据响应时间分配一个weight，响应时间越长，weight越小，被选中的可能性越低。 |
| RetryRule                 | 对选定的负载均衡策略机上重试机制。                           |
| RandomRule                | 随机选择一个server                                           |
| ZoneAvoidanceRule         | 复合判断server所在区域的性能和server的可用性选择server       |

那么，我们如何修改策略呢？  
只需要修改5的测试代码即可：

import com.netflix.client.ClientFactory;
    import com.netflix.client.http.HttpRequest;
    import com.netflix.client.http.HttpResponse;
    import com.netflix.config.ConfigurationManager;
    import com.netflix.loadbalancer.AvailabilityFilteringRule;
    import com.netflix.niws.client.http.RestClient;
    
    public class test {
    
        public static void main(String[] args) throws Exception {
            ConfigurationManager.getConfigInstance().setProperty(
                    "my-client.ribbon.listOfServers", "localhost:1001,localhost:1002"); //设置服务列表
            ConfigurationManager.getConfigInstance().setProperty(
                    "my-client.ribbon.NFLoadBalancerRuleClassName", AvailabilityFilteringRule.class.getName()); //设置负载均衡规则
    
            RestClient client = (RestClient) ClientFactory.getNamedClient("my-client");
            HttpRequest request = HttpRequest.newBuilder().uri("/hello").build();
            for(int i = 0; i < 10; i++) { 
                HttpResponse response = client.executeWithLoadBalancer(request);
                String json = response.getEntity(String.class);
                System.out.println(json);
            }
        };
    }

**8.当然，我们也可以自定义负载均衡规则，只需要实现IRule 接口即可：**

import java.util.Random;
    
    import com.netflix.loadbalancer.ILoadBalancer;
    import com.netflix.loadbalancer.IRule;
    import com.netflix.loadbalancer.Server;
    
    public class Myrule implements IRule { 
    
        private ILoadBalancer lb;
    
        public Server choose(Object key) { //自定义规则
            Random rm = new Random();
            int number = rm.nextInt(10);
            if(number < 2) {
                return lb.getAllServers().get(0);
            }else {
                return lb.getAllServers().get(1);
            }
        }
    
        public void setLoadBalancer(ILoadBalancer lb) {
            this.lb=lb;
    
        }
    
        public ILoadBalancer getLoadBalancer() {
            // TODO Auto-generated method stub
            return this.lb;
        }
    
    }

然后测试类修改如下：

import com.netflix.client.ClientFactory;
    import com.netflix.client.http.HttpRequest;
    import com.netflix.client.http.HttpResponse;
    import com.netflix.config.ConfigurationManager;
    import com.netflix.loadbalancer.AvailabilityFilteringRule;
    import com.netflix.niws.client.http.RestClient;
    
    /** * @author: * @description: * @program: ribbon_service * @create: 2018-06-22 11:39 **/
    public class test {
    
        public static void main(String[] args) throws Exception {
            ConfigurationManager.getConfigInstance().setProperty(
                    "my-client.ribbon.listOfServers", "localhost:1001,localhost:1002"); //设置服务列表
            ConfigurationManager.getConfigInstance().setProperty(
                    "my-client.ribbon.NFLoadBalancerRuleClassName", Myrule.class.getName()); //自定义负载均衡规则
    
            RestClient client = (RestClient) ClientFactory.getNamedClient("my-client");
            HttpRequest request = HttpRequest.newBuilder().uri("/hello").build();
            for(int i = 0; i < 10; i++) { 
                HttpResponse response = client.executeWithLoadBalancer(request);
                String json = response.getEntity(String.class);
                System.out.println(json);
            }
        };
    }

[70]: /images/1605454370311.png