SpringCloud (九) Hystrix请求合并的使用

前言：

承接上一篇文章，两文本来可以一起写的，但是发现RestTemplate使用普通的调用返回包装类型会出现一些问题，也正是这个问题，两文没有合成一文，本文篇幅不会太长，会说一下使用和适应的场景。

本文简单记述了Hystrix的请求合并的使用

>注意：本文项目地址：https://github.com/HellxZ/SpringCloudLearn.git

本文内容：

一、请求合并是做什么的？

如图，多个客户端发送请求调用RibbonConsumHystrix(消费者)项目中的findOne方法，这时候在这个项目中的线程池中会发申请与请求数量相同的线程数，对EurekaServiceProvider(服务提供者)的getUserById方法发起调用，每个线程都要调用一次，在高并发的场景下，这样势必会对服务提供者项目产生巨大的压力。

请求合并就是将单个请求合并成一个请求，去调用服务提供者，从而降低服务提供者负载的，一种应对高并发的解决办法

二、请求合并的原理

NetFlix在Hystrix为我们提供了应对高并发的解决方案----请求合并，如下图

通过请求合并器设置延迟时间，将时间内的，多个请求单个的对象的方法中的参数（id）取出来，拼成符合服务提供者的多个对象返回接口（getUsersByIds方法）的参数，指定调用这个接口（getUsersByIds方法），返回的对象List再通过一个方法（mapResponseToRequests方法），按照请求的次序将结果对象对应的装到Request对应的Response中返回结果。

三、请求合并适用的场景

在服务提供者提供了返回单个对象和多个对象的查询接口，并且单个对象的查询并发数很高，服务提供者负载较高的时候，我们就可以使用请求合并来降低服务提供者的负载

四、请求合并带来的问题

问题：即然请求合并这么好，我们是否就可以将所有返回单个结果的方法都用上请求合并呢？答案自然是否定的！

原因有二：

在第二节曾介绍过，我们为这个请求人为的设置了延迟时间，这样在并发不高的接口上使用请求缓存，会降低响应速度
有可能会提高服务提供者的负载：返回List的方法并发比返回单个对象方法负载更高的情况
实现请求合并比较复杂

五、实现请求合并

1、传统方式

首先在服务提供者的GetRequestController中添加两个接口，用于打印是哪个方法被调用

    /**
     * 为Hystrix请求合并提供的接口
     */
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id){
        logger.info("=========getUserById方法：入参ids："+id);
        return new User("one"+id, "女", "110-"+id);
    }

    @GetMapping("/users")
    public List<User> getUsersByIds(@RequestParam("ids") List<Long> ids){
        List<User> userList = new ArrayList<>();
        User user;
        logger.info("=========getUsersByIds方法：入参ids："+ids);
        for(Long id : ids){
            user = new User("person"+id ,"男","123-"+id);
            userList.add(user);
        }
        System.out.println(userList);
        return userList;
    }

在消费者（RibbonConsumHystrix）项目中的RibbonController中实现简单的调用上边的两个接口

    /**
     * 单个请求处理
     * @param id
     */
    @GetMapping("/users/{id}")
    public User findOne(@PathVariable Long id){
        LOGGER.debug("=============/hystrix/users/{} 执行了", id);
        User user = service.findOne(id);
        return user;
    }

    /**
     * 多个请求处理
     * @param ids id串，使用逗号分隔
     */
    @GetMapping("/users")
    public List<User> findAll(@RequestParam List<Long> ids){
        LOGGER.debug("=============/hystrix/users?ids={} 执行了", ids);
        return service.findAll(ids);
    }

扩充RibbonService，添加两个方法，分别调用上述两个接口，主要是为了分层明确

    /**请求合并使用到的测试方法**/

    /**
     * 查一个User对象
     */
    public User findOne(Long id){
        LOGGER.info("findOne方法执行了，id= "+id);
        return restTemplate.getForObject("http://eureka-service/users/{1}", User.class, id);
    }

    /**
     * 查多个对象
     *
     * 注意： 这里用的是数组，作为结果的接收，因为restTemplate.getForObject方法在这里受限
     *         如果尽如《SpringCloud微服务实战》一书中指定类型为List.class，会返回一个List<LinkedHashMap>类型的集合
     *         为了避坑这里我们使用数组的方式接收结果
     */
    public List<User> findAll(List<Long> ids){
        LOGGER.info("findAll方法执行了，ids= "+ids);
        User[] users = restTemplate.getForObject("http://eureka-service/users?ids={1}", User[].class, StringUtils.join(ids, ","));
        return Arrays.asList(users);
    }

接着在hystrix包下创建一个请求批处理UserBatchCommand类，使他继承HystrixCommand，泛型用List

package com.cnblogs.hellxz.hystrix;

import com.cnblogs.hellxz.entity.User;
import com.cnblogs.hellxz.servcie.RibbonService;
import com.netflix.hystrix.HystrixCommand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

import static com.netflix.hystrix.HystrixCommandGroupKey.Factory.asKey;

/**
 * @Author : Hellxz
 * @Description: 批量请求命令的实现
 * @Date : 2018/5/5 11:18
 */
public class UserBatchCommand extends HystrixCommand<List<User>> {

    private static final Logger LOGGER = LoggerFactory.getLogger(UserBatchCommand.class);

    private RibbonService service;
    /**
     * 这个ids是UserCollapseCommand获取的参数集
     */
    private List<Long> ids;

    public UserBatchCommand(RibbonService ribbonService, List<Long> ids){
        super(Setter.withGroupKey(asKey("userBatchCommand")));
        this.service = ribbonService;
        this.ids = ids;
    }

    /**
     * <b>方法名</b>: run
     * <p><b>描    述</b>: 调用服务层的简单调用返回集合</p>
     *
     * @param
     * @return  List<User>
     *
     * <p><b>创建日期</b> 2018/5/22 12:39 </p>
     * @author HELLXZ 张
     * @version 1.0
     * @since jdk 1.8
     */
    @Override
    protected List<User> run() {
        List<User> users = service.findAll(ids);
        System.out.println(users);
        return users;
    }

    /**
     * Fallback回调方法，如果没有会报错
     */
    @Override
    protected List<User> getFallback(){
        LOGGER.info("UserBatchCommand的run方法，调用失败");
        return null;
    }

}

上边的这个类是实际用来调用服务提供者的接口的，除了这个我们还需要一个将请求合并的类

在hystrix包下创建UserCollapseCommand

package com.cnblogs.hellxz.hystrix;

import com.cnblogs.hellxz.entity.User;
import com.cnblogs.hellxz.servcie.RibbonService;
import com.netflix.hystrix.HystrixCollapser;
import com.netflix.hystrix.HystrixCollapserProperties;
import com.netflix.hystrix.HystrixCommand;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

//注意这个asKey方法不是HystrixCommandKey.Factory.asKey
import static com.netflix.hystrix.HystrixCollapserKey.Factory.asKey;


/**
 * @Author : Hellxz
 * @Description: 继承HystrixCollapser的请求合并器
 * @Date : 2018/5/5 11:42
 */
public class UserCollapseCommand extends HystrixCollapser<List<User>,User,Long> {

    private RibbonService service;
    private Long userId;

    /**
     * 构造方法，主要用来设置这个合并器的时间，意为每多少毫秒就会合并一次
     * @param ribbonService 调用的服务
     * @param userId 单个请求传入的参数
     */
    public UserCollapseCommand(RibbonService ribbonService, Long userId){
        super(Setter.withCollapserKey(asKey("userCollapseCommand")).andCollapserPropertiesDefaults(HystrixCollapserProperties.Setter().withTimerDelayInMilliseconds(100)));
        this.service = ribbonService;
        this.userId = userId;
    }

    /**
     * 获取请求中的参数
     */
    @Override
    public Long getRequestArgument() {
        return userId;
    }

    /**
     * 创建命令，执行批量操作
     */
    @Override
    public HystrixCommand<List<User>> createCommand(Collection<CollapsedRequest<User, Long>> collapsedRequests) {
        //按请求数声名UserId的集合
        List<Long> userIds = new ArrayList<>(collapsedRequests.size());
        //通过请求将100毫秒中的请求参数取出来装进集合中
        userIds.addAll(collapsedRequests.stream().map(CollapsedRequest::getArgument).collect(Collectors.toList()));
        //返回UserBatchCommand对象，自动执行UserBatchCommand的run方法
        return new UserBatchCommand(service, userIds);
    }

    /**
     * 将返回的结果匹配回请求中
     * @param batchResponse 批量操作的结果
     * @param collapsedRequests 合在一起的请求
     */
    @Override
    protected void mapResponseToRequests(List<User> batchResponse, Collection<CollapsedRequest<User, Long>> collapsedRequests) {
        int count = 0 ;
        for(CollapsedRequest<User,Long> collapsedRequest : collapsedRequests){
            //从批响应集合中按顺序取出结果
            User user = batchResponse.get(count++);
            //将结果放回原Request的响应体内
            collapsedRequest.setResponse(user);
        }
    }
}

其中将多个参数封装成一个List，将参数交给UserBatchCommand类执行

创建测试接口：

在这里用了类比方法，分别是同步方法和异步方法

    /**
     * 合并请求测试
     * 说明：这个测试本应在findOne方法中new一个UserCollapseCommand对象进行测试
     *         苦于没有好的办法做并发实验，这里就放在一个Controller中了
     *         我们看到，在这个方法中用了三个UserCollapseCommand对象进行模拟高并发
     */
    @GetMapping("/collapse")
    public List<User> collapseTest(){
        LOGGER.info("==========>collapseTest方法执行了");
        List<User> userList = new ArrayList<>();
        Future<User> queue1 = new UserCollapseCommand(service, 1L).queue();
        Future<User> queue2 = new UserCollapseCommand(service, 2L).queue();
        Future<User> queue3 = new UserCollapseCommand(service, 3L).queue();
        try {
            User user1 = queue1.get();
            User user2 = queue2.get();
            User user3 = queue3.get();
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return userList;
    }

    /**
     * 同步方法测试合并请求
     *
     * 说明：这个方法是用来与上面的方法做类比的，通过这个实验我们发现如果使用同步方法，
     *         那么这个请求合并的作用就没有了，这会给findAll方法造成性能浪费
     */
    @GetMapping("synccollapse")
    public List<User> syncCollapseTest(){
        LOGGER.info("==========>syncCollapseTest方法执行了");
        List<User> userList = new ArrayList<>();
        User user1 = new UserCollapseCommand(service, 1L).execute();
        User user2 = new UserCollapseCommand(service, 2L).execute();
        User user3 = new UserCollapseCommand(service, 3L).execute();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        return userList;
    }

测试：

1）异步测试

postman访问 http://localhost:8088/hystrix/collapse

服务提供者的输出：

2018-05-22 13:11:46.718  INFO 9372 --- [io-8080-exec-10] c.c.h.controller.GetRequestController    : =========getUsersByIds方法：入参ids：[1, 2, 3]
[user:{name: person1, sex: 男, phone: 123-1 }, user:{name: person2, sex: 男, phone: 123-2 }, user:{name: person3, sex: 男, phone: 123-3 }]

异步请求合并成功！

2）同步测试

postman访问 http://localhost:8088/hystrix/synccollapse