怎么在Springboot中利用高吞吐量异步处理-成都快上网建站

怎么在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 order(String number) throws InterruptedException {     System.out.println("[ OrderController ] 接到下单请求");     System.out.println("当前待处理订单数: " + queue.getOrderQueue().size());     AsyncVo vo = new AsyncVo<>();     DeferredResult result = new DeferredResult<>();     vo.setParams(number);     vo.setResult(result);     queue.getOrderQueue().put(vo);     System.out.println("[ OrderController ] 返回下单结果");     return result;   } }

 9.   运行 AsyncStarter.java ,启动测试

浏览器输入 http://localhost:8080/order?number=10001

正常情况处理3秒返回,返回结果如下

{"time":1548241500718,"params":"10001"}

观察控制台打印日志,如下所示:

[ OrderController ] 接到下单请求
当前待处理订单数: 0
[ OrderController ] 返回下单结果
[ OrderTask ]开始处理订单
[ OrderTask ]订单处理完成

看完上述内容是否对您有帮助呢?如果还想对相关知识有进一步的了解或阅读更多相关文章,请关注创新互联行业资讯频道,感谢您对创新互联的支持。


分享文章:怎么在Springboot中利用高吞吐量异步处理
当前网址:http://kswjz.com/article/goejgi.html
扫二维码与项目经理沟通

我们在微信上24小时期待你的声音

解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流