怎么在Springboot中利用高吞吐量异步处理

怎么在Springboot中利用高吞吐量异步处理？很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。

专注于为中小企业提供做网站、成都网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业神农架林区免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了1000+企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

技术要点

org.springframework.web.context.request.async.DeferredResult

示例如下：

1.   新建Maven项目  async

2.   pom.xml

  4.0.0
  com.java
  async
  1.0.0

  
    org.springframework.boot
    spring-boot-starter-parent
    2.0.5.RELEASE
  


  

    
    
      org.springframework.boot
      spring-boot-starter-web
    


    
    
      org.springframework
      springloaded
      1.2.8.RELEASE
      provided
    
    
      org.springframework.boot
      spring-boot-devtools
      provided
    

  

  
    ${project.artifactId}
    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        
          1.8
          1.8
          UTF-8
        
      

      
        org.springframework.boot
        spring-boot-maven-plugin
        
          
            
              repackage
            
          
        
      
    
  

3.   AsyncStarter.java

package com.java;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AsyncStarter {

  public static void main(String[] args) {
    SpringApplication.run(AsyncStarter.class, args);
  }
}

4.   AsyncVo.java

package com.java.vo;

import org.springframework.web.context.request.async.DeferredResult;

/**
 * 存储异步处理信息
 * 
 * @author Logen
 *
 * @param  接口输入参数
 * @param  接口返回参数
 */
public class AsyncVo {

  /**
   * 请求参数
   */
  private I params;

  /**
   * 响应结果
   */
  private DeferredResult result;

  public I getParams() {
    return params;
  }

  public void setParams(I params) {
    this.params = params;
  }

  public DeferredResult getResult() {
    return result;
  }

  public void setResult(DeferredResult result) {
    this.result = result;
  }
}

5.   RequestQueue.java

package com.java.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.springframework.stereotype.Component;

import com.java.vo.AsyncVo;

/**
 * 存放所有异步处理接口请求队列的对象,一个接口对应一个队列
 * 
 * @author Logen
 *
 */
@Component
public class RequestQueue {

  /**
   * 处理下订单接口的队列，设置缓冲容量为50
   */
  private BlockingQueue> orderQueue = new LinkedBlockingQueue<>(50);

  public BlockingQueue> getOrderQueue() {
    return orderQueue;
  }
}

6.   OrderTask.java

package com.java.task;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.java.queue.RequestQueue;
import com.java.vo.AsyncVo;

/**
 * 处理订单接口的任务，每个任务类处理一种接口
 * 
 * @author Logen
 *
 */
@Component
public class OrderTask extends Thread {

  @Autowired
  private RequestQueue queue;

  private boolean running = true;

  @Override
  public void run() {
    while (running) {
      try {
        AsyncVo vo = queue.getOrderQueue().take();
        System.out.println("[ OrderTask ]开始处理订单");

        String params = vo.getParams();
        Thread.sleep(3000);
        Map map = new HashMap<>();
        map.put("params", params);
        map.put("time", System.currentTimeMillis());

        vo.getResult().setResult(map);

        System.out.println("[ OrderTask ]订单处理完成");
      } catch (InterruptedException e) {
        e.printStackTrace();
        running = false;
      }

    }
  }

  public void setRunning(boolean running) {
    this.running = running;
  }
}

7.   QueueListener.java

package com.java.listener;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.java.task.OrderTask;

/**
 * 队列监听器，初始化启动所有监听任务
 * 
 * @author Logen
 *
 */
@Component
public class QueueListener {

  @Autowired
  private OrderTask orderTask;

  /**
   * 初始化时启动监听请求队列
   */
  @PostConstruct
  public void init() {
    orderTask.start();
  }

  /**
   * 销毁容器时停止监听任务
   */
  @PreDestroy
  public void destory() {
    orderTask.setRunning(false);
  }

}

8.   OrderController.java

package com.java.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;

import com.java.queue.RequestQueue;
import com.java.vo.AsyncVo;

/**
 * 

 * 
 * 
 * 
 * 模拟下单处理，实现高吞吐量异步处理请求
 * 
 * 1、 Controller层接口只接收请求，不进行处理，而是把请求信息放入到对应该接口的请求队列中
 * 2、 该接口对应的任务类监听对应接口的请求队列，从队列中顺序取出请求信息并进行处理
 * 
 * 优点：接口几乎在收到请求的同时就已经返回，处理程序在后台异步进行处理，大大提高吞吐量
 * 
 * 
 * 
 * 
 * 
 * 
 * @author Logen
 *
 */
@RestController
public class OrderController {

  @Autowired
  private RequestQueue queue;

  @GetMapping("/order")
  public DeferredResult