Spring实现异步任务处理

1.Spring 实现异步任务

Spring提供了一个接口org.springframework.core.task.TaskExecutor，这个接口实现了java.util.concurrent.Executor接口，Executor这个接口熟悉多线程的同窗应该都知道，这是java线程池的顶层接口，那也就是说TaskExecutor也是个线程池，经过线程池来执行咱们的异步任务。

1.基于xml配置

经过xml文件来配置TaskExecutor线程池，具体配置以下。

<!-- 代码中引用便可 @Autowired id:线程池名称，池中线程的名称前缀 ThreadPoolTaskExecutor pool-size:单一的值表示核心线程数量，若是是5-25，表示core-max queue-capacity:队列容量，默认是无界队列，可能会致使OOM，并且在无界队列的状况下，最大线程就无效了，只有固定线程才适合无界队列 rejection-policy:当都满了的时候的拒绝策略，AbortPolice,CallerRunsPolicy,DiscardPolicy,DiscardOldestPolicy keep-alive:超过核心线程数量的线程的保活时间，若是设置为0，表示任务执行完以后当即回收 单位：s -->
<task:executor id="myExecutor" pool-size="5-25" queue-capacity="200" rejection-policy="ABORT" keep-alive="120"/>
复制代码

从上面的配置咱们能够看出来，其实就是线程池的经常使用配置。

使用方式：

public class MyAsync {

    /** * 注入线程池 */
    @Autowired
    private TaskExecutor taskExecutor;

    /** * 无返回值、无参数 */
    public void async() {
       // taskExecutor.execute(new MyTask());
    }

    /** * 有参数、无返回值 * * @param param */
    public void param(String param) {
        // taskExecutor.execute(new MyTask());
    }

    /** * Future 异步返回 * * @return */
    public Future<String> future() {
        // taskExecutor.execute(new MyTask());
        return new AsyncResult<String>("result");
    }

    /** * CompletableFuture 异步返回 * * @return */
    public CompletableFuture<String> completedFuture() {
        // taskExecutor.execute(new MyTask());
        return CompletableFuture.completedFuture("result");
    }
}
复制代码

基于xml配置，也能够配置启用@Async注解，具体配置以下：

<!-- 该标签是用于开启注解模式的，识别@Scheduled executor:executor bean name scheduler:scheduler bean name exception-handler:ThreadPoolTaskExecutor exception handler bean name mode:代理方式 1.AspectJ 2.JDK Proxy 默认JDK Proxy proxy-target-class:是否代理目标类 默认false -->
    <task:annotation-driven executor="myExecutor"/>
复制代码

直接使用@Async注解便可，使用方式以下：

public class MyAsync {

    /** * 无返回值、无参数 */
    @Async
    public void async() {
        
    }

    /** * 有参数、无返回值 * * @param param */
    @Async
    public void param(String param) {

    }

    /** * Future 异步返回 * * @return */
    @Async
    public Future<String> future() {

        return new AsyncResult<String>("result");
    }

    /** * CompletableFuture 异步返回 * * @return */
    @Async
    public CompletableFuture<String> completedFuture() {

        return CompletableFuture.completedFuture("result");
    }
}
复制代码

2.基于java config

基于java config的配置须要实现org.springframework.scheduling.annotation.AsyncConfigurer接口，具体代码以下。

@Configuration
public class MyAsyncConfigure implements AsyncConfigurer {


    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.execute(myTask());
        Future<?> future = executor.submit(myTask());
        return executor;
    }

    /** * 异常处理 * * @return */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }

    public MyTask myTask() {
        return new MyTask();
    }
}
复制代码

3.基于注解

基于注解的配置方式是使用@EnableAsync和@Asyc两个注解

@Configuration
@EnableAsync //开启异步，至关于TaskExecutor
public class MyConfiguration {
    /** * 配置线程池 * 若是不配置，@EnableAsync默认core-size=1 * * @return */
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor scheduler = new ThreadPoolTaskExecutor();
        scheduler.setCorePoolSize(10);
        return scheduler;
    }
}
复制代码

使用方式：

public class MyAsync {

    /** * 无返回值、无参数 */
    @Async
    public void async() {
    }

    /** * 有参数、无返回值 * * @param param */
    @Async
    public void param(String param) {

    }

    /** * Future 异步返回 * * @return */
    @Async
    public Future<String> future() {
        return new AsyncResult<String>("result");
    }

    /** * CompletableFuture 异步返回 * * @return */
    @Async
    public CompletableFuture<String> completedFuture() {
        return CompletableFuture.completedFuture("result");
    }
}
复制代码

4.异常处理

1.xml和注解

若是是使用xml配置或注解配置方式，异常处理须要实现org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler接口，它有一个简单的实现org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler，这个实现记录了异常日志，咱们也能够实现这个接口，自定义异常处理。

public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {

    }
}
复制代码

xml使用：

<!--异常处理-->
<bean id="myAsyncUncaughtExceptionHandler" class="com.ly.task.async.MyAsyncUncaughtExceptionHandler"/>

<task:annotation-driven executor="myExecutor" exception-handler="myAsyncUncaughtExceptionHandler"/>
复制代码

注解方式只要配置了，发生异常会自动调用。

2.java config

在上面java config的配置中，咱们实现了org.springframework.scheduling.annotation.AsyncConfigurer接口来配置，这个接口里面有一个org.springframework.scheduling.annotation.AsyncConfigurer#getAsyncUncaughtExceptionHandler方法，直接在这个方法里进行异常处理便可。

​