Spring-cloud (九) 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

服务提供者的输出：

2018-05-22 13:13:22.195  INFO 9372 --- [nio-8080-exec-8] c.c.h.controller.GetRequestController    : =========getUsersByIds方法：入参ids：[1]

[user:{name: person1, sex: 男, phone: 123-1 }]

2018-05-22 13:13:22.295  INFO 9372 --- [nio-8080-exec-1] c.c.h.controller.GetRequestController    : =========getUsersByIds方法：入参ids：[2]

[user:{name: person2, sex: 男, phone: 123-2 }]

2018-05-22 13:13:22.393  INFO 9372 --- [nio-8080-exec-5] c.c.h.controller.GetRequestController    : =========getUsersByIds方法：入参ids：[3]

[user:{name: person3, sex: 男, phone: 123-3 }]

异步请求合并失败!

2、注解方式

扩充RibbonService

    /**注解方式实现请求合并**/

    /**

     * 被合并请求的方法

     * 注意是timerDelayInMilliseconds，注意拼写

     */

    @HystrixCollapser(batchMethod = "findAllByAnnotation",collapserProperties = {@HystrixProperty(name = "timerDelayInMilliseconds",value = "100")})

    public Future<User> findOneByAnnotation(Long id){

        //你会发现根本不会进入这个方法体

        LOGGER.info("findOne方法执行了，ids= "+id);

        return null;

    }

    /**

     * 真正执行的方法

     */

    @HystrixCommand

    public List<User> findAllByAnnotation(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);

    }

扩充RibbonController调用findOneByAnnotation()

    /**

     * 注解方式的请求合并

     *

     * 这里真想不出怎么去测试 这个方法了，有什么好的并发测试框架请自测吧，如果找到这种神器

     * 请给我发邮件告诉我： hellxz001@foxmail.com

     */

    @GetMapping("/collapsebyannotation/{id}")

    public User collapseByAnnotation(@PathVariable Long id) throws ExecutionException, InterruptedException {

        Future<User> one = service.findOneByAnnotation(id);

        User user = one.get();

        return user;

    }

找到好用的测试工具记得联系我：hellxz001@foxmail.com ，在下在此感激不尽！

结束：

好了，这就是Hystrix请求合并的部分我所分享的，如果文章中有错误的地方及建议，还望评论指出。

引用：

理论部分来自：《SpringCloud微服务实战》作者：翟永超

实践部分参考官方文档：https://github.com/Netflix/Hystrix/wiki/How-To-Use#Collapsing

以及：Hystrix请求合并

>声名：本文为本人实操笔记，如需转载请注明出处：https://www.cnblogs.com/hellxz/p/9071163.html