Springboot实现高吞吐量异步处理详解(适用于高并发场景)

2023-08-08 17:39:04 369

技术要点

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

packagecom.java;

importorg.springframework.boot.SpringApplication;
importorg.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
publicclassAsyncStarter{

publicstaticvoidmain(String[]args){
SpringApplication.run(AsyncStarter.class,args);
}
}

4. AsyncVo.java

packagecom.java.vo;

importorg.springframework.web.context.request.async.DeferredResult;

/**
*存储异步处理信息
*
*@authorLogen
*
*@param接口输入参数
*@param接口返回参数
*/
publicclassAsyncVo{

/**
*请求参数
*/
privateIparams;

/**
*响应结果
*/
privateDeferredResultresult;

publicIgetParams(){
returnparams;
}

publicvoidsetParams(Iparams){
this.params=params;
}

publicDeferredResultgetResult(){
returnresult;
}

publicvoidsetResult(DeferredResultresult){
this.result=result;
}
}

5. RequestQueue.java

packagecom.java.queue; importjava.util.concurrent.BlockingQueue; importjava.util.concurrent.LinkedBlockingQueue; importorg.springframework.stereotype.Component; importcom.java.vo.AsyncVo; /** *存放所有异步处理接口请求队列的对象,一个接口对应一个队列 * *@authorLogen * */ @Component publicclassRequestQueue{ /** *处理下订单接口的队列，设置缓冲容量为50 */ privateBlockingQueue>orderQueue=newLinkedBlockingQueue<>(50); publicBlockingQueue>getOrderQueue(){ returnorderQueue; } }

6. OrderTask.java

packagecom.java.task; importjava.util.HashMap; importjava.util.Map; importorg.springframework.beans.factory.annotation.Autowired; importorg.springframework.stereotype.Component; importcom.java.queue.RequestQueue; importcom.java.vo.AsyncVo; /** *处理订单接口的任务，每个任务类处理一种接口 * *@authorLogen * */ @Component publicclassOrderTaskextendsThread{ @Autowired privateRequestQueuequeue; privatebooleanrunning=true; @Override publicvoidrun(){ while(running){ try{ AsyncVovo=queue.getOrderQueue().take(); System.out.println("[OrderTask]开始处理订单"); Stringparams=vo.getParams(); Thread.sleep(3000); Mapmap=newHashMap<>(); map.put("params",params); map.put("time",System.currentTimeMillis()); vo.getResult().setResult(map); System.out.println("[OrderTask]订单处理完成"); }catch(InterruptedExceptione){ e.printStackTrace(); running=false; } } } publicvoidsetRunning(booleanrunning){ this.running=running; } }

7. QueueListener.java

packagecom.java.listener; importjavax.annotation.PostConstruct; importjavax.annotation.PreDestroy; importorg.springframework.beans.factory.annotation.Autowired; importorg.springframework.stereotype.Component; importcom.java.task.OrderTask; /** *队列监听器，初始化启动所有监听任务 * *@authorLogen * */ @Component publicclassQueueListener{ @Autowired privateOrderTaskorderTask; /** *初始化时启动监听请求队列 */ @PostConstruct publicvoidinit(){ orderTask.start(); } /** *销毁容器时停止监听任务 */ @PreDestroy publicvoiddestory(){ orderTask.setRunning(false); } }

8. OrderController.java

packagecom.java.controller; importorg.springframework.beans.factory.annotation.Autowired; importorg.springframework.web.bind.annotation.GetMapping; importorg.springframework.web.bind.annotation.RestController; importorg.springframework.web.context.request.async.DeferredResult; importcom.java.queue.RequestQueue; importcom.java.vo.AsyncVo; /** *
* *
* *模拟下单处理，实现高吞吐量异步处理请求 * *1、Controller层接口只接收请求，不进行处理，而是把请求信息放入到对应该接口的请求队列中 *2、该接口对应的任务类监听对应接口的请求队列，从队列中顺序取出请求信息并进行处理 * *优点：接口几乎在收到请求的同时就已经返回，处理程序在后台异步进行处理，大大提高吞吐量 * * *
* *
* *@authorLogen * */ @RestController publicclassOrderController{ @Autowired privateRequestQueuequeue; @GetMapping("/order") publicDeferredResult

Springboot实现高吞吐量异步处理详解(适用于高并发场景)

热门推荐

随机推荐