Spring 异步方法入门：Java 与 Kotlin 完整示例

Java

package com.example.asyncmethod;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public record User(String name, String blog) {
}

Kotlin

package com.example.asyncmethod

import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties(ignoreUnknown = true)
data class User(val name: String?, val blog: String?)

Java

package com.example.asyncmethod;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

import java.util.concurrent.CompletableFuture;

@Service
public class GitHubLookupService {

	private static final Logger logger = LoggerFactory.getLogger(GitHubLookupService.class);

	private final RestClient restClient;

	public GitHubLookupService(RestClient.Builder restClientBuilder) {
		this.restClient = restClientBuilder.build();
	}

	@Async
	public CompletableFuture<User> findUser(String user) throws InterruptedException {
		logger.info("Looking up " + user);
		User results = restClient.get()
				.uri("https://api.github.com/users/{user}", user)
				.retrieve()
				.body(User.class);
		// Artificial delay of 1s for demonstration purposes
		Thread.sleep(1000L);
		return CompletableFuture.completedFuture(results);
	}
}

Kotlin

package com.example.asyncmethod

import org.slf4j.LoggerFactory
import org.springframework.scheduling.annotation.Async
import org.springframework.stereotype.Service
import org.springframework.web.client.RestClient
import org.springframework.web.client.requiredBody
import java.util.concurrent.CompletableFuture

@Service
class GitHubLookupService(restClientBuilder: RestClient.Builder) {

    private val logger = LoggerFactory.getLogger(javaClass)

    private val restClient = restClientBuilder.build()

    @Async
    fun findUser(user: String): CompletableFuture<User> {
        logger.info("Looking up $user")
        val results = restClient.get()
            .uri("https://api.github.com/users/{user}", user)
            .retrieve()
            .requiredBody<User>()
        // Artificial delay of 1s for demonstration purposes
        Thread.sleep(1000L)
        return CompletableFuture.completedFuture(results)
    }
}

Java

package com.example.asyncmethod;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@SpringBootApplication
@EnableAsync
public class AsyncMethodApplication {

	public static void main(String[] args) {
		// close the application context to shut down the custom ExecutorService
		SpringApplication.run(AsyncMethodApplication.class, args).close();
	}

	@Bean
	public Executor taskExecutor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setCorePoolSize(2);
		executor.setMaxPoolSize(2);
		executor.setQueueCapacity(500);
		executor.setThreadNamePrefix("GithubLookup-");
		executor.initialize();
		return executor;
	}
}

Kotlin

package com.example.asyncmethod

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Bean
import org.springframework.scheduling.annotation.EnableAsync
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
import java.util.concurrent.Executor

@SpringBootApplication
@EnableAsync
class AsyncMethodApplication {

    @Bean
    fun taskExecutor(): Executor = ThreadPoolTaskExecutor().apply {
        corePoolSize = 2
        maxPoolSize = 2
        queueCapacity = 500
        setThreadNamePrefix("GithubLookup-")
    }
}

fun main(args: Array<String>) {
    // close the application context to shut down the custom ExecutorService
    runApplication<AsyncMethodApplication>(*args).close()
}

Java

package com.example.asyncmethod;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
public class AppRunner implements CommandLineRunner {

	private static final Logger logger = LoggerFactory.getLogger(AppRunner.class);

	private final GitHubLookupService gitHubLookupService;

	public AppRunner(GitHubLookupService gitHubLookupService) {
		this.gitHubLookupService = gitHubLookupService;
	}

	@Override
	public void run(String... args) throws Exception {
		// Start the clock
		long start = System.currentTimeMillis();

		// Kick off multiple, asynchronous lookups
		CompletableFuture<User> page1 = gitHubLookupService.findUser("PivotalSoftware");
		CompletableFuture<User> page2 = gitHubLookupService.findUser("CloudFoundry");
		CompletableFuture<User> page3 = gitHubLookupService.findUser("Spring-Projects");

		// Wait until they are all done
		CompletableFuture.allOf(page1, page2, page3).join();

		// Print results, including elapsed time
		logger.info("Elapsed time: " + (System.currentTimeMillis() - start));
		logger.info("--> " + page1.get());
		logger.info("--> " + page2.get());
		logger.info("--> " + page3.get());

	}
}

Kotlin

package com.example.asyncmethod

import org.slf4j.LoggerFactory
import org.springframework.boot.CommandLineRunner
import org.springframework.stereotype.Component
import java.util.concurrent.CompletableFuture

@Component
class AppRunner(private val gitHubLookupService: GitHubLookupService) : CommandLineRunner {

    private val logger = LoggerFactory.getLogger(javaClass)

    override fun run(vararg args: String) {
        // Start the clock
        val start = System.currentTimeMillis()

        // Kick off multiple, asynchronous lookups
        val page1 = gitHubLookupService.findUser("PivotalSoftware")
        val page2 = gitHubLookupService.findUser("CloudFoundry")
        val page3 = gitHubLookupService.findUser("Spring-Projects")

        // Wait until they are all done
        CompletableFuture.allOf(page1, page2, page3).join()

        // Print results, including elapsed time
        logger.info("Elapsed time: ${System.currentTimeMillis() - start}")
        logger.info("--> ${page1.get()}")
        logger.info("--> ${page2.get()}")
        logger.info("--> ${page3.get()}")
    }
}

可以从命令行通过 Gradle 或 Maven 运行应用，也可以构建包含所有依赖、类和资源的单个可执行 JAR 再运行。可执行 JAR 使开发生命周期中跨环境的分发、版本管理和部署更方便。

使用 Gradle 时，可以通过 ./gradlew bootRun 运行应用。也可以先用 ./gradlew build 构建 JAR，再按以下方式运行：

使用 Maven 时，可以通过 ./mvnw spring-boot:run 运行应用。也可以先用 ./mvnw clean package 构建 JAR，再按以下方式运行：

应用日志会显示每次 GitHub 查询。通过 allOf 工厂方法创建一组 CompletableFuture 对象，再调用 join 方法，等待所有 CompletableFuture 完成。

下面是示例应用的典型输出，使用 Java 的 User record：

前两次调用在独立线程 GithubLookup-2 和 GithubLookup-1 中执行，第三次等待其中一个线程空闲。若想比较不启用异步时的耗时，可注释掉 @Async 再运行服务。由于每次查询至少花一秒，总耗时应明显增加。还可以调整 Executor，例如增加 corePoolSize。

原则上，任务耗时越长、同时调用的任务越多，异步带来的收益越明显。代价是必须处理 CompletableFuture：它增加了一层间接访问，因为你不再直接处理结果。