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 ...
随机推荐
- oracle init.ora常用配置详解
参考网上整理了重要的配置文件 db_name = "51cto" 一个数据库标识符,应与CREATE DATABASE 语句中指定的名称相对应. instance_name = ...
- USACO 2.2 Preface Numbering
Preface Numbering A certain book's prefaces are numbered in upper case Roman numerals. Traditional R ...
- MyEclipse安装TestNG
1.获取TestNG运行包. (1).直接下载*.jar包并导入项目中. (2).maven下载. http://testng.org/doc/download.html 2.为IDE加载TestNG ...
- JavaScript设计模式学习——builder pattern(建造者模式)
个人理解的应用场景 举个例子,比如想要创建各种类型的车的实例,车的类型有很多种,但创建每种类型车的接口定义可能是一样的,就用到了此模式 相关概念的通俗解释 上述例子中接口的定义叫builder 接口到 ...
- bootstrap-导航条
默认样式的导航条 导航条是在您的应用或网站中作为导航页头的响应式基础组件.它们在移动设备上可以折叠(并且可开可关),且在视口(viewport)宽度增加时逐渐变为水平展开模式. 两端对齐的导航条导航链 ...
- LeetCode Golang 2. 两数相加
2. 两数相加 给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字. 如果,我们将这两个数相加起来,则会返回一个新的链 ...
- day15 函数对象以及作用域
目录 函数对象 函数对象的四大功能 函数的嵌套 名称空间和作用域 名称空间 考试必考 作用域 global nonlacal LEGB原则 函数对象 ==Python中一切皆对象== 函数名也可以看成 ...
- BZOJ 1856 [SCOI2010]生成字符串 (组合数)
题目大意:给你n个1和m个0,你要用这些数字组成一个长度为n+m的串,对于任意一个位置k,要保证前k个数字中1的数量大于等于0的数量,求所有合法的串的数量 答案转化为所有方案数-不合法方案数 所有方案 ...
- 一、frp官方中文文档
frp 是一个可用于内网穿透的高性能的反向代理应用,支持 tcp, udp, http, https 协议. 目录 frp 的作用 开发状态 架构 使用示例 通过 ssh 访问公司内网机器 通过自定义 ...
- 新手学python-Day3-模块
模块就是引入别人写的,官方写的工具库,就像扳手,钳子,电锯