Spring Boot异步编程详解

原创 已于 2025-10-15 09:12:38 修改 · 542 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #java #后端

于 2025-10-14 08:30:29 首次发布

文章目录

1. 异步编程概述

异步编程是提高应用性能的重要手段，通过异步处理可以避免阻塞主线程，提高系统的并发处理能力。Spring Boot提供了完整的异步编程解决方案。

1.1 异步编程优势

  • 提高并发性：避免线程阻塞，提高系统吞吐量
  • 改善用户体验：快速响应用户请求
  • 资源利用率：更好地利用系统资源
  • 可扩展性：支持高并发场景

1.2 异步编程模式

  • 回调模式：基于回调函数的异步处理
  • Future模式：基于Future的异步结果获取
  • CompletableFuture模式：基于CompletableFuture的链式异步处理
  • 响应式编程：基于Reactive Streams的响应式处理

1.3 核心依赖

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Async -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    
    <!-- Spring WebFlux -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    
    <!-- Reactor Core -->
    <dependency>
        <groupId>io.projectreactor</groupId>
        <artifactId>reactor-core</artifactId>
    </dependency>
</dependencies>

2. @Async注解

2.1 基础异步方法

package com.example.demo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;

@Service
public class AsyncService {
    
    // 无返回值异步方法
    @Async
    public void asyncMethod() {
        System.out.println("异步方法执行: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("异步方法完成: " + Thread.currentThread().getName());
    }
    
    // 有返回值异步方法
    @Async
    public CompletableFuture<String> asyncMethodWithReturn() {
        System.out.println("异步方法执行: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("异步方法结果");
    }
    
    // 基于Future的异步方法
    @Async
    public Future<String> asyncMethodWithFuture() {
        System.out.println("异步方法执行: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new AsyncResult<>("异步方法结果");
    }
}

2.2 异步配置

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("Async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
    
    @Bean(name = "asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

2.3 异步异常处理

package com.example.demo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncExceptionService {
    
    @Async
    public CompletableFuture<String> asyncMethodWithException() {
        System.out.println("异步方法执行: " + Thread.currentThread().getName());
        
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        // 模拟异常
        if (Math.random() > 0.5) {
            throw new RuntimeException("异步方法异常");
        }
        
        return CompletableFuture.completedFuture("异步方法成功");
    }
    
    @Async
    public CompletableFuture<String> asyncMethodWithTryCatch() {
        try {
            System.out.println("异步方法执行: " + Thread.currentThread().getName());
            Thread.sleep(1000);
            
            if (Math.random() > 0.5) {
                throw new RuntimeException("异步方法异常");
            }
            
            return CompletableFuture.completedFuture("异步方法成功");
        } catch (Exception e) {
            System.err.println("异步方法异常: " + e.getMessage());
            return CompletableFuture.completedFuture("异步方法失败");
        }
    }
}

3. CompletableFuture

3.1 基础CompletableFuture

package com.example.demo.service;

import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

@Service
public class CompletableFutureService {
    
    private final Executor executor = Executors.newFixedThreadPool(5);
    
    // 创建CompletableFuture
    public CompletableFuture<String> createCompletableFuture() {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("CompletableFuture执行: " + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "CompletableFuture结果";
        }, executor);
    }
    
    // 链式处理
    public CompletableFuture<String> chainCompletableFuture() {
        return CompletableFuture
                .supplyAsync(() -> "Hello", executor)
                .thenApply(s -> s + " World")
                .thenApply(s -> s + "!")
                .thenApply(String::toUpperCase);
    }
    
    // 异常处理
    public CompletableFuture<String> handleException() {
        return CompletableFuture
                .supplyAsync(() -> {
                    if (Math.random() > 0.5) {
                        throw new RuntimeException("随机异常");
                    }
                    return "成功结果";
                }, executor)
                .handle((result, throwable) -> {
                    if (throwable != null) {
                        return "异常处理: " + throwable.getMessage();
                    }
                    return result;
                });
    }
}

3.2 组合CompletableFuture

package com.example.demo.service;

import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

@Service
public class CompletableFutureCombineService {
    
    private final Executor executor = Executors.newFixedThreadPool(5);
    
    // 组合两个CompletableFuture
    public CompletableFuture<String> combineTwoFutures() {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果1";
        }, executor);
        
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果2";
        }, executor);
        
        return future1.thenCombine(future2, (result1, result2) -> 
            "组合结果: " + result1 + " + " + result2);
    }
    
    // 等待所有CompletableFuture完成
    public CompletableFuture<String> waitForAllFutures() {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果1";
        }, executor);
        
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果2";
        }, executor);
        
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果3";
        }, executor);
        
        return CompletableFuture.allOf(future1, future2, future3)
                .thenApply(v -> "所有任务完成: " + future1.join() + ", " + future2.join() + ", " + future3.join());
    }
    
    // 等待任意一个CompletableFuture完成
    public CompletableFuture<String> waitForAnyFuture() {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果1";
        }, executor);
        
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "结果2";
        }, executor);
        
        return CompletableFuture.anyOf(future1, future2)
                .thenApply(result -> "任意一个任务完成: " + result);
    }
}

4. 响应式编程

4.1 WebFlux基础

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    // 获取单个用户
    @GetMapping("/{id}")
    public Mono<User> getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    // 获取所有用户
    @GetMapping
    public Flux<User> getAllUsers() {
        return userService.findAll();
    }
    
    // 创建用户
    @PostMapping
    public Mono<User> createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    // 更新用户
    @PutMapping("/{id}")
    public Mono<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.update(id, user);
    }
    
    // 删除用户
    @DeleteMapping("/{id}")
    public Mono<Void> deleteUser(@PathVariable Long id) {
        return userService.deleteById(id);
    }
}

4.2 响应式服务

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    // 查找单个用户
    public Mono<User> findById(Long id) {
        return Mono.fromCallable(() -> userRepository.findById(id).orElse(null))
                .subscribeOn(Schedulers.boundedElastic());
    }
    
    // 查找所有用户
    public Flux<User> findAll() {
        return Flux.fromIterable(userRepository.findAll())
                .subscribeOn(Schedulers.boundedElastic());
    }
    
    // 保存用户
    public Mono<User> save(User user) {
        return Mono.fromCallable(() -> userRepository.save(user))
                .subscribeOn(Schedulers.boundedElastic());
    }
    
    // 更新用户
    public Mono<User> update(Long id, User user) {
        return Mono.fromCallable(() -> {
            user.setId(id);
            return userRepository.save(user);
        }).subscribeOn(Schedulers.boundedElastic());
    }
    
    // 删除用户
    public Mono<Void> deleteById(Long id) {
        return Mono.fromRunnable(() -> userRepository.deleteById(id))
                .subscribeOn(Schedulers.boundedElastic())
                .then();
    }
}

4.3 响应式流处理

package com.example.demo.service;

import com.example.demo.entity.User;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import java.time.Duration;
import java.util.List;

@Service
public class ReactiveStreamService {
    
    // 流式处理
    public Flux<String> processStream() {
        return Flux.range(1, 10)
                .map(i -> "处理数据: " + i)
                .delayElements(Duration.ofMillis(100))
                .subscribeOn(Schedulers.parallel());
    }
    
    // 背压处理
    public Flux<String> handleBackpressure() {
        return Flux.range(1, 1000)
                .map(i -> "数据: " + i)
                .onBackpressureBuffer(100) // 缓冲100个元素
                .subscribeOn(Schedulers.parallel());
    }
    
    // 错误处理
    public Flux<String> handleErrors() {
        return Flux.range(1, 10)
                .map(i -> {
                    if (i == 5) {
                        throw new RuntimeException("处理异常");
                    }
                    return "数据: " + i;
                })
                .onErrorResume(throwable -> Flux.just("错误处理: " + throwable.getMessage()))
                .subscribeOn(Schedulers.parallel());
    }
    
    // 超时处理
    public Mono<String> handleTimeout() {
        return Mono.fromCallable(() -> {
            Thread.sleep(2000);
            return "处理完成";
        })
        .timeout(Duration.ofSeconds(1))
        .onErrorReturn("处理超时")
        .subscribeOn(Schedulers.boundedElastic());
    }
}

5. 异步任务调度

5.1 定时任务

package com.example.demo.service;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Service
public class ScheduledService {
    
    // 固定延迟执行
    @Scheduled(fixedDelay = 5000)
    public void fixedDelayTask() {
        System.out.println("固定延迟任务执行: " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
    }
    
    // 固定频率执行
    @Scheduled(fixedRate = 3000)
    public void fixedRateTask() {
        System.out.println("固定频率任务执行: " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
    }
    
    // Cron表达式执行
    @Scheduled(cron = "0 0 12 * * ?")
    public void cronTask() {
        System.out.println("Cron任务执行: " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
    }
    
    // 初始延迟执行
    @Scheduled(initialDelay = 10000, fixedRate = 5000)
    public void initialDelayTask() {
        System.out.println("初始延迟任务执行: " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
    }
}

5.2 任务调度配置

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.concurrent.Executor;

@Configuration
@EnableScheduling
public class SchedulingConfig {
    
    @Bean
    public Executor taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5);
        scheduler.setThreadNamePrefix("Scheduled-");
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        scheduler.setAwaitTerminationSeconds(60);
        scheduler.initialize();
        return scheduler;
    }
}

6. 异步消息处理

6.1 消息队列异步处理

package com.example.demo.service;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncMessageService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    // 发送异步消息
    public void sendAsyncMessage(String message) {
        CompletableFuture.runAsync(() -> {
            rabbitTemplate.convertAndSend("async.exchange", "async.routing.key", message);
        });
    }
    
    // 异步处理消息
    @RabbitListener(queues = "async.queue")
    public void handleAsyncMessage(String message) {
        System.out.println("异步处理消息: " + message);
        
        // 模拟异步处理
        CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("消息处理完成: " + message);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
}

6.2 事件驱动异步处理

package com.example.demo.service;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class EventDrivenAsyncService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    // 发布异步事件
    public void publishAsyncEvent(String data) {
        AsyncEvent event = new AsyncEvent(this, data);
        eventPublisher.publishEvent(event);
    }
    
    // 异步处理事件
    @EventListener
    @Async
    public CompletableFuture<Void> handleAsyncEvent(AsyncEvent event) {
        System.out.println("异步处理事件: " + event.getData());
        
        try {
            Thread.sleep(2000);
            System.out.println("事件处理完成: " + event.getData());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return CompletableFuture.completedFuture(null);
    }
    
    // 事件类
    public static class AsyncEvent {
        private final Object source;
        private final String data;
        
        public AsyncEvent(Object source, String data) {
            this.source = source;
            this.data = data;
        }
        
        public Object getSource() { return source; }
        public String getData() { return data; }
    }
}

7. 异步性能优化

7.1 线程池优化

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
@EnableAsync
public class AsyncPerformanceConfig {
    
    @Bean(name = "asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(200);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("Async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        executor.initialize();
        return executor;
    }
    
    @Bean(name = "ioExecutor")
    public Executor ioExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(20);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(500);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("IO-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

7.2 异步监控

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ThreadPoolExecutor;

@Service
public class AsyncMonitorService {
    
    @Autowired
    private ThreadPoolTaskExecutor asyncExecutor;
    
    public Map<String, Object> getAsyncStats() {
        Map<String, Object> stats = new HashMap<>();
        
        ThreadPoolExecutor executor = asyncExecutor.getThreadPoolExecutor();
        
        stats.put("corePoolSize", executor.getCorePoolSize());
        stats.put("maximumPoolSize", executor.getMaximumPoolSize());
        stats.put("activeCount", executor.getActiveCount());
        stats.put("completedTaskCount", executor.getCompletedTaskCount());
        stats.put("taskCount", executor.getTaskCount());
        stats.put("queueSize", executor.getQueue().size());
        
        return stats;
    }
}

8. 异步最佳实践

8.1 异步方法设计

package com.example.demo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

@Service
public class AsyncBestPracticeService {
    
    // 异步方法应该返回CompletableFuture
    @Async
    public CompletableFuture<String> asyncMethodWithReturn() {
        try {
            // 模拟异步处理
            Thread.sleep(1000);
            return CompletableFuture.completedFuture("异步处理完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.failedFuture(e);
        }
    }
    
    // 异步方法应该处理异常
    @Async
    public CompletableFuture<String> asyncMethodWithExceptionHandling() {
        try {
            // 模拟可能失败的操作
            if (Math.random() > 0.5) {
                throw new RuntimeException("随机失败");
            }
            Thread.sleep(1000);
            return CompletableFuture.completedFuture("异步处理成功");
        } catch (Exception e) {
            return CompletableFuture.failedFuture(e);
        }
    }
    
    // 异步方法应该设置超时
    @Async
    public CompletableFuture<String> asyncMethodWithTimeout() {
        return CompletableFuture
                .supplyAsync(() -> {
                    try {
                        Thread.sleep(2000);
                        return "异步处理完成";
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException(e);
                    }
                })
                .orTimeout(1, TimeUnit.SECONDS)
                .exceptionally(throwable -> "异步处理超时");
    }
}

8.2 异步配置最佳实践

# application.yml
spring:
  task:
    execution:
      pool:
        core-size: 10
        max-size: 20
        queue-capacity: 200
        keep-alive: 60s
      thread-name-prefix: "Async-"
    scheduling:
      pool:
        size: 5
      thread-name-prefix: "Scheduled-"

# 异步监控
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,threaddump
  metrics:
    export:
      prometheus:
        enabled: true

9. 总结

Spring Boot异步编程提供了完整的异步处理解决方案：

  1. @Async注解：简单的异步方法声明
  2. CompletableFuture：强大的异步编程工具
  3. 响应式编程：基于Reactive Streams的响应式处理
  4. 任务调度：定时任务和异步任务调度
  5. 消息处理：异步消息队列处理
  6. 性能优化：线程池配置和性能监控
  7. 最佳实践：异步方法设计和配置优化

通过合理使用这些异步编程技术，可以构建出高性能、高并发的Spring Boot应用。

《滚雪球学Spring Boot》教程导航帖（更新于2025.05.20）
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由优快云博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如优快云、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
Java 原生异步编程与Spring 异步编程 详解
tangPHP的博客
05-11 1077
Java异步编程是现代高性能应用开发的核心技术之一，它允许程序在执行耗时操作（如网络请求、文件IO）时不必阻塞主线程，从而提高系统吞吐量和响应性。// 核心线程数// 最大线程数// 队列容量// 空闲线程存活时间// 指定线程池return "线程池中的任务";}, pool);├─ 创建任务│ ├─ runAsync() -> 无返回值│ └─ supplyAsync() -> 有返回值├─ 处理结果│ ├─ thenApply() -> 转换。
Spring Boot 异步执行机制详解
nwiymo_786的博客
10-24 179
Spring Boot 异步执行机制详解
Spring Boot详解
这河里吗l的博客
06-28 6093
Spring Boot是由Pivotal团队提供的全新框架，其中“Boot”的意思就是“引导”，Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速开发 Spring应用的方式。目录：SpringBoot入门，SpringBoot入门HelloWorld，SpringBoot的全局配置文件，SpringBoot异常处理，SpringBoot整合Junit、MyBatis、转换器、拦截器、logback日志记录器，Spring Boot部署
Spring Boot 异步处理全面详解：从基础到高级应用
嗨，欢迎来到我的 优快云 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
10-16 7671
Spring Boot 异步处理全面详解：从基础到高级应用
Spring Boot注解详解
hello！
07-21 2007
本文系统梳理了Spring Boot核心注解及其使用场景，主要包含以下内容：1. 核心启动注解如@SpringBootApplication、@EnableAutoConfiguration；2. 组件注解如@Component、@Service等分层组件标识；3. 依赖注入相关注解如@Autowired、@Qualifier等实现自动装配；4. Web开发相关注解包括请求映射、参数绑定等。这些注解极大简化了Spring应用的开发，通过声明式配置替代繁琐的XML配置，是Spring Boot自动配置和快速开
Spring Boot 异步任务执行机制详解
ycobra_161的博客
10-24 341
Spring Boot 异步任务执行机制详解
Spring Boot监听机制详解
qq_43947876的博客
06-16 1085
Spring Boot监听机制基于观察者模式，通过事件驱动实现应用生命周期的精细化管理。其核心组件包括事件（ApplicationEvent）、监听器（ApplicationListener）和事件发布者（ApplicationEventPublisher）。系统提供多种内置生命周期事件（如启动、环境准备、上下文初始化等），支持自定义事件和异步处理。典型应用场景包括：资源初始化、环境校验、优雅停机和业务解耦。开发者可通过注解或编程方式注册监听器，实现启动时预热缓存、校验配置、停机释放资源等功能。
Spring Boot事件机制详解
AWen_Jack的博客
03-24 1740
事件驱动架构(Event-Driven Architecture, EDA)是一种软件设计模式，其中系统组件通过事件的发布与订阅进行通信。在Spring Boot中，事件机制为应用程序提供了松耦合的组件间通信方式，使得发布者无需关心谁在监听，监听者也无需了解事件来源
Spring Boot 拦截器详解
BUG糕手的博客
08-15 1498
Spring Boot拦截器核心用法与实践 摘要：本文详细介绍了Spring Boot拦截器的核心概念和应用场景。拦截器常用于登录校验、权限控制、日志记录等，通过preHandle、postHandle和afterCompletion三个方法实现请求处理全周期控制。文章通过登录拦截器实例，展示了如何拦截API请求、校验Token及返回401状态码。与过滤器相比，拦截器仅针对Controller请求，且能直接使用Spring依赖注入。高级用法部分演示了利用拦截器记录接口性能的方法。
详解Spring/Spring boot异步任务编程WebAsyncTask
08-27
Spring/Spring Boot 异步任务编程 WebAsyncTask 本文主要介绍了 Spring/Spring Boot 中的异步任务编程，使用 WebAsyncTask 实现异步任务的执行。首先，我们需要了解异步处理的概念。异步处理主要是让服务器处理请求...
Spring Boot异步任务实现Demo详解
### Spring Boot 使用@Async注解实现异步任务知识点详解 #### 异步编程概念 在软件开发中，异步编程是一种执行代码的方式，它允许程序的一部分独立于主程序继续执行。在异步执行模式下，程序的流程不会被阻塞，...
Spring/Spring Boot异步任务实战：WebAsyncTask详解
"本文主要探讨了Spring和Spring Boot框架中的异步任务编程，重点介绍了如何使用WebAsyncTask来实现这一功能。文中通过实例讲解了异步处理的概念和其在提高并发处理能力上的重要性，并区分了处理线程与异步线程的区别...
Java 服务端异步编程详解：深入理解 Spring MVC 中的 Callable 异步请求
全栈工程师，热爱编程，喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得，以及在项目开发中的实践经验。
07-22 1340
在 Spring MVC 中，Callable 是一种简便的异步请求处理方式。通过 Callable，开发者可以在新的线程中执行耗时操作，而不会阻塞处理请求的主线程。Spring MVC 会自动管理异步请求的生命周期，并将结果返回给客户端。Spring MVC 中的 Callable 异步请求提供了一种简单而高效的异步处理方式，可以显著提高系统的并发处理能力和响应速度。通过具体的示例代码，我们展示了如何使用 Callable 实现异步请求处理，并分析了其优势和适用场景。
Spring Boot 使用FastExcel实现多级表头动态数据填充导出
shitou的博客
12-19 244
本文介绍了使用FastExcel库实现动态表头Excel导出的方法。主要包括：1）通过Maven引入FastExcel依赖；2）定义动态表头实体类，使用注解配置表头样式、列宽等属性；3）实现自定义表头处理器(CellWriteHandler)，动态替换表头中的占位符变量；4）提供导出工具类，支持按指标类型生成包含年度和月度数据的多Sheet Excel文件。该方法通过注解和处理器机制，实现了灵活的表头定制和动态数据填充功能。
深入Spring Boot源码（六）：Actuator端点与监控机制深度解析
qq_45110186的博客
12-17 822
本文深入解析了SpringBoot Actuator模块的内部机制，重点介绍了其核心功能实现原理。内容涵盖：1）Actuator架构设计理念与模块组成；2）端点抽象体系及自动配置机制；3）健康检查的分层设计与内置指示器实现；4）指标收集与Micrometer集成；5）信息端点实现与构建信息暴露；6）端点安全控制策略；7）自定义端点开发全流程。文章还提供了生产环境配置建议和测试策略，帮助开发者全面掌握Actuator的监控能力，为应用运维提供有力支持。
国家电网Java面试被问：Spring Boot Starter 制作原理
最新发布
xh2277659985的博客
12-22 808
SpringBoot Starter通过自动配置简化依赖管理，其核心原理包含：1) 依赖集合包结构，2) 自动配置类通过条件注解(@ConditionalOnClass等)实现按需加载，3) 配置文件绑定属性。制作步骤包括：定义配置属性类、创建自动配置类、注册到META-INF/spring.factories或AutoConfiguration.imports文件。最佳实践建议遵循命名规范、提供默认配置并确保向后兼容。该机制在启动时自动扫描配置，根据条件评估创建Bean，实现智能组件装配。
SpringBoot--Spring Boot原生缓存基于Redis的Cacheable注解使用
2301_77287584的博客
12-22 342
Spring Boot通过注解简化Redis缓存使用，提供声明式缓存管理方案。配置包括添加依赖、Redis连接设置和序列化配置。主要使用@Cacheable实现缓存查询（检查缓存存在性，不存在则执行方法并缓存结果）和@CacheEvict实现缓存清除（可针对单个键或全部缓存）。还支持自定义TTL管理，通过扩展RedisCacheManager实现不同缓存的不同过期时间设置。这套方案使开发者能快速集成Redis缓存，通过简单注解实现高效的缓存管理。
Spring Boot 深度解析：核心原理与自动配置全解
技术分析
12-17 665
摘要：本文深入解析SpringBoot自动配置机制，从核心概念、实现原理到自定义扩展三个维度展开。自动配置通过@EnableAutoConfiguration注解触发，依赖AutoConfigurationImportSelector加载配置类，结合条件注解(@ConditionalOnClass等)控制生效时机，实现"约定优于配置"。文章详细剖析了自动配置流程、优先级规则(自定义配置>自动配置)，并给出自定义Starter的完整实现方案，包括配置属性类、自动配置类编写及注册方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小凯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值