Spring Cloud Ribbon负载均衡

时间 2019-12-10

标签 spring cloud ribbon 负载均衡栏目 Spring 繁體版

原文原文链接

目录java

1、简介

Spring Cloud Ribbon是一个基于HTTP 和 TCP的客户端负载工具，它基于Netflix Ribbon实现，咱们可使用它来进行远程服务负载均衡的调用。它不像Zuul 和 Eureka 等能够独立部署，它虽然是一个工具类框架，可是几乎全部的Spring Cloud微服务架构和基础设施都离不开它，包括后面所介绍的Feign 远程调用，也是基于Ribbon实现的工具算法

2、客户端负载均衡

负载均衡是在一个架构中很是重要，并且不得不去实施的内容。由于负载均衡对系统的高可用，网络压力的缓解和处理能力扩容的重要手段之一。一般负载均衡分为两种：硬件负载均衡 和 软件负载均衡，硬件负载均衡通常是经过硬件来实现，在服务器节点之间安装特定的负载均衡设备，好比F5。而软件负载均衡是采用软件控制的手段实现的，它实在服务器之间安装某种特定功能的软件来完成特定的请求分开工做，好比Nginx等。不管硬件负载仍是软件负载，只要是服务端负载均衡都能如下图的架构方式构建起来：spring

硬件负载均衡的设备和软件负载均衡的模块都会维护一个下挂可用的服务清单，经过心跳检测来剔除故障的服务节点以保证清单中都是能够访问的服务端节点。当客户发送请求到负载均衡的设备时。设备按照服务负载均衡的算法(随机访问，轮询访问，权重访问，最少访问次数算法)来找到对应的服务端。服务器

而客户端负载均衡和服务端负载均衡最大的不一样点在于上面所提到服务清单的存储位置。在客户端负载均衡中，全部客户端节点都维护着本身要访问的服务清单，而这些服务清单都来自注册中心，好比咱们上一章介绍的Eureka服务端。网络

经过Spring Cloud Ribbon的封装，咱们在微服务架构中使用负载均衡就比较简单，只须要下面两步：架构

服务提供者只须要启动多个服务实例并注册到一个注册中心或是多个相关联的服务注册中心
服务消费者直接调用被@LoadBalanced注解修饰过的RestTemplate来实现面向服务的接口调用。

3、RestTemplate详解

在上一章中，咱们已经引入了Spring Cloud Ribbon实现了客户端负载均衡的一个简单的实例，其中，咱们使用了一个很是有用的对象RestTemplate。该对象会使用Ribbon的自动化配置，同时经过配置@LoadBalanced开启客户端负载均衡。下面咱们将详细介绍RestTemplate 针对几种不一样的请求类型和参数类型的服务调用实现。app

准备工做负载均衡

在上一篇博客中，咱们搭建了一个注册中心，一个服务提供者，一个ribbon消费者客户端，如今咱们也须要这三个组件来作Ribbon 服务消费框架

GET请求

在RestTemplate中，对GET请求能够经过以下两个方法进行调用实现。ide

第一种：getForEntity()函数，该方法返回的是ResponseEntity，该对象是Spring对HTTP请求响应的封装，其中主要存储了HTTP的几个重要元素，好比HTTP请求状态码的枚举对象HttpStatus(经常使用的404，500这些错误)，在它的父类HttpEntity中还存储着HTTP请求的头信息对象HttpHeaders以及泛型类型集合的请求体对象。

它的通常形式有三种：

/*
* url是远程服务端的路径，responseType是返回值类型，urlVariables是可变参数，给服务端传递的参数
*/
getForEntity(String url, Class<T> responseType, Object... urlVariables)
  
/*
* 可使用Map封装参数传递给客户端
*/
getForEntity(String url, Class<T> responseType, Map<String, ?> urlVariables)
  
/*
* 也是一直接使用uri地址
*/
getForEntity(URI url, Class<T> responseType) throws RestClientException

/*
* getForObject 用法和getForEntity基本相同
*/
getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException

getForObject(String url, Class<T> responseType, Map<String, ?> urlVariables) throws RestClientException

getForObject(URI url, Class<T> responseType) throws RestClientException

URI 和 URL 的关系：

URI : 统一资源标志符:

URL: 统一资源定位符****

URN : 统一资源名称****

三者之间的关系：

通常用法

getForEntity

Ribbon 消费者

/**
     * 文章基于spring-boot-starter-parent 1.3.7 版本
     * 若是读者使用1.5.9 以上的版本，能够用GetMapping
     * @return
     */
    @RequestMapping(value = "/ribbon-consumer1", method = RequestMethod.GET)
    public ResponseEntity<String> helloUser(){
      // 返回值是String类型，因此对应第一个逗号后面的类型
      // /user/{1} 中的{1}表示的是第一个参数，传的值是didi
      // 也能够用getForEntity().getBody() 方法，此时返回值就只是一个String类型
        return restTemplate.getForEntity("http://server-provider/user/{1}",String.class,"didi");
    }

        
    @RequestMapping(value = "/ribbon-consumer2", method = RequestMethod.GET)
    public ResponseEntity<User> helloUser2(){
        // 返回值是一个User类型
        // 多个参数之间用& 隔开
        return restTemplate.getForEntity("http://server-provider/user2?id=001&name=didi",User.class);
    }

        // 传递一个Map类型的对象
    @RequestMapping(value = "/ribbon-consumer3", method = RequestMethod.GET)
    public ResponseEntity<String> helloUser3(){
        Map params = new HashMap();
        params.put("name","data");
        // {name}表示的是params中的key
        return restTemplate.getForEntity("http://server-provider/user3?name={name}", String.class,params);
    }

        // 其实最核心的就是经过uri进行调用，上面全部的写法都会转换为下面这种写法
        // 也就是说下面这种写法是最根本的。
    @RequestMapping(value = "/ribbon-consumer4", method = RequestMethod.GET)
    public ResponseEntity<String> helloUser4(){
        UriComponents uriComponents = UriComponentsBuilder.fromUriString(
                "http://server-provider/user4?name={name}")
                .build()
                .expand("lx")
                .encode();
        URI uri = uriComponents.toUri();
        return restTemplate.getForEntity(uri,String.class);
    }

User 对象

public class User {

    private Integer id;
    private String name;

    public User(){}
    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
        get and set...
}

服务提供者

来看一下服务提供者的代码：

// 返回的类型是String
    @RequestMapping(value = "/user/{name}", method = RequestMethod.GET)
    public String helloUser(@PathVariable("name") String name){
        return "Hello " + name;
    }

    // 返回的类型是User
    @RequestMapping(value = "/user2", method = RequestMethod.GET)
    public User helloUser(User user){
        return user;
    }

    @RequestMapping(value = "/user3", method = RequestMethod.GET)
    public String helloUser1(@RequestParam("name") String name){
        return "Hello " + name;
    }

    @RequestMapping(value = "/user4", method = RequestMethod.GET)
    public String helloUser2(@RequestParam("name") String name){
        return "Hello " + name;
    }

getForObject()

Ribbon 消费者

@RequestMapping(value = "/ribbonGet", method = RequestMethod.GET)
    public String ribbonGet(){
        // {1} 和 {2} 都是占位符，分别表明着 001 和 lx的值 
        return restTemplate.getForObject("http://server-provider/ribbon?id={1}&name={2}",String.class,
                new Object[]{"001","lx"});
    }

        // 和上面用法基本相同
    @RequestMapping(value = "/ribbonGet2", method = RequestMethod.GET)
    public String ribbonGet2(){
        Map params = new HashMap();
        params.put("id","001");
        params.put("name","lx");
        return restTemplate.getForObject("http://server-provider/ribbon?id={id}&name={name}",String.class,
                params);
    }

    @RequestMapping(value = "/ribbonGet3", method = RequestMethod.GET)
    public String ribbonGet3(){
        UriComponents uriComponents = UriComponentsBuilder.fromUriString(
                "http://server-provider/ribbon?id={id}&name={name}")
                .build()
                .expand("001","lx")
                .encode();
        URI uri = uriComponents.toUri();
        return restTemplate.getForObject(uri,String.class);
    }

服务提供者

// 上面全部的url共用下面一个方法
        @RequestMapping(value = "/ribbon", method = RequestMethod.GET)
    public String acceptRibbon(@RequestParam("id")String id,
                               @RequestParam("name") String name){

        System.out.println("id = " + id + "name = " + name);
        return "Hello " + id + " World " + name;
    }

POST请求

了解完GET请求后，再来看一下POST请求：

在RestTemplate中，POST请求能够用一下几种方式来实现

// postForEntity
postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables)   
postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)
postForEntity(URI url, Object request, Class<T> responseType) throws RestClientException

// postForObject
postForObject(String url, Object request, Class<T> responseType, Object... uriVariables)
postForObject(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)
postForObject(URI url, Object request, Class<T> responseType) throws RestClientException

// postForLocation
postForLocation(String url, Object request, Object... urlVariables) throws RestClientException
postForLocation(String url, Object request, Map<String, ?> urlVariables) throws RestClientException 
postForLocation(URI url, Object request) throws RestClientException

Ribbon服务端

/**
     * 文章基于spring-boot-starter-parent 1.3.7 版本
     * 若是读者使用1.5.9 以上的版本，能够用 PostMapping
     * @return
     */
    @RequestMapping(value = "/ribbonPost", method = RequestMethod.POST)
    public User ribbonPost(){
        User user = new User(001,"lx");
        return restTemplate.postForEntity("http://server-provider/rpost",user,User.class)
                .getBody();
    }

    @RequestMapping(value = "/ribbonPost2", method = RequestMethod.POST)
    public User ribbonPost2(){
        User user = new User(001,"lx");
        UriComponents uriComponents = UriComponentsBuilder.fromUriString("http://server-provider/location")
                .build()
                .expand(user)
                .encode();
        URI uri = uriComponents.toUri();
        return restTemplate.postForEntity(uri,user,User.class).getBody();
    }

    @RequestMapping(value = "/ribbonPost3", method = RequestMethod.POST)
    public String ribbonPost3(){
        User user = new User(001,"lx");
        // 占位符石str, 服务端能够用 @PathVariable获取
        return restTemplate.postForEntity("http://server-provider/rbPost/{str}",user,String.class,"hello")
                .getBody();
    }

    @RequestMapping(value = "/ribbonPost4", method = RequestMethod.POST)
    public String ribbonPost4(){
        Map<String,String> params = new HashMap<>();
        params.put("id","001");
        params.put("name","lx");
        return restTemplate.postForEntity("http://server-provider/mapPost",params,String.class).getBody();
    }

    /**
     *  restTemplate.postForObject()方法与上面用法几乎相同
     *  postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables)
     *  postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)
     *  postForEntity(URI url, Object request, Class<T> responseType)
     *  
     *. postForLocation 也类似，这里就再也不举例说明了
     */

服务提供者

@RequestMapping(value = "/rpost", method = RequestMethod.POST)
    public User accpetRibbonPost(@RequestBody User user){
        log.info("id = " + user.getId() + " name = " + user.getName());
        return user;
    }

    @RequestMapping(value = "/location", method = RequestMethod.POST)
    public User acceptRibbonPost2(@RequestBody User user){
        log.info("id = " + user.getId() + " name = " + user.getName());
        return user;
    }

    @RequestMapping(value = "/rbPost/{str}", method = RequestMethod.POST)
    public String accpetRibbonPost3(@PathVariable String str, @RequestBody User user){
        log.info("str = " + str);
        log.info("id = " + user.getId() + " name = " + user.getName());
        return str + " " + user.getId() + " " + user.getName();
    }

    @RequestMapping(value = "/mapPost", method = RequestMethod.POST)
    public String acceptRibbonPost4(@RequestBody Map map){
        String id = (String)map.get("id");
        String name = (String)map.get("name");
        return "id = " + id + " name = " + name;
    }

PUT请求

Restful中的put请求常常用来修改某些属性的值，他和POST请求类似

通常形式

/*
* 它的形式比较少，只有一种比较形式
*/
put(String url, Object request, Object... urlVariables) throws RestClientException
put(String url, Object request, Map<String, ?> urlVariables) throws RestClientException
put(URI url, Object request) throws RestClientException

Ribbon服务端

@RequestMapping(value = "/putRibbon", method = RequestMethod.PUT)
  public void putRibbon(){
    restTemplate.put("http://server-provider/ribbonPut",new User(21,"lx"));
  }

这里只采用了一种简单形式，用法和Post很类似，没有再详细说明

PUT请求没有返回值，能够理解为只把须要的值传过去就能够，修改为功不成功与我没有关系

服务提供者

@RequestMapping(value = "/ribbonPut", method = RequestMethod.PUT)
  public void acceptRibbonPut(@RequestBody User user){
    log.info("user.id = " + user.getId() + " user.name = " + user.getName());
  }

DELETE请求

delete请求在Restful API中通常用于根据id删除某条信息，用法也比较简单，没有返回值

通常形式

delete(String url, Object... urlVariables) throws RestClientException
delete(String url, Map<String, ?> urlVariables) throws RestClientException
delete(URI url) throws RestClientException

Ribbon服务端

@RequestMapping(value = "/deleteRibbon", method = RequestMethod.DELETE)
  public void deleteUser(){
    User user = new User(21,"lx");
    restTemplate.delete("http://server-provider/ribbonDelete/{1}",user.getId());
  }

服务提供者

@RequestMapping(value = "/ribbonDelete/{id}", method = RequestMethod.DELETE)
  public void deleteRibbon(@PathVariable Integer id){
    log.info("delete user " + id);
  }

参考资料：

https://www.jb51.net/article/138563.htm#comments

《Spring Cloud 微服务实战》