溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
一、SpringBoot中異步請求的使用
1、異步請求與同步請求
特點：
可以先釋放容器分配給請求的線程與相關資源，減輕系統負擔，釋放了容器所分配線程的請求，其響應將被延后，可以在耗時處理完成（例如長時間的運算）時再對客戶端進行響應。一句話：增加了服務器對客戶端請求的吞吐量（實際生產上我們用的比較少，如果并發請求量很大的情況下，我們會通過nginx把請求負載到集群服務的各個節點上來分攤請求壓力，當然還可以通過消息隊列來做請求的緩沖）。
2、異步請求的實現
方式一：Servlet方式實現異步請求
@RequestMapping(value = "/email/servletReq", method = GET)
public void servletReq (HttpServletRequest request, HttpServletResponse response) {
AsyncContext asyncContext = request.startAsync();
//設置監聽器:可設置其開始、完成、異常、超時等事件的回調處理
asyncContext.addListener(new AsyncListener() {
@Override
public void onTimeout(AsyncEvent event) throws IOException {
System.out.println("超時了...");
//做一些超時后的相關操作...
}
@Override
public void onStartAsync(AsyncEvent event) throws IOException {
System.out.println("線程開始");
}
@Override
public void onError(AsyncEvent event) throws IOException {
System.out.println("發生錯誤："+event.getThrowable());
}
@Override
public void onComplete(AsyncEvent event) throws IOException {
System.out.println("執行完成");
//這里可以做一些清理資源的操作...
}
});
//設置超時時間
asyncContext.setTimeout(20000);
asyncContext.start(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10000);
System.out.println("內部線程：" + Thread.currentThread().getName());
asyncContext.getResponse().setCharacterEncoding("utf-8");
asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
asyncContext.getResponse().getWriter().println("這是異步的請求返回");
} catch (Exception e) {
System.out.println("異常："+e);
}
//異步請求完成通知
//此時整個請求才完成
asyncContext.complete();
}
});
//此時之類 request的線程連接已經釋放了
System.out.println("主線程：" + Thread.currentThread().getName());
}
方式二：使用很簡單，直接返回的參數包裹一層callable即可，可以繼承WebMvcConfigurerAdapter類來設置默認線程池和超時處理
@RequestMapping(value = "/email/callableReq", method = GET)
@ResponseBody
public Callable<String> callableReq () {
System.out.println("外部線程：" + Thread.currentThread().getName());
return new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(10000);
System.out.println("內部線程：" + Thread.currentThread().getName());
return "callable!";
}
};
}
@Configuration
public class RequestAsyncPoolConfig extends WebMvcConfigurerAdapter {
@Resource
private ThreadPoolTaskExecutor myThreadPoolTaskExecutor;
@Override
public void configureAsyncSupport(final AsyncSupportConfigurer configurer) {
//處理 callable超時
configurer.setDefaultTimeout(60*1000);
configurer.setTaskExecutor(myThreadPoolTaskExecutor);
configurer.registerCallableInterceptors(timeoutCallableProcessingInterceptor());
}
@Bean
public TimeoutCallableProcessingInterceptor timeoutCallableProcessingInterceptor() {
return new TimeoutCallableProcessingInterceptor();
}
}
方式三：和方式二差不多，在Callable外包一層，給WebAsyncTask設置一個超時回調，即可實現超時處理
@RequestMapping(value = "/email/webAsyncReq", method = GET)
@ResponseBody
public WebAsyncTask<String> webAsyncReq () {
System.out.println("外部線程：" + Thread.currentThread().getName());
Callable<String> result = () -> {
System.out.println("內部線程開始：" + Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(4);
} catch (Exception e) {
// TODO: handle exception
}
logger.info("副線程返回");
System.out.println("內部線程返回：" + Thread.currentThread().getName());
return "success";
};
WebAsyncTask<String> wat = new WebAsyncTask<String>(3000L, result);
wat.onTimeout(new Callable<String>() {
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "超時";
}
});
return wat;
}
方式四：DeferredResult可以處理一些相對復雜一些的業務邏輯，最主要還是可以在另一個線程里面進行業務處理及返回，即可在兩個完全不相干的線程間的通信。
@RequestMapping(value = "/email/deferredResultReq", method = GET)
@ResponseBody
public DeferredResult<String> deferredResultReq () {
System.out.println("外部線程：" + Thread.currentThread().getName());
//設置超時時間
DeferredResult<String> result = new DeferredResult<String>(60*1000L);
//處理超時事件 采用委托機制
result.onTimeout(new Runnable() {
@Override
public void run() {
System.out.println("DeferredResult超時");
result.setResult("超時了!");
}
});
result.onCompletion(new Runnable() {
@Override
public void run() {
//完成后
System.out.println("調用完成");
}
});
myThreadPoolTaskExecutor.execute(new Runnable() {
@Override
public void run() {
//處理業務邏輯
System.out.println("內部線程：" + Thread.currentThread().getName());
//返回結果
result.setResult("DeferredResult!!");
}
});
return result;
}
二、SpringBoot中異步調用的使用
1、介紹
異步請求的處理。除了異步請求，一般上我們用的比較多的應該是異步調用。通常在開發過程中，會遇到一個方法是和實際業務無關的，沒有緊密性的。比如記錄日志信息等業務。這個時候正常就是啟一個新線程去做一些業務處理，讓主線程異步的執行其他業務。
2、使用方式（基于spring下）
3、注意事項
4、什么情況下會導致@Async異步方法會失效？
調用同一個類下注有@Async異步方法：在spring中像@Async和@Transactional、cache等注解本質使用的是動態代理，其實Spring容器在初始化的時候Spring容器會將含有AOP注解的類對象“替換”為代理對象（簡單這么理解），那么注解失效的原因就很明顯了，就是因為調用方法的是對象本身而不是代理對象，因為沒有經過Spring容器，那么解決方法也會沿著這個思路來解決。
5、解決4中問題1的方式（其它2,3兩個問題自己注意下就可以了）
將要異步執行的方法單獨抽取成一個類，原理就是當你把執行異步的方法單獨抽取成一個類的時候，這個類肯定是被Spring管理的，其他Spring組件需要調用的時候肯定會注入進去，這時候實際上注入進去的就是代理類了。
其實我們的注入對象都是從Spring容器中給當前Spring組件進行成員變量的賦值，由于某些類使用了AOP注解，那么實際上在Spring容器中實際存在的是它的代理對象。那么我們就可以通過上下文獲取自己的代理對象調用異步方法。
@Controller
@RequestMapping("/app")
public class EmailController {
//獲取ApplicationContext對象方式有多種,這種最簡單,其它的大家自行了解一下
@Autowired
private ApplicationContext applicationContext;
@RequestMapping(value = "/email/asyncCall", method = GET)
@ResponseBody
public Map<String, Object> asyncCall () {
Map<String, Object> resMap = new HashMap<String, Object>();
try{
//這樣調用同類下的異步方法是不起作用的
//this.testAsyncTask();
//通過上下文獲取自己的代理對象調用異步方法
EmailController emailController = (EmailController)applicationContext.getBean(EmailController.class);
emailController.testAsyncTask();
resMap.put("code",200);
}catch (Exception e) {
resMap.put("code",400);
logger.error("error!",e);
}
return resMap;
}
//注意一定是public,且是非static方法
@Async
public void testAsyncTask() throws InterruptedException {
Thread.sleep(10000);
System.out.println("異步任務執行完成！");
}
}
開啟cglib代理，手動獲取Spring代理類,從而調用同類下的異步方法。
首先，在啟動類上加上@EnableAspectJAutoProxy(exposeProxy = true)注解。
代碼實現，如下：
@Service
@Transactional(value = "transactionManager", readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
public class EmailService {
@Autowired
private ApplicationContext applicationContext;
@Async
public void testSyncTask() throws InterruptedException {
Thread.sleep(10000);
System.out.println("異步任務執行完成！");
}
public void asyncCallTwo() throws InterruptedException {
//this.testSyncTask();
// EmailService emailService = (EmailService)applicationContext.getBean(EmailService.class);
// emailService.testSyncTask();
boolean isAop = AopUtils.isAopProxy(EmailController.class);//是否是代理對象；
boolean isCglib = AopUtils.isCglibProxy(EmailController.class); //是否是CGLIB方式的代理對象；
boolean isJdk = AopUtils.isJdkDynamicProxy(EmailController.class); //是否是JDK動態代理方式的代理對象；
//以下才是重點!!!
EmailService emailService = (EmailService)applicationContext.getBean(EmailService.class);
EmailService proxy = (EmailService) AopContext.currentProxy();
System.out.println(emailService == proxy ? true : false);
proxy.testSyncTask();
System.out.println("end!!!");
}
}
三、異步請求與異步調用的區別
四、總結
總結
以上所述是小編給大家介紹的SpringBoot中異步請求和異步調用問題，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對億速云網站的支持！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
