版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_29451823/article/details/82784730
同步异步处理对比
- 使用Callable进行异步处理，副线程写在主线程里面的 ，符合企业级开发的一般应用场景！AsyncController.java
package com.imooc.web.asnyc;
import java.util.concurrent.Callable;
import org.apache.commons.lang.RandomStringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
@RestController
public class AsyncController {
private Logger logger = LoggerFactory.getLogger(getClass());
@RequestMapping("/order")
public Callable<String> order() throws Exception {
logger.info("主线程开启");
Callable<String> result = new Callable<String>() {
@Override
public String call() throws Exception {
logger.info("副线程开启");
Thread.sleep(1000);
logger.info("副线程关闭");
return "success";
}
};
logger.info("主线程关闭");
return result;
}
}
运行结果：
- 使用DefferedResult异步处理Rest服务，符合企业级开发的复杂应用场景！
MockQueue.java 模拟消息队列对象
package com.imooc.web.asnyc;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* 模拟消息队列的对象
* @author caijiajun
* @date 2018年9月13日
*/
@Component
public class MockQueue {
//下单的消息
private String placeOrder;
//订单完成的消息
private String completeOrder;
private Logger logger = LoggerFactory.getLogger(getClass());
public String getPlaceOrder() {
return placeOrder;
}
public void setPlaceOrder(String placeOrder) throws Exception {
new Thread(() -> {
logger.info("接到下单请求，" + placeOrder);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//服务器处理一秒后订单完成（相当于应用二）
this.completeOrder = placeOrder;
logger.info("下单请求处理完毕，" + placeOrder);
}).start();
}
public String getCompleteOrder() {
return completeOrder;
}
public void setCompleteOrder(String completeOrder) {
this.completeOrder = completeOrder;
}
}
DeferredResultHolder.java 两个线程之前传递对象
package com.imooc.web.asnyc;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.async.DeferredResult;
/**
* Http请求和响应两个线程之间传递对象
* @author caijiajun
* @date 2018年9月13日
*/
@Component
public class DeferredResultHolder {
//map<key,value> 其中key相当于订单号，一个订单号对应一个订单的处理结果
private Map<String,DeferredResult<String>> map = new HashMap<String,DeferredResult<String>>();
public Map<String,DeferredResult<String>> getMap() {
return map;
}
public void setMap(Map<String, DeferredResult<String>> map) {
this.map = map;
}
}
AsyncController.java Controller控制器
package com.imooc.web.asnyc;
import java.util.concurrent.Callable;
import org.apache.commons.lang.RandomStringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
@RestController
public class AsyncController {
@Autowired
private MockQueue mockQueue;
@Autowired
private DeferredResultHolder deferredResultHolder;
private Logger logger = LoggerFactory.getLogger(getClass());
@RequestMapping("/order")
public DeferredResult<String> order() throws Exception {
logger.info("主线程开启");
//生产8位随机订单号
String oderNumber = RandomStringUtils.randomNumeric(8);
mockQueue.setPlaceOrder(oderNumber);
//响应结果
DeferredResult<String> result = new DeferredResult<>();
//注入
deferredResultHolder.getMap().put(oderNumber, result);
logger.info("主线程关闭");
return result;
}
}
QueueListener.java 监听消息队列是否已经完成
package com.imooc.web.asnyc;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
/**
* 监听虚拟消息队列 相当于线程二
* @author caijiajun
* @date 2018年9月13日
*/
@Component
public class QueueListener implements ApplicationListener<ContextRefreshedEvent>{
@Autowired
private MockQueue mockQueue;
@Autowired
private DeferredResultHolder deferredResultHolder;
private Logger logger = LoggerFactory.getLogger(getClass());
//spring 加载完成后的事件
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
new Thread(() -> {
while (true) {
//消息队列不为空
if(StringUtils.isNotBlank(mockQueue.getCompleteOrder())) {
String orderNumber = mockQueue.getCompleteOrder();
logger.info("返回订单处理结果：" +orderNumber);
deferredResultHolder.getMap().get(orderNumber).setResult("place order success");
//还原消息队列为空
mockQueue.setCompleteOrder(null);
}else{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}).start();
}
}
- 上面的异步请求，都是模拟的，那么正在开发中的异步请求，spring是如何配置的呢？还是在WebMvcConfigurerAdapter的实现类里面进行配置
package com.imooc.web.config;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.AsyncSupportConfigurer;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import com.imooc.filter.TimeFilter;
import com.imooc.web.interceptor.TimeInterceptor;
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter{
@Autowired
private TimeInterceptor timeInterceptor;
/**
* 配置异步支持
*/
@Override
public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
//配置对应的异步请求拦截器
configurer.registerCallableInterceptors(timeInterceptor);//异步请求配置1、副线程就开在主线程里面
configurer.registerDeferredResultInterceptors(timeInterceptor);//配置对应的异步请求拦截器：2、使用DeferredResult设置消息
configurer.setDefaultTimeout(5000);//异步请求默认的超出时间
configurer.setTaskExecutor(null);//设置可重用的线程池，来替代spring默认的不重用的线程池，我们上面的Callable看的线程是每次运行的时候都是开的一个新的线程。这种就是不重用的线程池。
}
}