提升 Spring Boot 吞吐量的 7 个神技，让你的项目飞起来！ ...

一、异步执行

实现方式二种：

• 使用异步注解 @aysnc、启动类：添加 @EnableAsync 注解
  
• JDK 8 本身有一个非常好用的 Future 类——CompletableFuture
  

1. @AllArgsConstructor
2. public class AskThread implements Runnable{
3.     private CompletableFuture<Integer> re = null;
5.     public void run() {
6.         int myRe = 0;
7.         try {
8.             myRe = re.get() * re.get();
9.         } catch (Exception e) {
10.             e.printStackTrace();
11.         }
12.         System.out.println(myRe);
13.     }
15.     public static void main(String[] args) throws InterruptedException {
16.         final CompletableFuture<Integer> future = new CompletableFuture<>();
17.         new Thread(new AskThread(future)).start();
18.         //模拟长时间的计算过程
19.         Thread.sleep(1000);
20.         //告知完成结果
21.         future.complete(60);
22.     }
23. }

复制代码

在该示例中，启动一个线程，此时 AskThread 对象还没有拿到它需要的数据，执行到 myRe = re.get() * re.get() 会阻塞。
我们用休眠 1 秒来模拟一个长时间的计算过程，并将计算结果告诉 future 执行结果，AskThread 线程将会继续执行。

1. public class Calc {
2.     public static Integer calc(Integer para) {
3.         try {
4.             //模拟一个长时间的执行
5.             Thread.sleep(1000);
6.         } catch (InterruptedException e) {
7.             e.printStackTrace();
8.         }
9.         return para * para;
10.     }
12.     public static void main(String[] args) throws ExecutionException, InterruptedException {
13.         final CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> calc(50))
14.                 .thenApply((i) -> Integer.toString(i))
15.                 .thenApply((str) -> """ + str + """)
16.                 .thenAccept(System.out::println);
17.         future.get();
18.     }
19. }

复制代码

CompletableFuture.supplyAsync 方法构造一个 CompletableFuture 实例，在 supplyAsync() 方法中，它会在一个新线程中，执行传入的参数。
在这里它会执行 calc() 方法，这个方法可能是比较慢的，但这并不影响 CompletableFuture 实例的构造速度，supplyAsync() 会立即返回。
而返回的 CompletableFuture 实例就可以作为这次调用的契约，在将来任何场合，用于获得最终的计算结果。
supplyAsync 用于提供返回值的情况，CompletableFuture 还有一个不需要返回值的异步调用方法 runAsync(Runnable runnable)，一般我们在优化 Controller 时，使用这个方法比较多。
这两个方法如果在不指定线程池的情况下，都是在 ForkJoinPool.common 线程池中执行，而这个线程池中的所有线程都是 Daemon（守护）线程，所以，当主线程结束时，这些线程无论执行完毕都会退出系统。
核心代码：

1. CompletableFuture.runAsync(() ->
2.    this.afterBetProcessor(betRequest,betDetailResult,appUser,id)
3. );

复制代码

异步调用使用 Callable 来实现：

1. @RestController  
2. public class HelloController {
4.     private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
6.     @Autowired  
7.     private HelloService hello;
9.     @GetMapping("/helloworld")
10.     public String helloWorldController() {
11.         return hello.sayHello();
12.     }
14.     /**
15.      * 异步调用restful
16.      * 当controller返回值是Callable的时候，springmvc就会启动一个线程将Callable交给TaskExecutor去处理
17.      * 然后DispatcherServlet还有所有的spring拦截器都退出主线程，然后把response保持打开的状态
18.      * 当Callable执行结束之后，springmvc就会重新启动分配一个request请求，然后DispatcherServlet就重新
19.      * 调用和处理Callable异步执行的返回结果， 然后返回视图
20.      *
21.      * @return
22.      */  
23.     @GetMapping("/hello")
24.     public Callable<String> helloController() {
25.         logger.info(Thread.currentThread().getName() + " 进入helloController方法");
26.         Callable<String> callable = new Callable<String>() {
28.             @Override  
29.             public String call() throws Exception {
30.                 logger.info(Thread.currentThread().getName() + " 进入call方法");
31.                 String say = hello.sayHello();
32.                 logger.info(Thread.currentThread().getName() + " 从helloService方法返回");
33.                 return say;
34.             }
35.         };
36.         logger.info(Thread.currentThread().getName() + " 从helloController方法返回");
37.         return callable;
38.     }
39. }

复制代码

异步调用的方式 WebAsyncTask：

1. @RestController  
2. public class HelloController {
4.     private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
6.     @Autowired  
7.     private HelloService hello;
9.         /**
10.      * 带超时时间的异步请求 通过WebAsyncTask自定义客户端超时间
11.      *
12.      * @return
13.      */  
14.     @GetMapping("/world")
15.     public WebAsyncTask<String> worldController() {
16.         logger.info(Thread.currentThread().getName() + " 进入helloController方法");
18.         // 3s钟没返回，则认为超时
19.         WebAsyncTask<String> webAsyncTask = new WebAsyncTask<>(3000, new Callable<String>() {
21.             @Override  
22.             public String call() throws Exception {
23.                 logger.info(Thread.currentThread().getName() + " 进入call方法");
24.                 String say = hello.sayHello();
25.                 logger.info(Thread.currentThread().getName() + " 从helloService方法返回");
26.                 return say;
27.             }
28.         });
29.         logger.info(Thread.currentThread().getName() + " 从helloController方法返回");
31.         webAsyncTask.onCompletion(new Runnable() {
33.             @Override  
34.             public void run() {
35.                 logger.info(Thread.currentThread().getName() + " 执行完毕");
36.             }
37.         });
39.         webAsyncTask.onTimeout(new Callable<String>() {
41.             @Override  
42.             public String call() throws Exception {
43.                 logger.info(Thread.currentThread().getName() + " onTimeout");
44.                 // 超时的时候，直接抛异常，让外层统一处理超时异常
45.                 throw new TimeoutException("调用超时");
46.             }
47.         });
48.         return webAsyncTask;
49.     }
51.     /**
52.      * 异步调用，异常处理，详细的处理流程见MyExceptionHandler类
53.      *
54.      * @return
55.      */  
56.     @GetMapping("/exception")
57.     public WebAsyncTask<String> exceptionController() {
58.         logger.info(Thread.currentThread().getName() + " 进入helloController方法");
59.         Callable<String> callable = new Callable<String>() {
61.             @Override  
62.             public String call() throws Exception {
63.                 logger.info(Thread.currentThread().getName() + " 进入call方法");
64.                 throw new TimeoutException("调用超时!");
65.             }
66.         };
67.         logger.info(Thread.currentThread().getName() + " 从helloController方法返回");
68.         return new WebAsyncTask<>(20000, callable);
69.     }
71. }

复制代码

二、增加内嵌 Tomcat 的最大连接数


代码如下：

1. @Configuration
2. public class TomcatConfig {
3.     @Bean
4.     public ConfigurableServletWebServerFactory webServerFactory() {
5.         TomcatServletWebServerFactory tomcatFactory = new TomcatServletWebServerFactory();
6.         tomcatFactory.addConnectorCustomizers(new MyTomcatConnectorCustomizer());
7.         tomcatFactory.setPort(8005);
8.         tomcatFactory.setContextPath("/api-g");
9.         return tomcatFactory;
10.     }
11.     class MyTomcatConnectorCustomizer implements TomcatConnectorCustomizer {
12.         public void customize(Connector connector) {
13.             Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
14.             //设置最大连接数
15.             protocol.setMaxConnections(20000);
16.             //设置最大线程数
17.             protocol.setMaxThreads(2000);
18.             protocol.setConnectionTimeout(30000);
19.         }
20.     }
22. }

复制代码

使用 @ComponentScan()


三、使用 @ComponentScan() 定位扫包

使用 @ComponentScan() 定位扫包比 @SpringBootApplication 扫包更快。

四、默认 Tomcat 容器改为 Undertow

默认 Tomcat 容器改为 Undertow（Jboss 下的服务器，Tomcat 吞吐量 5000，Undertow 吞吐量 8000）

1. <exclusions>
2.   <exclusion>
3.      <groupId>org.springframework.boot</groupId>
4.      <artifactId>spring-boot-starter-tomcat</artifactId>
5.   </exclusion>
6. </exclusions>

复制代码

改为：

1. <dependency>
2.   <groupId>org.springframework.boot</groupId>
3.   <artifactId>spring-boot-starter-undertow</artifactId>
4. </dependency>

复制代码

Spring Boot 基础就不介绍了，推荐下这个实战教程：https://github.com/javastacks/spring-boot-best-practice
五、使用 BufferedWriter 进行缓冲

这里不给大家举例，可自行尝试。
六、Deferred 方式实现异步调用

代码如下：

1. @RestController
2. public class AsyncDeferredController {
3.     private final Logger logger = LoggerFactory.getLogger(this.getClass());
4.     private final LongTimeTask taskService;
6.     @Autowired
7.     public AsyncDeferredController(LongTimeTask taskService) {
8.         this.taskService = taskService;
9.     }
11.     @GetMapping("/deferred")
12.     public DeferredResult<String> executeSlowTask() {
13.         logger.info(Thread.currentThread().getName() + "进入executeSlowTask方法");
14.         DeferredResult<String> deferredResult = new DeferredResult<>();
15.         // 调用长时间执行任务
16.         taskService.execute(deferredResult);
17.         // 当长时间任务中使用deferred.setResult("world");这个方法时，会从长时间任务中返回，继续controller里面的流程
18.         logger.info(Thread.currentThread().getName() + "从executeSlowTask方法返回");
19.         // 超时的回调方法
20.         deferredResult.onTimeout(new Runnable(){
22.    @Override
23.    public void run() {
24.     logger.info(Thread.currentThread().getName() + " onTimeout");
25.     // 返回超时信息
26.     deferredResult.setErrorResult("time out!");
27.    }
28.   });
30.         // 处理完成的回调方法，无论是超时还是处理成功，都会进入这个回调方法
31.         deferredResult.onCompletion(new Runnable(){
33.    @Override
34.    public void run() {
35.     logger.info(Thread.currentThread().getName() + " onCompletion");
36.    }
37.   });
39.         return deferredResult;
40.     }
41. }

复制代码

七、异步调用可以使用 AsyncHandlerInterceptor 进行拦截



代码如下：

1. @Component
2. public class MyAsyncHandlerInterceptor implements AsyncHandlerInterceptor {
4. private static final Logger logger = LoggerFactory.getLogger(MyAsyncHandlerInterceptor.class);
6. @Override
7. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
8.    throws Exception {
9.   return true;
10. }
12. @Override
13. public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
14.    ModelAndView modelAndView) throws Exception {
15. // HandlerMethod handlerMethod = (HandlerMethod) handler;
16.   logger.info(Thread.currentThread().getName()+ "服务调用完成，返回结果给客户端");
17. }
19. @Override
20. public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
21.    throws Exception {
22.   if(null != ex){
23.    System.out.println("发生异常:"+ex.getMessage());
24.   }
25. }
27. @Override
28. public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler)
29.    throws Exception {
31.   // 拦截之后，重新写回数据，将原来的hello world换成如下字符串
32.   String resp = "my name is chhliu!";
33.   response.setContentLength(resp.length());
34.   response.getOutputStream().write(resp.getBytes());
36.   logger.info(Thread.currentThread().getName() + " 进入afterConcurrentHandlingStarted方法");
37. }
39. }

复制代码

参考资料：

• https://my.oschina.net/u/3768341/blog/3001731
  
• https://blog.csdn.net/liuchuanhong1/article/details/78744138
  

版权声明：本文为CSDN博主「灬点点」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/qq_32447301/article/details/88046026

近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！