Spring Aysnc 最佳实践(1)：原理与限制

据我观察，不管是初级新手仍是高级开发者都流行用 Spring Boot 构建本身的程序。Spring Boot “约定优于配置”的风格让你们在开发时能专一于业务逻辑。须要的时候，查阅 Spring Boot 教程就能够很方便地了解 Spring 的工做机制。尽管大多数时候只要添加几个注解就能够搞定，但有时候仍是须要了解它背后的运行机制，这样才能更专业地使用 Spring Boot。

本文将尝试介绍如何在 Spring 中进行异步处理。

异步处理适用那些与业务逻辑（横切关注点）不直接相关或者不做为其余业务逻辑输入的部分，也可在分布式系统中解耦。

*译注：横切关注点（cross-cutting concerns）指一些具备横越多个模块的行为，使用传统的软件开发方法不可以达到有效模块化的一类特殊关注点。*

Spring 中，`@Async`注解能够标记异步操做。然而，使用`@Async`时有一些限制，仅仅把它加在方法上并不能确保方法会在独立的线程中执行。若是你只是偶尔用到 `@Async`，须要格外小心。

1. @Async 的工做机制

首先为方法添加 `Async` 注解。接着，Spring 会基于 `proxyTargetClass` 属性，为包含 `Async` 定义的对象建立代理（JDK Proxy/CGlib）。最后，Spring 会尝试搜索与当前上下文相关的线程池，把该方法做为独立的执行路径提交。确切地说，Spring 会搜索惟一的 `TaskExecutor` bean 或者名为 `taskExecutor` 的 bean。若是找不到，则使用默认的 `SimpleAsyncTaskExecutor`。

要完成上面的过程，使用中须要注意几个限制，不然会出现 `Async` 不起做用的状况。

2. @Async 的限制

1. 必须在标记 `@ComponentScan` 或 `@configuration` 的类中使用 `@Async`。

2.1 在类中使用 Async 注解

```java
package com.example.ask2shamik.springAsync.demo;

import java.util.Map;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class AsyncMailTrigger {
    @Async
    public void senMail(Map<String,String> properties) {
        System.out.println("Trigger mail in a New Thread :: "  + Thread.currentThread().getName());
        properties.forEach((K,V)->System.out.println("Key::" + K + " Value ::" + V));
    }
}
```

2.2 Caller 类

```java
package com.example.ask2shamik.springAsync.demo;

import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class AsyncCaller {
    @Autowired
    AsyncMailTrigger asyncMailTriggerObject;

    public void rightWayToCall() {
        System.out.println("Calling From rightWayToCall Thread " + Thread.currentThread().getName());
        asyncMailTriggerObject.senMail(populateMap());
    }
    
    public void wrongWayToCall() {
        System.out.println("Calling From wrongWayToCall Thread " + Thread.currentThread().getName());
        AsyncMailTrigger asyncMailTriggerObject = new AsyncMailTrigger();
        asyncMailTriggerObject.senMail(populateMap());
    }

    private Map<String,String> populateMap(){
        Map<String,String> mailMap= new HashMap<String,String>();
        mailMap.put("body", "A Ask2Shamik Article");
        return mailMap;
    }
}
```

上面的例子中，使用了 `@Autowired` 的 `AsyncMailTrigger` 受 `@ComponentScan` 管理，于是会建立新线程执行。而 `WrongWayToCall` 方法中建立的局部对象，不受 `@ComponentScan` 管理，不会建立新线程。

 2.3 输出

```shell
Calling From rightWayToCall Thread main
2019-03-09 14:08:28.893  INFO 8468 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
Trigger mail in a New Thread :: task-1
Key::body Value ::A Ask2Shamik Article
++++++++++++++++
Calling From wrongWayToCall Thread main
Trigger mail in a New Thread :: main
Key::body Value ::A Ask2Shamik Article
```

2. 不要在 `private` 方法上使用 `@Async` 注解。因为在运行时不能建立代理，因此不起做用。

```java
@Async
private void senMail() {
    System.out.println("A proxy on Private method "  + Thread.currentThread().getName());
}
```

3. 调用 `methodAsync` 的 `caller` 方法与 `@Async` 方法应该在不一样的类中定义。不然，尽管建立了代理对象，但 `caller` 会绕过代理直接调用方法，不会建立新线程。

(https://dzone.com/storage/temp/11422746-springasync.jpg)

2.4 示例

```java
package com.example.ask2shamik.springAsync.demo;

import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class AsyncCaller {
    @Autowired
    AsyncMailTrigger asyncMailTriggerObject;

    public void rightWayToCall() {
        System.out.println("Calling From rightWayToCall Thread " + Thread.currentThread().getName());
        asyncMailTriggerObject.senMail(populateMap());
    }

    public void wrongWayToCall() {
        System.out.println("Calling From wrongWayToCall Thread " + Thread.currentThread().getName());
        this.senMail(populateMap());
    }

    private Map<String,String> populateMap(){
        Map<String,String> mailMap= new HashMap<String,String>();
        mailMap.put("body", "A Ask2Shamik Article");
        return mailMap;
    }

    @Async
    public void senMail(Map<String,String> properties) {
        System.out.println("Trigger mail in a New Thread :: "  + Thread.currentThread().getName());
        properties.forEach((K,V)->System.out.println("Key::" + K + " Value ::" + V));
    }
}
```

最后，在执行的时候应当使用 `@EnableAsync` 注解。它的做用是让 Spring 在后台线程池中提交 `@Async` 方法。要自定义 `Executor` 可本身实现 bean。在接下来的文章中会给出具体的示例。

```java
package com.example.ask2shamik.springAsync;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableAsync;
import com.example.ask2shamik.springAsync.demo.AsyncCaller;

@SpringBootApplication
@EnableAsync
public class DemoApplication {
    @Autowired
    AsyncCaller caller;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {
        caller.rightWayToCall();
        Thread.sleep(1000);
        System.out.println("++++++++++++++++");
        Thread.sleep(1000);
        caller.wrongWayToCall();
        };
    }
}
```

 3. 总结

但愿经过本文的讲解，能够帮助理解 Async 的内部机制及使用中的限制。下一篇会探讨 Async 中的异常处理。敬请期待！