Spring框架实战技巧 - @Async实现代码零入侵异步化改造

Spring 框架提供了一种简单的方式实现异步调用方法。通过@Async注解，将方法标记为异步，可以在不阻塞主线程的情况下执行代码。

本教程将介绍使用 Spring 框架的 @Async 注解实现方法异步调用的步骤，并通过 Person 类的例子来讲解如何在 Spring 框架中使用 @Async 注解。

启用和配置@Async#

步骤如下：

在pom.xml文件中添加Spring框架的依赖，以便使用@Async注解。

1
<dependency>
2
    <groupId>org.springframework</groupId>
3
    <artifactId>spring-context</artifactId>
4
    <version>5.0.8.RELEASE</version>
5
</dependency>

在 Spring 配置文件中开启异步调用。

在xml配置中：

1
<task:annotation-driven executor="asyncExecutor"/>
2
<task:executor id="asyncExecutor" pool-size="5"/>

在Java配置中：

1
@Configuration
2
@ComponentScan("com.example")
3
@EnableAsync
4
public class AppConfig implements AsyncConfigurer {
5

6
    @Override
7
    public Executor getAsyncExecutor() {
8
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
9
        executor.setCorePoolSize(5);
10
        executor.setMaxPoolSize(10);
11
        executor.setQueueCapacity(25);
12
        executor.setThreadNamePrefix("MyAsyncExecutor-");
13
        executor.initialize();
14
        return executor;
15
    }
16
}

在代码中使用@Async注解标记异步方法。

1
public class Person {
2
    @Async
3
    public void sayHello() {
4
        System.out.println("Hello from " + Thread.currentThread().getName() + "!");
5
    }
6
}

Person 类代码示例#

1
import org.springframework.scheduling.annotation.Async;
2
import org.springframework.stereotype.Component;
3

4
@Component
5
public class Person {
6
    @Async
7
    public void sayHello() {
8
        System.out.println("Hello from " + Thread.currentThread().getName() + "!");
9
    }
10
}

在代码中调用异步方法：

1
import org.springframework.context.ApplicationContext;
2
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
3

4
public class Main {
5
    public static void main(String[] args) {
6
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
7
        Person p = context.getBean(Person.class);
8
        p.sayHello();
9
        System.out.println("Main thread done!");
10
    }
11
}
12
// 输出结果：
13
// Main thread done!
14
// Hello from MyAsyncExecutor-1!

在 Person 类中，我们定义了一个异步方法 sayHello()，该方法在被调用时，会打印一条消息 “Hello from !”，其中替换为执行该方法的线程名称。

在 Main 类中，我们创建了一个 Spring 应用程序上下文，并获取了通过 AppConfig 类定义的 Person bean 的一个实例。我们调用了 Person bean 的 sayHello() 方法，然后打印一条消息“Main thread done!”（表示主线程已完成）。

因为我们在 sayHello() 方法上使用了 @Async 注解，因此该方法会在异步线程池中执行（即 MyAsyncExecutor-1）。

实战示例#

以下是一个使用@Async注解的示例代码，该示例演示了如何使用异步方法在后台计算一个数字序列的总和。代码分为三个部分：序列生成器、序列求和器和主应用程序。

序列生成器#

在这个例子中，我们将使用一个简单的生成器来生成一个数字序列。该生成器将接收一个起始值和一个结束值，并生成一个从起始值到结束值的数字序列。

1
@Component
2
public class NumberSequenceGenerator {
3
    public List<Integer> generate(int start, int end) {
4
        List<Integer> list = new ArrayList<Integer>();
5
        for (int i = start; i <= end; i++) {
6
            list.add(i);
7
        }
8
        return list;
9
    }
10
}

在这个例子中，我们定义了一个名为NumberSequenceGenerator的组件，它包含一个名为generate()的方法，该方法接收两个整数参数（start和end），并生成一个数字序列，其中第一个元素是start，最后一个元素是end。

序列求和器#

在这个例子中，我们将使用一个异步方法来计算数字序列的总和。该方法将接收一个数字序列，并计算该序列的总和。

1
@Service
2
public class SumCalculator {
3
    @Autowired
4
    private NumberSequenceGenerator generator;
5

6
    @Async
7
    public Future<Integer> calculateSumAsync(int start, int end) {
8
        List<Integer> list = generator.generate(start, end);
9
        int sum = 0;
10
        for (Integer i : list) {
11
            sum += i;
12
        }
13
        return new AsyncResult<Integer>(sum);
14
    }
15
}

在这个例子中，我们定义了一个名为SumCalculator的服务，它包含一个异步方法calculateSumAsync()，该方法接收两个整数参数（start和end），并计算从start到end的数字序列的总和。在方法的内部，我们使用NumberSequenceGenerator生成数字序列，并迭代该序列以计算总和。最后，我们将总和封装在一个Future对象中，并返回该对象以供调用者使用。

启动示例#

在这个例子中，我们将使用一个主应用程序来演示如何使用异步方法计算数字序列的总和。

1
public class MainApplication {
2
    public static void main(String[] args) throws Exception {
3
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
4
        SumCalculator calculator = context.getBean(SumCalculator.class);
5
        Future<Integer> future = calculator.calculateSumAsync(1, 1000);
6
        while (!future.isDone()) {
7
            System.out.println("异步方法正在执行...");
8
            Thread.sleep(1000);
9
        }
10
        System.out.println("异步方法返回值：" + future.get());
11
        context.close();
12
    }
13
}

在这个例子中，我们创建了一个Spring应用程序上下文，并从该上下文中获取SumCalculator服务。然后，我们使用calculateSumAsync()方法计算数字序列的总和，并使用while循环等待异步方法的结果。当异步方法执行完成后，我们将输出异步方法的返回值，并关闭Spring应用程序上下文。

总结#

使用 Spring 框架的 @Async 注解，可以轻松地实现方法异步调用。虽然示例代码很简单，但实际上，异步方法比较适用于涉及复杂或长时间运行的操作。在这种情况下，异步方法可以在后台执行，而不会阻塞主线程。如果你使用 Spring 框架开发 web 应用或其他需要异步处理的场景，那么学习使用 @Async 注解将非常有用。

音乐

音乐