前言：
承接上一篇文章，两文本来可以一起写的，但是发现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.asKeyimport 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请求合并