How To Do @Async in Spring--转
原文地址:http://www.baeldung.com/spring-async
1. Overview
In this article, we’ll explore the asynchronous execution support in Spring – and the @Async annotation.
Simply put – annotating a method of a bean with @Async will make it execute in a separate thread i.e. the caller will not wait for the completion of the called method.
One interesting aspect in Spring is that the event support in the framework also has support for async processing if you want to go that route.
2. Enable Async Support
Let’s start by enabling asynchronous processing with Java configuration – by simply adding the @EnableAsync to a configuration class:
1
2
3
|
@Configuration @EnableAsync public class SpringAsyncConfig { ... } |
The enable annotation is enough, but as you’d expect, there are also a few simple options for configuration as well:
- annotation – by default, @EnableAsync detects Spring’s @Async annotation and the EJB 3.1 javax.ejb.Asynchronous; this option can be used to detect other, user-defined annotation types as well
- mode – indicates the type of advice that should be used – JDK proxy-based or AspectJ weaving
- proxyTargetClass – indicates the type of proxy that should be used – CGLIB or JDK; this attribute has effect only if the mode is set to AdviceMode.PROXY
- order – sets the order in which AsyncAnnotationBeanPostProcessor should be applied; by default, it runs last, just so that it can take into account all existing proxies
Asynchronous processing can also be enabled using XML configuration – by using the task namespace:
1
2
|
< task:executor id = "myexecutor" pool-size = "5" /> < task:annotation-driven executor = "myexecutor" /> |
3. The @Async Annotation
First – let’s go over the rules – @Async has two limitations:
- it must be applied to public methods only
- self-invocation – calling the async method from within the same class – won’t work
The reasons are simple – the method needs to be public so that it can be proxied. And self-invocation doesn’t work because it bypasses the proxy and calls the underlying method directly.
3.1. Methods with void Return Type
Following is the simple way to configure a method with void return type to run asynchronously:
1
2
3
4
5
|
@Async public void asyncMethodWithVoidReturnType() { System.out.println( "Execute method asynchronously. " + Thread.currentThread().getName()); } |
3.2. Methods With Return Type
@Async can also be applied to a method with return type – by wrapping the actual return in the Future:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
@Async public Future<String> asyncMethodWithReturnType() { System.out.println( "Execute method asynchronously - " + Thread.currentThread().getName()); try { Thread.sleep( 5000 ); return new AsyncResult<String>( "hello world !!!!" ); } catch (InterruptedException e) { // } return null ; } |
Spring also provides an AsyncResult class which implements Future. This can be used to track the result of asynchronous method execution.
Now, let’s invoke the above method and retrieve the result of the asynchronous process using the Future object.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public void testAsyncAnnotationForMethodsWithReturnType() throws InterruptedException, ExecutionException { System.out.println( "Invoking an asynchronous method. " + Thread.currentThread().getName()); Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType(); while ( true ) { if (future.isDone()) { System.out.println( "Result from asynchronous process - " + future.get()); break ; } System.out.println( "Continue doing something else. " ); Thread.sleep( 1000 ); } } |
4. The Executor
By default, Spring uses a SimpleAsyncTaskExecutor to actually run these methods asynchronously. The defaults can be overridden at two levels – at the application level or at the individual method level.
4.1. Override the Executor at the Method Level
The required executor needs to be declared in a configuration class:
1
2
3
4
5
6
7
8
9
|
@Configuration @EnableAsync public class SpringAsyncConfig { @Bean (name = "threadPoolTaskExecutor" ) public Executor threadPoolTaskExecutor() { return new ThreadPoolTaskExecutor(); } } |
Then the executor name should be provided as an attribute in @Async:
1
2
3
4
5
|
@Async ( "threadPoolTaskExecutor" ) public void asyncMethodWithConfiguredExecutor() { System.out.println( "Execute method with configured executor - " + Thread.currentThread().getName()); } |
4.2. Override the Executor at the Application Level
The configuration class should implement the AsyncConfigurer interface – which will mean that it has the implement the getAsyncExecutor() method. It’s here that we will return the executor for the entire application – this now becomes the default executor to run methods annotated with @Async:
1
2
3
4
5
6
7
8
9
10
|
@Configuration @EnableAsync public class SpringAsyncConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { return new ThreadPoolTaskExecutor(); } } |
5. Exception Handling
When a method return type is a Future, exception handling is easy – Future.get() method will throw the exception.
But, if the return type is void, exceptions will not be propagated to the calling thread. Hence we need to add extra configurations to handle exceptions.
We’ll create a custom async exception handler by implementing AsyncUncaughtExceptionHandler interface. The handleUncaughtException() method is invoked when there are any uncaught asynchronous exceptions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler { @Override public void handleUncaughtException( Throwable throwable, Method method, Object... obj) { System.out.println( "Exception message - " + throwable.getMessage()); System.out.println( "Method name - " + method.getName()); for (Object param : obj) { System.out.println( "Parameter value - " + param); } } } |
In the previous section, we looked at the AsyncConfigurer interface implemented by the configuration class. As part of that, we also need to override the getAsyncUncaughtExceptionHandler() method to return our custom asynchronous exception handler:
1
2
3
4
|
@Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return new CustomAsyncExceptionHandler(); } |
6. Conclusion
In this tutorial, we looked at running asynchronous code with Spring. We started with the very basic configuration and annotation to make it work but also looked at more advanced configs such as providing our own executor, or exception handling strategies.
How To Do @Async in Spring--转的更多相关文章
- SpringBoot系列:Spring Boot异步调用@Async
在实际开发中,有时候为了及时处理请求和进行响应,我们可能会多任务同时执行,或者先处理主任务,也就是异步调用,异步调用的实现有很多,例如多线程.定时任务.消息队列等, 这一章节,我们就来讲讲@Async ...
- spring boot使用@Async异步注解
1.java的大部分接口的方法都是串行执行的,但是有些业务场景是不需要同步返回结果的,可以把结果直接返回,具体业务异步执行,也有些业务接口是需要并行获取数据,最后把数据聚合在统一返回给前端. 通常我们 ...
- 161021、spring异步调用,完美解决!
前言 项目中,用户抢单,下单需要向对方推送消息,但是加上推送就会造成抢单和下单性能降低,反应变慢,因为抢单下单动作跟推送部分是同步的,现在想改成异步推送. 在Java应用中,绝大多数情况下都是通过同步 ...
- 【Spring】6、注解大全
一.@interface Java用 @interface Annotation{ } 定义一个注解 @Annotation,一个注解是一个类. 二.@Override,@Deprecated,@S ...
- spring 类注入失败,解决之道
1.今天偶尔发现的问题,如果你在一个类上面用了注解@Async,spring的异步注解之后,发现如果别的类用@Autowired导入这个类时会失败! 解决办法:用了@Async无非是想方便的用异步操作 ...
- Java方式配置Spring MVC
概述 使用Java方式配置Spring MVC,以及回顾一下Spring MVC的各种用法. Spring MVC简述 关于Spring MVC的介绍网上有很多,这里就不再赘述了,只是要说一下,Spr ...
- 注解@Async解决异步调用问题
序言:Spring中@Async 根据Spring的文档说明,默认采用的是单线程的模式的.所以在Java应用中,绝大多数情况下都是通过同步的方式来实现交互处理的. 那么当多个任务的执行势必会相互影响. ...
- springmvc实现long-pulling技术
背景介绍: 项目中有一个通讯模块,本来是用websocket全双工技术实现的,但IE10下面不支持websocket,而国内的360.2345浏 览器封装的所有是IE10下面的内核,考虑到站点在国内的 ...
- servlet3异步原理与实践
一.什么是Servlet servlet 是基于 Java 的 Web 组件,由容器进行管理,来生成动态内容.像其他基于 Java 的组件技术一样,servlet 也是基于平台无关的 Java 类格式 ...
- springboot-async
在项目中,当访问其他人的接口较慢或者做耗时任务时,不想程序一直卡在耗时任务上,想程序能够并行执行, 我们可以使用多线程来并行的处理任务,也可以使用spring提供的异步处理方式@Async. Spri ...
随机推荐
- windows安装gnvm安装教程,node多版本解决方案
本文是实现windows下node多版本管理 Win10专业版 一.安装前准备 安装前请卸载node相关的所有东西!!! 二.gnvm下载 gnvm搜索 http://ksria.com/gnvm/ ...
- js接收文件流并下载
js接收文件流并下载 标签(空格分隔): js 在此输入正文 <script type="text/javascript"> function download(fil ...
- Android7.0打开sdacrd图片问题
1.点击item,通过intent打开指定路径的图片. 2.测试6.0,5.0正常运行代码: File file=new File(item.address): Intent intent = new ...
- golden gate的DDL配置
DDL复制的配置 目前只支持oracle和teradata的ddl复制 oracle能复制除了系统对象之外的所有对象 两种配置方法: 基于trigger的DDL:对于生产库有一定影响. 原理: 源库建 ...
- 【摘录】JAVA内存管理-有关垃圾收集的关键参数
第八章 有关垃圾收集的关键参数 一些命令行参数可以用来选择垃圾收集器,指定堆或代的大小,修改垃圾收集行为,获取垃圾收集统计数据.本章给出一些最常用的参数.有关各种各样参数更多完整的列表和详细信息可以参 ...
- POJ 1458 Common Subsequence 【最长公共子序列】
解题思路:先注意到序列和串的区别,序列不需要连续,而串是需要连续的,先由样例abcfbc abfcab画一个表格分析,用dp[i][j]储存当比较到s1[i],s2[j]时最长公共子序 ...
- hook的本质就是在本原可执行文件中加东西
hook的本质就是在本原可执行文件中加东西. 本质就是添加东西:
- Unity 组件的增、查、禁、删 代码书写
using UnityEngine; public class NewBehaviourScript : MonoBehaviour { // Use this for initialization ...
- day10 强制类型转换(更新)
目录 强制类型转换 int() str() list() tuple() set() dict() 总结 强制类型转换 直接看总结 # 定义各个数据类型的值 num_int = 123 num_flo ...
- QT中文字的绘制
为什么要做这次文字的介绍,因为在一般的教材中,还真没有文字的描述: 1.绘制最简单的文字. 我们更改重绘函数如下: void Dialog::paintEvent(QPaintEvent *){QPa ...