三種合并請(qǐng)求的方式幫提高接口性能

<aop:aspectj-autoproxy/><bean id="hystrixAspect" class="com.netflix.hystrix.contrib.javanica.aop.aspectj.HystrixCommandAspect" />

public class HystrixCollapserSample {
    @HystrixCollapser(batchMethod = "batch")    public Future<Boolean> single(String input) {        return null; // single方法不會(huì)被執(zhí)行到    }
    public List<Boolean> batch(List<String> inputs) {        return inputs.stream().map(it -> Boolean.TRUE).collect(Collectors.toList());    }}

@HystrixCollapser(            batchMethod = "batch",            collapserKey = "single",            scope = com.netflix.hystrix.HystrixCollapser.Scope.GLOBAL,            collapserProperties = {                    @HystrixProperty(name = "maxRequestsInBatch", value = "100"),                    @HystrixProperty(name = "timerDelayInMilliseconds", value = "1000"),                    @HystrixProperty(name = "requestCache.enabled", value = "true")            })

public class BatchCollapser<E> implements InitializingBean {     private static final Logger logger = LoggerFactory.getLogger(BatchCollapser.class);     private static volatile Map<Class, BatchCollapser> instance = Maps.newConcurrentMap();     private static final ScheduledExecutorService SCHEDULE_EXECUTOR = Executors.newScheduledThreadPool(1);
     private volatile LinkedBlockingDeque<E> batchContainer = new LinkedBlockingDeque<>();     private Handler<List<E>, Boolean> cleaner;     private long interval;     private int threshHold;
     private BatchCollapser(Handler<List<E>, Boolean> cleaner, int threshHold, long interval) {         this.cleaner = cleaner;         this.threshHold = threshHold;         this.interval = interval;     }
     @Override     public void afterPropertiesSet() throws Exception {         SCHEDULE_EXECUTOR.scheduleAtFixedRate(() -> {             try {                 this.clean();             } catch (Exception e) {                 logger.error("clean container exception", e);             }         }, 0, interval, TimeUnit.MILLISECONDS);     }
     public void submit(E event) {         batchContainer.add(event);         if (batchContainer.size() >= threshHold) {             clean();         }     }
     private void clean() {         List<E> transferList = Lists.newArrayListWithExpectedSize(threshHold);         batchContainer.drainTo(transferList, 100);         if (CollectionUtils.isEmpty(transferList)) {             return;         }
         try {             cleaner.handle(transferList);         } catch (Exception e) {             logger.error("batch execute error, transferList:{}", transferList, e);         }     }
     public static <E> BatchCollapser getInstance(Handler<List<E>, Boolean> cleaner, int threshHold, long interval) {         Class jobClass = cleaner.getClass();         if (instance.get(jobClass) == null) {             synchronized (BatchCollapser.class) {                 if (instance.get(jobClass) == null) {                     instance.put(jobClass, new BatchCollapser<>(cleaner, threshHold, interval));                 }             }         }
         return instance.get(jobClass);     } }

if (ConcurrentHashMultiset.isEmpty()) {    return;}
List<Request> transferList = Lists.newArrayList();ConcurrentHashMultiset.elementSet().forEach(request -> {    int count = ConcurrentHashMultiset.count(request);    if (count <= 0) {        return;    }
    transferList.add(count == 1 ? request : new Request(request.getIncrement() * count));    ConcurrentHashMultiset.remove(request, count);});