1、什么是Records

record是一种特殊类型的类声明，目的是为了减少样板代码。record引入的主要目的是快速创建数据载体类。

这种类的主要目的就是在不同的模块或者层之间包含并传递数据，它们表现为POJO（Plain Old Java Objects）和DTO（Data Transfer Objects）。

record声明有专门的的关键字record，我们比较下一个简单的POJO类和record上语法的区别：

POJO类：

@Data
public class Point {
    private String x;
    private String y;
}

record：

public record Point(String x, String y) {
}

我们创建一个简单的演示项目，依赖如图所示：

使用record替代普通DTO

我们在Spring MVC的控制器中可以用一个record的DTO来接受前端传递来的数据：

@RestController
@RequestMapping("/people")
public class PersonController {

    private final PersonService personService;

    public PersonController(PersonService personService) {
        this.personService = personService;
    }

    @PostMapping
    public ResponseEntity<Person> save(@RequestBody PersonDto personDto){
        return ResponseEntity.ok(personService.save(personDto));
    }

    @GetMapping("/findByLastName")
    public ResponseEntity<List<PersonOnlyWithName>> findByLastName(String lastName){
        return ResponseEntity.ok(personService.findByLastName(lastName));
    }
}

上面的PersonDto是一个record：

public record PersonDto(String firstName, String lastName,Integer age) {
}

3、使用record作为Spring的Bean

上面注入的PersonService，是一个Spring的Bean，它同样可以是一个record，我们只需要在record的参数里写上要被注入的bean，这个bean就会自动被注入：

@Service
public record PersonService(PersonRepository personRepository) {

  //保存person
    public Person save(PersonDto personDto){
        Person person = new Person(personDto.firstName(), personDto.lastName(), personDto.age());
        return personRepository.save(person);
    }

  //按照lastName查询people，返回值只有firstName和lastName
    public List<PersonOnlyWithName> findByLastName(String lastName){
        return personRepository.findByLastName(lastName);
    }
}

在这里的PersonRepository的bean可以自动被注入，代码上比属性@Autowired注入，甚至构造器注入代码更简洁。

Spring Data JPA用作数据访问的Repository：

public interface PersonRepository extends JpaRepository<Person, Long> {

    List<PersonOnlyWithName> findByLastName(String lastName);
}

使用record来声明bean，有一些潜在的问题：

1、record中，被注入的对象在当前对象里其实是有一个隐藏的get方法：“ personService.personRepository()”，这违反了信息隐藏的封装原则。

2、record定义了equals和hasCode方法，作为service并不需要。

3、service的变量属性一般都是final。

如果上述的东西对你并没有什么影响，你可以自由决定是否使用。

3、使用record作为Spring Data JPA的projection

Spring Data JPA的projection目的是定制查询的数据返回，而不是返回整个实体。一般情况下都是使用接口或者dto类，现在支持使用record。

定制的返回的record内容为：

public record PersonOnlyWithName(String firstName, String lastName) {
}

即我们查询返回的结果，不需要id和age，只需要firstName和lastName。

4、演示应用

启动程序，保存Person，插入两条数据：

按照lastName查询，查看我们projection的效果：

用record改造Controller控制器

在上面我们的Controller用的还是普通的class，既然record可以声明为bean并注入bean，那我们改造一下上面的Controller。

@RestController
@RequestMapping("/people")
public record PersonController(PersonService personService) {

    @PostMapping
    public ResponseEntity<Person> save(@RequestBody PersonDto personDto){
        return ResponseEntity.ok(personService.save(personDto));
    }

    @GetMapping("/findByLastName")
    public ResponseEntity<List<PersonOnlyWithName>> findByLastName(String lastName){
        return ResponseEntity.ok(personService.findByLastName(lastName));
    }
}

代码比构造器注入更精简。

感谢对我的书《从企业级开发到云原生微服务：Spring Boot实战》的支持。

头条原文地址：https://www.toutiao.com/article/7161419177252127239

本文介绍Spring Boot 2.6对Java 17支持的一个新特性，使用Java 17的Record来做为Spring Boot的配置属性（ConfiguartionProperties）。

什么是Record

record是一种特殊类型的类声明，目的是为了减少样板代码。record引入的主要目的是快速创建数据载体类。

这种类的主要目的就是在不同的模块或者层之间包含并传递数据，它们表现为POJO（Plain Old Java Objects）和DTO（Data Transfer Objects）。

record声明有专门的的关键字record，我们比较下一个简单的POJO类和record上语法的区别：

POJO类：

@Data
public class Point {
    private String x;
    private String y;
}

record：

public record Point(String x, String y) {
}

Spring Boot的配置属性（Configuration Properties）类也是一个简单POJO。

用POJO类作为Configuration Properties

• 新建演示项目，注意添加Spring Configuration Processor

• 演示的Configuration Properties，首先我们使用常规的Java类来演示

@ConfigurationProperties(prefix = "author")
@Data
public class AuthorProperties {
    private String firstName;
    private String lastName;
}

• application.properties 中的配置

author.firstName=wang
author.lastName=yunfei

• 注册Configuration Properties为Bean，并使用

@SpringBootApplication
@EnableConfigurationProperties(AuthorProperties.class)//将AuthorProperties注册为Bean
@Slf4j
public class RecordConfigurationPropertiesApplication {

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

   @Bean //注入并使用AuthorProperties的Bean
   CommandLineRunner commandLineRunner(AuthorProperties authorProperties){
      return args -> {
         log.info(authorProperties.toString());
      };
   }
}

• 运行程序

用Record作为Configuration Properties

我们只需要将AuthorProperties类修改为record即可：

@ConfigurationProperties(prefix = "author")
public record AuthorProperties(String firstName, String lastName) {
}

运行结果和上面保持一致。

感谢对我的书《从企业级开发到云原生微服务：Spring Boot实战》的支持。

头条原文地址：https://www.toutiao.com/article/7159057842337530371/

本文期望通过以下的讲述，帮助你快速轻松的使用Gradle加速您的Spring Boot开发应用。

1、Gradle越来越流行

2012年开始，Spring框架已全部使用Gradle来构建；2020年开始，Spring Boot也全部采用Gradle来构建。官方使用Gradle的主要原因还是“构建项目花费更少的时间”。（可参考：Spring/Spring Boot编译工具从Maven迁移到了Gradle）

但对于我们普通的应用开发者来说，Gradle对于我们的优势在于：更简洁的代码和更丰富的功能。（可参考：Gradle大战Maven，胜负已分？）

最近的一些统计报告，越来越显示出Gradle有越来越多的人在使用它。

• stackoverflow的趋势报告

• OpenLogic发布的《2022年度开源报告》

最近有出了一个振奋人心的消息是，Spring官方生成应用程序的网站：spring initializr（https://start.spring.io/），也将默认的构建工具从Maven切换到了Gradle。

综合上述种种，我觉得有必要了解一下快速易用的Gradle了。

2、了解Spring Boot项目的结构

• 打开:https://start.spring.io，生成演示项目，项目构建工具选中的默认的Gradle。

• 点击“GENERATE”生成项目压缩包，解压这个压缩包，项目的结构如下：

和Gradle有关系的有：settings.gralde 、gradle wrapper[gradle/wrapper 目录、gradlew （gradlew.bat ）]、build.gradle 。下面我们逐一的了解。

2.1 settings.gradle

本文件配置构建项目所需要的信息，Spring Boot项目的该文件内容很简单：

rootProject.name = 'gradle-demo'

2.2 gradle wrapper

我们通过使用gradle wrapper脚本，可以直接下载、配置gradle，无需外部安装配置gradle。这样也可以为你的当前程序匹配最合适版本的Gradle版本。

可以直接通过gradle wrapper脚本对程序进行编译、打包、测试、部署和发布等任务操作。

针对Linux/MacOS的gradle wrapper是gradlew ；

针对Windows的gradler wrapper是gradlew.bat 。

2.3 如何加速gradle下载

gradle wrapper会自动下载gradle，若默认的下载gradle的url网速很慢，可以替换成阿里云或腾讯云的地址。当然可以是你公司内部的文件下载地址。

我们在 gradle/wrapper/gradle-wrapper.properties 的distributionUrl 类配置：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

若使用阿里云的地址加速（列表页面： https://mirrors.aliyun.com/macports/distfiles/gradle/）：

distributionUrl=https\://mirrors.aliyun.com/macports/distfiles/gradle/gradle-7.5.1-bin.zip

若使用腾讯云地址加速，可在页面： https://mirrors.cloud.tencent.com/gradle/查找。

2.4 build.gradle

build.gradle 相当于Maven的pom.xml，不过它比Maven要简介很多，如同样的项目，如果用Maven生成的代码对比的话：

xml是一门很清晰但是却很啰嗦的表意语言，在Java生态里使用的越来越少，在Spring Boot的开发中几乎没有任何和xml有关系的内容。由图中的对比也可以看出Gradle比Maven易读性更强且更易维护！

build.gradle的核心内容包括：plugins（插件）、库（repositories）、依赖（dependecies）、任务（tasks）。

因build.gradle是本文核心的内容之一，我们将专门用一个大标题来讲解build.gradle。

3、build.gradle

生成的build.gradle的文件内容如下：

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'java'
}

group = 'top.wisely'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    maven { url 'https://maven.aliyun.com/repository/public/' }
    maven { url 'https://mirrors.cloud.tencent.com/nexus/repository/maven-public/' }
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

下面我们对重点内容进行讲解。

3.1 plugins（插件）

build.gradle中声明了plugins的依赖。

核心插件只需要使用id简称即可，社区插件需要使用全名称的id。

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'java'
}

社区插件：Spring Boot Gradle插件，它为我们提供Spring Boot运行，创建可执行jar包或者war包的能力，这个我们在下一节会着重的去讲解：

id 'org.springframework.boot' version '2.7.5'

社区插件：Spring Boot依赖管理插件，它为我们提供对项目直接或间接依赖的库的版本的控制，这些版本都是Spring Boot做过兼容性测试的版本：

id 'io.spring.dependency-management' version '1.0.15.RELEASE'

核心插件：Java插件将Java编译以及测试等功能添加到项目中。

id 'java'

3.2 repositories（库）

Gradle默认使用Maven的中心库下载依赖包：

repositories {
    mavenCentral()
}

如果从中心库下载jar包的速度慢，我们可以通过阿里云或者腾讯云的Maven库镜像来加速，当然也可以使用你公司内部的Maven库私服来加速。

repositories {
    maven { url 'https://maven.aliyun.com/repository/public/' }
    maven { url 'https://mirrors.cloud.tencent.com/nexus/repository/maven-public/' }
    mavenCentral()
}

3.3 dependecies（依赖）

• 普通依赖：implementation 我们只需要按照下面的格式即可引入依赖：

implementation group: '***', name: '***', version: '***'

或简写成：

implementation 'group:name:version'

因为插件，只要被Spring Boot所管理的依赖，版本也无须维护，可以更加精简的写成：

implementation 'group:name'

依赖样子一般为：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    //...
}

在我们绝大部分时间，我们和gradle做依赖相关的工作，在了解这些后都能解决了。

我们可以通过：https://mvnrepository.com 网站查找添加依赖，我们在依赖中选中Gradle（short）来复制内容到我们的依赖中。

• 测试依赖：testImplementation

测试相关的依赖，使用testImplementation，规则和普通依赖一致。

dependencies {
    //...
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

• 编译依赖：compileOnly 只在编译期起效的依赖。

dependencies {
    //...
    compileOnly 'org.projectlombok:lombok'
  //...
}

• 运行时依赖：runtimeOnly

只在运行时起效的依赖。

dependencies {
    //...
    runtimeOnly 'com.mysql:mysql-connector-j'
    //...
}

4、Spring Boot Gradle Plugin

能够让Spring Boot各种能力运行起来，主要是依靠Spring Boot Gradle插件。Spring Boot Gradle插件中包含了大量的task（任务），我们可以用gradlew来查看他提供的所有tasks（任务）。

• 项目任务列表：通过下面的任务来查询当前项目的任务列表，这些大部分任务都是由Spring Boot Gradle插件提供的。

./gradlew tasks

• 查询具体的任务信息的帮助

./gradlew help --task bootRun

• 添加简单的演示代码

@SpringBootApplication
@RestController
public class GradleDemoApplication {

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

   @RequestMapping("/")
   public String hello(){
      return "hello gradle!!!";
   }
}

• 运行Spring Boot程序的task：bootRun

./gradlew bootRun

访问：http://localhost:8080/

• 编译可执行jar包task：build /bootJar

./gradlew bootJar

会在build/libs 目录下，生成可执行jar包。

jar包的名字为 gradle-demo-0.0.1-SNAPSHOT.jar，jar包的名字是由上面的settrings.gradle 中设置的名字

• 清理build的任务：clean

./gradlew clean

• 执行测试的任务：test

./gradlew test

5、Intellij IDEA和Gradle：如虎添翼

5.1 创建Gradle的Spring Boot项目

Intellij IDEA支持新建Spring Initializr的项目，注意选择Gradle作为构建工具。

5.2 可直接打开基于Gradle的Spring Boot项目

可直接在File-》Open选择基于Gradle的Spring Boot项目，导入到Intellij IDEA后，会自动下载相关的依赖。下面是导入项目导入到Intellij IDEA的样子。

5.3 在Gradle工具窗口执行tasks（任务）

在上图中，我们看见右侧有Gradle的页签，点开可以看见Gradle工具窗口，窗口中有任务列表。

在任务列表，我们选择一个任务如bootJar 双击运行：

5.4 加载build.gradle的变化

• 手动加载：可以点击Gradle工具窗口的刷新按钮或build.gradle文件上的刷新按钮实现手动加载。

• 自动加载：在设置的Build Tool 中的Reload project after changes in the build scripts 选中Any changes 。

5.5 快捷检索、添加依赖

在build.gradle 页面，MacOS下使用command + N ，Windows下使用Alt+Insert。可调出Add depedency。

点击Add depedency后，我们会多一个依赖的检索视图，可以在此检索并添加依赖：

5.6 build.gradle脚本自动补全

5.7 在Gradle工具窗口查看项目的依赖

6、结语

通过本文的讲解，一般情况下可以满足你在项目开发中绝大部分的需求。如果有更深层的使用需求，可留言讨论。

最后送给大家一句话：

"I can’t understand why people are frightened of new ideas. I’m frightened of the old ones." — John Cage "我不明白为什么人们害怕新想法。 我害怕那些旧的。" - 约翰凯奇。

感谢对我的书《从企业级开发到云原生微服务：Spring Boot实战》的支持。

头条原文地址：https://www.toutiao.com/article/7155054951813644803/

参考资料：

https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/

https://gustavopeiretti.com/spring-boot-with-gradle-wrapper/

https://tomgregory.com/10-tips-to-use-gradle-with-intellij-idea/

但在很多时候，通过上述方式实现的计划任务是在代码里写死的，我们需要修改计划任务只能通过修改代码的方式实现。很多时候，我们需要从外部来设置计划任务执行的时间和方式。所以在本文中，我们着重讲解一下如何动态地配置计划任务。

和Spring对异步任务的支持一样，通过@EnableAsync 注解开启异步的支持，然后通过@Async 注解来指定异步的方法，而真正的异步任务的执行者是TaskExecutor接口 ，它的实现是ThreadPoolTaskExecutor。（若感兴趣可参考《Spring Boot 实战21 - Spring Boot的多线程异步任务》，此处只为比较加深记忆）

同样，Spring对计划任务的支持也是通过@EnableScheduling 开启计划任务的支持，然后通过@Scheduled 注解来制定计划任务，而真正的任务执行者是TaskScheduler 接口，它的实现是ThreadPoolTaskScheduler 。（若对于固定配置的计划任务感兴趣可参考《Spring Boot 实战22 - Spring Boot的计划任务》）

TaskScheduler的接口有三类主要方法：

public interface TaskScheduler {

  //指定时间启动计划任务
   ScheduledFuture<?> schedule(Runnable task, Trigger trigger);
  ScheduledFuture<?> schedule(Runnable task, Date startTime);

  //指定频率启动计划任务
   ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period);
   ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period);

  //指定延迟启动计划任务
   ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
   ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay);
}

方法的返回值都是ScheduledFuture 接口,可以使用它来取消任务或者检查任务是否完成。而实际要执行的任务是Runnable的实现类。

那我们可以通过TaskScheduler来实现动态的计划任务的实现。Spring Boot为我们提供了 TaskSchedulingAutoConfiguration自动配置来自动注册TaskScheduler 的Bean。所以我们无需配置可直接注入TaskScheduler的Bean即可使用。

Spring Boo同样提供了TaskSchedulingProperties来TaskScheduler 进行配置，我们可以通过：spring.task.scheduling的属性进行配置。

• 新建一个演示项目

• 构建需要定时启动的任务

public class RunnableTask implements Runnable{
    private String taskName;
    private WorkingService workingService;

    public RunnableTask(String taskName, WorkingService workingService) {
        this.taskName = taskName;
        this.workingService = workingService;
    }

    @Override
    public void run() {
        workingService.work( taskName );
    }
}

这里为了还原实际，一般我们会在任务中调用Spring容器中的其他类进行操作，在此我们引入了一个WorkingService来真正执行任务。

• 简单的WorkingService

@Service
@Slf4j
public class WorkingService {

    public void work(String taskName){
        log.info("当前任务：" + taskName +" 在线程" + Thread.currentThread().getName() + "上运行");
    }
}

• 使用TaskScheduler 的Bean启动定时任务

@Service
public class SchedulingService {
    private final TaskScheduler taskScheduler; // 可直接注入TaskScheduler的Bean
    private final WorkingService workingService; 

    //构造器注入，免@Autowired
    public SchedulingService(TaskScheduler taskScheduler, WorkingService workingService) { 
        this.taskScheduler = taskScheduler;
        this.workingService = workingService;
    }

    public void schedule(String taskName, String cronExpression){
          //RunnableTask不是一个Bean，不能直接注入workingService，在它的构造器直接传入
        RunnableTask task = new RunnableTask(taskName,workingService);
        CronTrigger cronTrigger = new CronTrigger(cronExpression);
       //api接受实际执行的任务，和定时启动的cron表达式
        taskScheduler.schedule(task,cronTrigger);
    }

    public void scheduleAtFixedRate(String taskName, long period){
        RunnableTask task = new RunnableTask(taskName,workingService);
       //api接受实际执行的任务，和间隔时间
        taskScheduler.scheduleAtFixedRate(task, period);
    }

    public void scheduleWithFixedDelay(String taskName, long delay){
        RunnableTask task = new RunnableTask(taskName,workingService);
       //api接受实际执行的任务，和延迟时间
        taskScheduler.scheduleWithFixedDelay(task, delay);
    }
}

• 在启动类设置动态配置

@SpringBootApplication
@EnableScheduling
public class DynamicTaskSchedulerApplication {

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

   @Bean
   CommandLineRunner commandLineRunner(SchedulingService schedulingService, WorkingService workingService){
      return args -> {
         schedulingService.schedule("指定时间任务", "50 * * * * THU");
         schedulingService.scheduleAtFixedRate("指定频率任务", 1000);
         schedulingService.scheduleWithFixedDelay("指定延迟任务", 1000);
      } ;
   }
}

• application.properties 的配置

spring.task.scheduling.pool.size=3
spring.task.scheduling.thread-name-prefix=wisely-

• 启动程序验证

头条原文地址：https://www.toutiao.com/article/7158705923182182927/

感谢对我的书《从企业级开发到云原生微服务：Spring Boot实战》的支持。

HTTP里有一个RFC 7807规范：https://www.rfc-editor.org/rfc/rfc7807。这个规范里定义了HTTP API的“问题细节”（Problem Details）内容。

该规范定义了一个“问题细节”（Problem Details），用它来携带HTTP错误返回信息，避免自定义新的错误返回格式。我们通常情况下是自己定义错误返回格式的。

Spring 6.0为我们提供了一个org.springframework.http.ProblemDetail 来实现该规范。

RFC 7807是一个很简单的规范。它定义了一个JSON格式，并关联了一个媒体类型（media type），这个JSON格式包含了五个可选成员来描述问题细节：

• type ：一个URI引用，用来识别问题的类型。这个URI的路径内容应该用来显示人类可读的信息来描述类型；
• title ：人类可读的问题类型描述；相同类型的问题，应该总是相同的描述；
• status ：HTTP状态码，将它包含在问题细节里是一种方便的方式；
• detail ：人类可读的问题实例描述，解释为什么当前的问题发生在这个特定的场景下；
• instance ：一个URI引用，用来识别问题实例。这个URI的内容应该用来描述问题实例，但不是必须的。

我们首先建立一个演示项目：

1、通常的业务异常处理方法

• 定义一个业务异常类。异常含义为：当Person找不到的时候抛出的业务异常。

public class PersonNotFoundException  extends RuntimeException {
    @Getter
    private final HttpStatus status;

    public PersonNotFoundException(String message, HttpStatus status) {
        super(message);
        this.status = status;
    }
}

• 注册这个业务异常到全局异常处理。

通过在@RestControllerAdvice 中定义全局的切面处理。

通过@ExceptionHandler 来处理指定异常的处理方式。

这里返回的格式就是我们自定义的ErrorMsg格式。我们通过自定义这个ErroMsg完成和接口使用者协议，完成对业务异常的处理。

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(PersonNotFoundException.class)
    public ResponseEntity<ErrorMsg> personNotFoundHandler(PersonNotFoundException e) {
        ErrorMsg msg = new ErrorMsg("0000", e.getMessage());
        return new ResponseEntity<>(msg, e.getStatus());
    }
}

• 需自定义的错误返回

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ErrorMsg {
    private String code;
    private String msg;
}

• 测试控制器

@RestController
public class PersonController {

    @GetMapping("/getPerson")
    public String getPerson(){
        throw new PersonNotFoundException("查找的人不存在", HttpStatus.NOT_FOUND);
    }
}

• 启动程序，访问：http://localhost:8080/getPerson

2、基于“问题细节”的业务异常处理

基于我们常规的异常处理，其实已经能满足我们的业务需求，使用RFC 7807规范，我们可以免去自定义的异常错误格式（ErrorMsg ），使用Spring 6.0给我们提供的ProblemDetail ，这样我们以后再无需自己自定义异常返回格式，且在不同的项目之间有了标准，从而客户端在使用的时候有了可预测性。

Spring 6.0的做法也很简单，我们只需要将我们自定返回的ErrorMsg 修改成ProblemDetail 即可。我们看一下示例代码：

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(PersonNotFoundException.class)
    public ProblemDetail personNotFoundHandler(PersonNotFoundException e) {
      ProblemDetail problemDetail = ProblemDetail.forStatus(HttpStatus.NOT_FOUND); 
      problemDetail.setType(URI.create("https://www.toutiao.com/c/user/token/MS4wLjABAAAAJxW0bvHKNNwIpcsocIDAjNHHNXg2yaj1upViHO2JVNw/"));
      problemDetail.setTitle("Person Not Found");
      problemDetail.setDetail(String.format("错误信息：‘%s’", e.getMessage()));
      return problemDetail;
    }
}

值得说的是ProblemDetail 还支持设置一个Map的properties：

private Map<String, Object> properties;

这样也为我们的定制扩展提供了更大的空间。

启动，访问： http://localhost:8080/getPerson，其实的错误返回符合RFC 7807规范。

注意查看返回的头信息，我们看到了，返回数据的媒体类型为：application/problem+json：

我会持续关注Spring Boot 6.0和Spring Boot 3.0的最新的特性相关信息，并发布相关的文章，请保持关注。

感谢支持我的书：《从企业级开发到云原生微服务:Spring Boot实战》

头条原文地址：https://www.toutiao.com/article/7158705923182182927/

参考资料：https://docs.spring.io/spring-framework/docs/6.0.0-RC2/javadoc-api/org/springframework/http/ProblemDetail.html

Spring 6.0最大的更新有：

1. Java 17作为最低版本
2. 迁移到Jakarta EE 9+（Tomcat 10/Jetty 11，最新的hibernate 6.1）
3. AOT（Ahead-Of-Time ）

在2022.10.20日的下午，Spring Boot 3.0的第一个候选发布。我们可以从 https://repo.spring.io/milestone 里使用Spring Boot 3.0 RC1的依赖了。预计Spring 6.0和Spring Boot 3.0都会在下个月也就是11月发布正式版。

这是Spring Boot 3.0的第一个候选版本，预计将于2022年11月24日发布正式版本。现在不会再添加更多的特性，只会在发现问题时进行API更改。我们选择大可以放心的去学习使用Spring Boot 3.0了！

此版本是11个月工作的结晶，是第一个完全实现在Spring Boot 3.0中提供的主题规划的版本。 最值得注意的是，此版本建立在多年研发工作：实验性Spring Native项目之上，旨在为 GraalVM 原生镜像（native image）提供支持。

现在，你可以使用标准的Spring Boot Maven或Gradle插件将Spring Boot应用程序转换为本地原生（native）可执行程序，不需要任何特殊配置。

这个发布的版本包含了新的文档部分，来介绍原生镜像（native image）相关的内容和概念，在此链接可以查看：https://docs.spring.io/spring-boot/docs/3.0.0-RC1/reference/html/native-image.html。通过此文档，我们可以了解到Spring Boot 3.0的最大特性之一AOT的功能的使用。

和Spring 6.0一样，除了对GraalVM原生镜像的支持，该版本还完成了我们到JakartaEE 9的迁移和到Java 17的基线升级。

其它值得关注的RC1版本的新特性有：

1. Spring Data JDBC更灵活的自动配置。

2. Prometheus Examplars的自动配置。

3. log4j2 增强功能包括：profile文件支持和环境属性查找。

关于当前RC1版本和历史的里程碑版本的详细发布记录，可查看：https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-3.0.0-RC1-Release-Notes。

我会持续关注Spring Boot 6.0和Spring Boot 3.0的最新的特性相关信息，请保持关注。

感谢支持我的书：《从企业级开发到云原生微服务:Spring Boot实战》

参考资料：

https://spring.io/blog/2022/10/20/spring-framework-6-0-0-rc2-available-now

https://spring.io/blog/2022/10/12/spring-framework-6-0-goes-rc1

https://spring.io/blog/2022/10/20/spring-boot-3-0-0-rc1-available-now

什么是Ngrok

Ngrok可以创建一个http隧道，并为您提供一个公共URL，重定向到本地机器上的指定端口。它是一个很棒的开发或者测试目的使用的工具。

Ngrok的官网地址是：https://ngrok.com 。

Ngrok Spring Boot Starter

Spring Boot的Web端口可以通过Ngrok Spring Boot Starter暴露到互联网。

Ngrok Spring Boot Starter将会根据你的操作系统自动下载Ngrok的二进制文件并缓存到home_directory/.ngrok2 目录。

每次运行Spring Boot程序的时候，Ngrok会自动构建指向Spring Boot Web程序的http隧道。

该Starter的地址为：https://github.com/kilmajster/ngrok-spring-boot-starter

注册Ngrok

• 注册Ngrok 访问Ngrok官网：https://ngrok.com/，注册Ngrok账号

• 获取Ngrok的认证码 访问： https://dashboard.ngrok.com/get-started/your-authtoken ，即可看到authtoken。

Spring Boot 代码演示

• 新建演示项目

• 简单的演示代码

@SpringBootApplication
@RestController
public class NgrokDemoApplication {

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

   @GetMapping("/")
   public String index(){
      return "Hello Ngrok!";
   }

}

• 添加ngrok-spring-boot-starter依赖

Gradle:

implementation 'io.github.kilmajster:ngrok-spring-boot-starter:0.6.0'

或Maven：

<dependency>
  <groupId>io.github.kilmajster</groupId>
  <artifactId>ngrok-spring-boot-starter</artifactId>
  <version>0.6.0</version>
</dependency>

• 简单配置 在application.yaml 中:

ngrok:
  enabled: true # 开启ngrok
  auth-token:  ------# 复制上面获取的authtoken到此处

• 启动程序

通过Spring Boot控制台，你可以发现：

1. 启动时程序自动会自动下载ngrok并解压缓存到系统用户的.ngrok下。
2. 启动ngrok，ngrok dashboard的地址是：http://127.0.0.1:4040

• 访问ngrok dashboard

你会发现ngrok为我们提供了两个公网访问的地址，分别是http和https的。

• 访问ngrok提供的公网地址

用手机访问：

ping 域名返回的也是公网的ip：

更多关于如何使用的，请参考Starter的项目地址。

感谢支持我的书：《从企业级开发到云原生微服务:Spring Boot实战》

头条文章地址：https://www.toutiao.com/article/7080505822463214093/

参考资料： https://github.com/kilmajster/ngrok-spring-boot-starter

你可能会使用的方式

通常情况下，以使用Spring Data JPA和Hibernate为例（别走开，方案是和数据库访问技术无关的，理论上Mybatis，JDBC都可以使用），我们在application.yaml 里配置使用：

spring.jpa.show-sql: true

但这样的设置只能在开发测试环境里设置，因为使用此属性等同于使用System.out.println打印SQL语句，这将会有性能的问题。而且也不能显示SQL的参数。

或者我们通过设置Hibernate属性在application.yaml配置：

logging.level.org.hibernate.SQL: debug
logging.level.org.hibernate.type.descriptor.sql: trace

这个方案比上面的方案好一些，但是也有几个问题：

1. 在批处理情况，不清楚有多少语句实际发送到数据库服务器，因为日志消息是在准备阶段打印的，而不是在调用executeBatch方法时打印的。
2. org.hibernate.type.descriptor.sql只能记录内置的Hibernate核心类型，如果你使用自定义的类型，将不会被打印。

现在我们介绍一个开源项目，叫做：datasource-proxy，地址： https://github.com/jdbc-observations/datasource-proxy 。

它提供了一个JDBC的DataSource 的代理：ProxyDataSource ，这就意味着它可以用在任何在Spring Boot下的数据访问技术，如：JPA、Mybatis等。就算混合使用多种数据访问技术，datasource-proxy也能打印所有的通过JDBC连接的语句。

使用datasource-proxy

• 新建演示项目

• 添加相关依赖 我们可以直接添加datasource-proxy的依赖，然后自己通过ProxyDataSourceBuilder 来创建ProxyDataSource。不过我们并不需要这样做，因为已经有人给我们写好了datasource-proxy的Spring Boot Starter，我们直接使用这个starter就可以直接自动配置好datasource-proxy。starter的地址： https://github.com/gavlyukovskiy/spring-boot-data-source-decorator 。

Gradle

implementation 'com.github.gavlyukovskiy:datasource-proxy-spring-boot-starter:1.8.1'

或Maven

<dependency>
    <groupId>com.github.gavlyukovskiy</groupId>
    <artifactId>datasource-proxy-spring-boot-starter</artifactId>
    <version>1.8.1</version>
</dependency>

• 简单的数据访问演示类

@Data
@Entity
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;
}
public interface PersonRepository extends JpaRepository <Person, Long> {
    List<Person> findByNameStartsWith(String name);
}

• 简单的数据访问查询测试

@SpringBootApplication
public class LoggingSqlApplication {

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

   @Bean
   CommandLineRunner commandLineRunner(PersonRepository personRepository){
      return args -> {
         personRepository.save(new Person(null,"wiselyman001", 18));
         personRepository.save(new Person(null,"wiselyman002", 18));
         personRepository.save(new Person(null,"wiselyman003", 18));
         personRepository.save(new Person(null,"wiselyman004", 18));
         personRepository.findByNameStartsWith("wiselyman");
      };
   }
}

• datasource-proxy的核心配置

datasource-proxy-spring-boot-starter 为我们提供了一个DataSourceProxyProperties来配置DataSourceProxy ，我们可以通过application.yaml 来配置。如：

# 设置日志库，默认为slf4j(slf4j, jul, common, sysout)
decorator.datasource.datasource-proxy.logging: slf4j

# 开启所有的查询到日志，默认为true
decorator.datasource.datasource-proxy.query.enable-logging: true
decorator.datasource.datasource-proxy.query.log-level: debug
# 日志名称设置
decorator.datasource.datasource-proxy.query.logger-name:

# 设置慢SQL的情况，慢SQL的日志级别是WARN
decorator.datasource.datasource-proxy.slow-query.enable-logging: true
decorator.datasource.datasource-proxy.slow-query.log-level: warn
decorator.datasource.datasource-proxy.slow-query.logger-name:
# 设置被认为是慢sql的时间并用日志记录下来
decorator.datasource.datasource-proxy.slow-query.threshold: 300

decorator.datasource.datasource-proxy.multiline: true
decorator.datasource.datasource-proxy.json-format: false
# 开启查询指标
decorator.datasource.datasource-proxy.count-query: false

上面是默认配置，若满足要求无需单独进行设置。

如我们没有特殊的定制，我们只需在application.yaml加上即可使用：

logging.level.net.ttddyy.dsproxy.listener: debug

运行程序

Name:dataSource, Connection:3, Time:36, Success:True
Type:Prepared, Batch:False, QuerySize:1, BatchSize:0
Query:["insert into person (age, name) values (?, ?)"]
Params:[(18,wiselyman001)]
2022-10-17 17:13:16.907 DEBUG 12740 --- [           main] n.t.d.l.l.SLF4JQueryLoggingListener      : 
Name:dataSource, Connection:4, Time:34, Success:True
Type:Prepared, Batch:False, QuerySize:1, BatchSize:0
Query:["insert into person (age, name) values (?, ?)"]
Params:[(18,wiselyman002)]
2022-10-17 17:13:17.041 DEBUG 12740 --- [           main] n.t.d.l.l.SLF4JQueryLoggingListener      : 
Name:dataSource, Connection:5, Time:33, Success:True
Type:Prepared, Batch:False, QuerySize:1, BatchSize:0
Query:["insert into person (age, name) values (?, ?)"]
Params:[(18,wiselyman003)]
2022-10-17 17:13:17.183 DEBUG 12740 --- [           main] n.t.d.l.l.SLF4JQueryLoggingListener      : 
Name:dataSource, Connection:6, Time:36, Success:True
Type:Prepared, Batch:False, QuerySize:1, BatchSize:0
Query:["insert into person (age, name) values (?, ?)"]
Params:[(18,wiselyman004)]
2022-10-17 17:13:17.407 DEBUG 12740 --- [           main] n.t.d.l.l.SLF4JQueryLoggingListener      : 
Name:dataSource, Connection:7, Time:37, Success:True
Type:Prepared, Batch:False, QuerySize:1, BatchSize:0
Query:["select person0_.id as id1_0_, person0_.age as age2_0_, person0_.name as name3_0_ from person person0_ where person0_.name like ? escape ?"]
Params:[(wiselyman%,\)]

感谢支持我的书：《从企业级开发到云原生微服务:Spring Boot实战》

头条原文地址：https://www.toutiao.com/article/7153135743584551438/

参考资料：

https://github.com/jdbc-observations/datasource-proxy

https://github.com/gavlyukovskiy/spring-boot-data-source-decorator

https://vladmihalcea.com/the-best-way-to-log-jdbc-statements/

https://vladmihalcea.com/log-sql-spring-boot/

但也存在着这样的Java类对象的源码不受控制的情况：

1、Java类在第三方的类库中，你无法修改；

2、不想修改已有的类的代码，因当前业务和已有业务在不同的模块中。

Jackson为我们mixin来解决这个问题，在不修改已有的Java类库的情况下，定制Json的输出。Spring Boot 2.7为我们提供了@JsonMixin注解来快速注册mixin。

1、演示项目

打开https://start.spring.io，Spring Boot版本选择2.7.x依赖选择“Spring Web”和“Lombok”。

2、演示代码

需要定制输出的类：

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
}

演示用控制器：

@RestController
public class PersonController {
    @GetMapping("/getDemoPerson")
    Person getDemoPerson(){
        return new Person("wiselyman",18);
    }
}

运行访问： http://localhost:8080/getDemoPerson

下面我们需要将“name”输出修改为“fullName”，我们先用最简单的常规实现，这意味着我们能直接修改“Person”类的源码。

3、可控时的实现

在可修改源码的情况下，定制输出是很简单的：

import com.fasterxml.jackson.annotation.JsonProperty;

@Data
@AllArgsConstructor
public class Person {
    @JsonProperty("fullName")
    private String name;
    private Integer age;
}

运行访问： http://localhost:8080/getDemoPerson

4、不可控时mixin的实现

我们通过定义一下个抽象类来实现mixin的功能，然后通过Spring Boot的@JsonMixin注解将这个抽象类注册到自动配置的ObjectMapper。

首先我们的Person类恢复原样。

@Data
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
}

定义一个叫抽象类FullNameMixin，将FullNameMixin附加到目标类Person：

import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.boot.jackson.JsonMixin;

@JsonMixin(Person.class) //1
public abstract class FullNameMixin {
    @JsonProperty("fullName") //2
    String name; //3
}

1. Spring Boot的Jackson自动配置将扫描应用程序的包以查找带有“@JsonMixin”注释的类，并将它们注册到自动配置的“ObjectMapper”。 注册动作由Spring Boot的“JsonMixinModule”执行。“Person.class”是被附加mixin的目标类。
2. 被定制的新名称。
3. 被定制的原属性。

运行访问： http://localhost:8080/getDemoPerson

JDK 17+和Jakarta 9+基线

1. 整个框架的代码基于Java 17源码级别。
2. Servlet、JPA等从"javax"迁移到"jakarta"命名空间。
3. 兼容最新一代的web容器：Tomcat 10，Jetty 11.
4. JDK 19的“虚拟线程”的早期兼容。

   一般核心修订

5. 升级到ASM 9.4和Kotlin 1.7。
6. 完成CGLIB分支，支持捕捉CGLIB生成的类。
7. AOT（Ahead-Of-Time）转换的全面基础。
8. 对GraalVM原生镜像第一级别的支持。

   核心容器

9. GenericApplicationContext(refreshForAotProcessing)中对AOT处理的支持。
10. 基于预先解析构造器和工厂方法的bean的定义和转换。
11. 为AOP代理和配置类提供早期代理类确定的支持。
12. PathMatchingResourcePatternResolver使用NIO和module path API来扫描。

    数据访问和事务

13. 支持预先确定 JPA 管理类型（用于包含在 AOT 处理中）。
14. JPA支持Hibernate 6.1（保持Hibernate 5.6）的支持。
15. 升级到R2DBC 1.0（响应式编程的数据库驱动，包含R2DBC事务定义）。
16. 移除JCA CCI的支持。

    Spring消息

17. RSocket接口客户端基于@RSocketExchange服务接口。
18. 基于Netty 5 alpha 的Reactor Netty 2的早期支持。

    一般Web修订

19. HTTP接口客户端基于@HttpExchange服务接口。
20. 支持RFC 7807问题https://docs.spring.io/spring-framework/docs/6.0.0-RC1/reference/html/web.html#mvc-ann-rest-exceptions。
21. 统一的HTTP状态码的处理。
22. 为RestTemplate提供基于Micrometer的观测性支持。

    Spring MVC

23. 默认使用PathPatternParser（可以选择PathMatcher）
24. 为控制器方法返回的Flux和Mono返回值，提供与Micrometer上下文传播集成。
25. 移除过时的Tiles和FreeMarker JSP的支持。

    Spring WebFlux

26. 使用新的PartEvent API用于form文件上传。
27. 添加ResponseEntityExceptionHandler定制WebFlux一场和渲染RFC 7807错误响应。
28. 用于非流的媒体类型的Flux返回值。
29. 基于Netty 5 alpha 的Reactor Netty 2的早期支持。
30. JDK HttpClient与WebClient 集成。
31. 为WebClient提供基于Micrometer的观测性支持。

    测试

32. 支持测试AOT处理的application context。
33. 与HtmlUnit 2.64请求参数处理集成。

我会陆续更新关于Spring 6.0和Spring Boot 3.0新特性的文章，请保持关注，感谢！

参考资料： https://github.com/spring-projects/spring-framework/wiki/What%27s-New-in-Spring-Framework-6.x/

通常情况下，多租户有三种形式：

1、分区（Partitioned）数据：不同租户的数据都在一张表里，通过一个值（tenantId）来区分不同的租户。

2、分结构（Schema）：不同的租户数据放置在相同数据库实例的不同结构（Schema）中。

3、分数据库（Database）：不同租户的数据放置在不同的数据中。

在Spring Boot中，多租户的能力是由Hibernate提供的，我们在本文中结合Spring Data JPA一起对三种多租户的模式进行演示。本文不需要你具备任何Spring Data JPA和Hibernate基础，也可以通过本文领略下Spring Data JPA。

多租户最最简单也是最常用的多租户方式是“分区数据“”，而这个功能是Hibernate 6.0才具有的功能，而Spring Boot 2.x只支持Hibernate 5.x，所以使用“分区数据”的方式进行多租户需要采用Spring Boot 3.x。幸运的是Spring Boot 3.0将于今年11月份发布，到时候你就可以在生产环境使用本功能了。

“分结构”和“分数据库”的实现方式Spring Boot 2.x是支持的，本文为了演示简单以及远期的前瞻性，将全部以Spring Boot 3.0来实现。

首先，我们从最简单的开始。

1、“分区数据”多租户

• 新建演示项目：spring-boot-multitenant-partition,依赖为Spring Web、Spring Data JPA、Lombok，Spring Boot版本注意选择3.x，Spring Boot 3.x的最小支持JDK版本为17。

• 演示实体：

  @Entity //1
  @Data
  public class Person {
    @Id //2
    @GeneratedValue(strategy= GenerationType.IDENTITY) //3
    private Long id;
    @TenantId //4
    private String tenantId;
    private String name;
    private Integer age;
  }
  

  1、通过@Entity注解定义一个实体，对应数据库一张表；
  2、通过@Id注解表名该属性对应数据库的主键；
  3、通过@GeneratedValue(strategy= GenerationType.IDENTITY)配置使用MySQL的主键自增；
  4、使用@TenantId注解的属性tenantId作为分区数据多租户的的区分标识。

• 演示数据访问

import org.springframework.data.jpa.repository.JpaRepository;

public interface PersonRepository extends JpaRepository<Person,Long> {
    List<Person> findByName(String name);
}

这个是Spring Data JPA神奇的地方，通过一个定义一个接口PersonRepository继承框架提供的JpaRepository接口，框架将会给我们自动代理一个实现类，这个实现类除了基本的增删查改以外，还会通过方法名自动推算查询语句。如findByName相当于select * from person where name = ?

• 演示如何确定TenantId的来源

import org.hibernate.cfg.AvailableSettings;
import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;

@Component
public class WiselyTenantIdResolver implements CurrentTenantIdentifierResolver, //1
                                                HibernatePropertiesCustomizer  { //2

    private static final ThreadLocal<String> CURRENT_TENANT = new ThreadLocal<>(); //1.1

    public void setCurrentTenant(String currentTenant) { //1.2
        CURRENT_TENANT.set(currentTenant); 
    }

    @Override
    public String resolveCurrentTenantIdentifier() { //1
        return Optional.ofNullable(CURRENT_TENANT.get()).orElse("unknown");
    }

    @Override
    public boolean validateExistingCurrentSessions() {
        return false;
    }

    @Override
    public void customize(Map<String, Object> hibernateProperties) { //2
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, this);
    }

}

1、通过实现CurrentTenantIdentifierResolver接口来获取确定TenantId的来源。 1.1、 使用线程本地变量CURRENT_TENANT来存储当前的TenantId；
1.2、通过setCurrentTenant方法接受外部设置当前访问者的TenantId，并存储在线程本地变量CURRENT_TENANT中；
1.3、通过重写接口的resolveCurrentTenantIdentifier方法，获得当前的TenantId；
2、通过重写HibernatePropertiesCustomizer接口的customize方法，可以将当前类注册到Hibernate的配置。

• 通过请求头设置TenantId

@Component
public class TenantIdInterceptor implements HandlerInterceptor {
    private final WiselyTenantIdResolver tenantIdResolver;

    public TenantIdInterceptor(WiselyTenantIdResolver tenantIdResolver) {
        this.tenantIdResolver = tenantIdResolver;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        tenantIdResolver.setCurrentTenant(request.getHeader("x-tenant-id"));
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
}

通过定义一个Spring MVC的拦截器，在每个request请求的头部设置key：x-tenant-id（如：companya），在拦截器中获取到TenantId后设置WiselyTenantIdResolver的TenantId，即当前的TenantId。

• 注册此拦截器

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    private final TenantIdInterceptor tenantIdInterceptor;

    public WebConfig(TenantIdInterceptor tenantIdInterceptor) {
        this.tenantIdInterceptor = tenantIdInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tenantIdInterceptor);
        WebMvcConfigurer.super.addInterceptors(registry);
    }
}

• 演示控制器

@RestController
@RequestMapping("/people")
public class PersonController {

    private final PersonRepository personRepository;

    public PersonController(PersonRepository personRepository) {
        this.personRepository = personRepository;
    }


    @PostMapping
    public Person save(@RequestBody PersonDto personDto){ //1
        return  personRepository.save(personDto.createPerson());
    }

    @GetMapping
    private List<Person> all(){ //2
        return personRepository.findAll();
    }
}

1、通过设置在头信息中设置不同的TenantId，数据库中的tenant_id字段将自动存储头中的租户；
2、通过设置在头信息中设置不同的TenantId，只能查询到该租户下的数据。

• 控制器所需要的DTO

import lombok.Value;

@Value
public class PersonDto {
    private String name;
    private Integer age;
    public Person createPerson(){
        Person person = new Person();
        person.setName(this.name);
        person.setAge(this.age);
        return person;
    }
}

• 配置：

spring.datasource.url: jdbc:mysql://localhost:3306/partitioned #1
spring.datasource.username: root
spring.datasource.password: example
spring.datasource.driver-class-name: com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto: update # 2
server.port: 80

1、在数据库中创建一个schema叫partitioned；
2、设置为update属性，hibernate会自动因实体类的变化自动创建和更新数据库的表；

• 启动程序

• 测试需保存的数据

通过postman构造四条数据，分别为：

租户：companya，通过x-tenant-id头来设置：

{"name":"wang","age":22}
{"name":"li","age":23}

租户：companya，通过x-tenant-id头来设置：

{"name":"peng","age":24}
{"name":"zhang","age":25}

• 请求需保存的数据

在postman的样子是这样的：

我们一次对上述四条数据进行请求，查看数据库：

我们看见数据都添加了正确的tenant_id。

• 按租户查询数据

查询租户companya的数据：

查询租户companyb的数据：

2、“分结构”多租户

第二个例子，我们在一个数据库中分别建立2个schema，分别是companya,用来放置租户companya的数据；companyb用来放置租户companyb的数据。再建一个schema：public作为默认的连接的schema。

• 演示实体

public class Person {
    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;
}

无须标识租户的tenantId字段，因为租户已经通过schema来隔离开了。

• 如何获得当前租户id

@Component
public class WiselyTenantIdResolver implements CurrentTenantIdentifierResolver, HibernatePropertiesCustomizer {
    private static final ThreadLocal<String> CURRENT_TENANT = new ThreadLocal<>();
    public void setCurrentTenant(String currentTenant) {
        CURRENT_TENANT.set(currentTenant);
    }

    @Override
    public String resolveCurrentTenantIdentifier() {
        return Optional.ofNullable(CURRENT_TENANT.get()).orElse("public");
    }

    @Override
    public boolean validateExistingCurrentSessions() {
        return false;
    }

    @Override
    public void customize(Map<String, Object> hibernateProperties) {
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, this);
    }

}

这里和上例没有什么区别，只是上例设置如果没有获取到TenantId，则将tenant_id字段设置为unknown,本例是将数据库的schema连到public。

• 通过获得tenantId，连接到对应的schema

import org.hibernate.cfg.AvailableSettings;
import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;



@Component
public class WiselyMultiTenantConnectionProvider implements MultiTenantConnectionProvider, HibernatePropertiesCustomizer { 
    private final DataSource dataSource; 

    public WiselyMultiTenantConnectionProvider(DataSource dataSource){
        this.dataSource = dataSource;
    }

    @Override
    public Connection getAnyConnection() throws SQLException {
        return dataSource.getConnection();
    }

    @Override
    public void releaseAnyConnection(Connection connection) throws SQLException {
        connection.close();
    }

    @Override
    public Connection getConnection(String tenantIdentifier) throws SQLException {
        final Connection connection = getAnyConnection();
        connection.createStatement().execute(String.format("use %s;", tenantIdentifier));
        return connection;
    }


    @Override
    public void releaseConnection(String tenantIdentifier, Connection connection) throws SQLException {
        connection.createStatement().execute("use public;");
        connection.close();
    }

//...省略一些非关键方法

    @Override
    public void customize(Map<String, Object> hibernateProperties) {
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, this);
    }
}

因为我们是连接单个数据库的不同schema，所以我们只需要在系统中配置一个dataSource，通过这个dataSource我们获得数据库的连接。
通过重写MultiTenantConnectionProvider接口的Connection getConnection(String tenantIdentifier)方法，我们根据在上面的WiselyTenantIdResolver获得的tenantId，即当前方法的tenantIdentifier参数来切换dataSource连接到不同的schema.

• 配置

spring.datasource.url: jdbc:mysql://127.0.0.1:3306/public
spring.datasource.username: root
spring.datasource.password: example
spring.datasource.driver-class-name: com.mysql.cj.jdbc.Driver
spring.jpa.show-sql: true
server.port: 80

• 其余代码和上例保持一致，省略

• 测试数据和postman和上例保持一致，查看数据库中的数据：

租户：companya

租户：companyb

查询租户：companya

查询租户：companyb

3、“分数据库”多租户

第三个例子是不同租户的数据分别在不同的数据库里，为了演示方便，本例还是用2个schema来模拟两个数据库，区别是相同数据库时我们使用一个dataSource来切换不同的schema；而本例中会有多个dataSource，使用tenantId来切换到不同的dataSource。

spring-jdbc包为我们提供一个类叫做AbstractRoutingDataSource,它可以设置多个数据源，并通过一个key来切换这个数据源，很显然，这个key是我们的tenantId。

• 动态切换数据源

import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;


@Component
public class WiselyTenantRoutingDatasource  extends AbstractRoutingDataSource {

    private final WiselyTenantIdResolver wiselyTenantIdResolver; //1


     public WiselyTenantRoutingDatasource(WiselyTenantIdResolver wiselyTenantIdResolver) {
        this.wiselyTenantIdResolver = wiselyTenantIdResolver;
        setDefaultTargetDataSource(createDatabase("jdbc:mysql://127.0.0.1:3306/public", "root", "example")); //2
        HashMap<Object, Object> targetDataSources = new HashMap<>(); //3
        targetDataSources.put("companya",createDatabase("jdbc:mysql://127.0.0.1:3306/companya", "root", "example")); //4
        targetDataSources.put("companyb",createDatabase("jdbc:mysql://127.0.0.1:3306/companyb", "root", "example"));
        setTargetDataSources(targetDataSources); //5
    }


    @Override
    protected String determineCurrentLookupKey() { //6
        return wiselyTenantIdResolver.resolveCurrentTenantIdentifier();
    }


    private DataSource createDatabase(String databaseUrl, String username, String password) {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.driverClassName("com.mysql.cj.jdbc.Driver");
        dataSourceBuilder.url(databaseUrl);
        dataSourceBuilder.username(username);
        dataSourceBuilder.password(password);
        return dataSourceBuilder.build();
    }
}

1、注入WiselyTenantIdResolver的bean获得当前的tenantId；
2、添加默认数据源到动态路由数据源里；
3、定义一个Map，在里面存储不同租户的数据源；
4、通过代码编程的方式构建一个数据源；
5、讲这些数据源都添加到动态路由数据源里；
6、通过从WiselyTenantIdResolver中拿到的TenantId，切换到不同的数据源。

• 在数据源被切换后，我们就可以轻松获得数据库的连接

@Component
public class WiselyMultiTenantConnectionProvider implements MultiTenantConnectionProvider, HibernatePropertiesCustomizer {

    private final DataSource dataSource;

    public WiselyMultiTenantConnectionProvider(DataSource dataSource){
        this.dataSource = dataSource;
    }

    @Override
    public Connection getAnyConnection() throws SQLException {
        return dataSource.getConnection();
    }

    @Override
    public void releaseAnyConnection(Connection connection) throws SQLException {
        connection.close();
    }

    @Override
    public Connection getConnection(String tenantIdentifier) throws SQLException {
        return dataSource.getConnection();
    }

    @Override
    public void releaseConnection(String tenantIdentifier, Connection connection) throws SQLException {
        connection.close();
    }

  // 省略不重要的方法

    @Override
    public void customize(Map<String, Object> hibernateProperties) {
        hibernateProperties.put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, this);
    }
}

这里直接注入前面切换数据源后的得到的dataSource，从dataSource中得到数据库的连接

• 其余代码与上例保持一致，数据源是编程获得，所以无须在配置中配置。

• 演示效果和上例一致，再此就不做演示了

4、源码地址

分区数据多租户

分结构多租户

分数据库多租户

5、参考资料

https://spring.io/blog/2022/07/31/how-to-integrate-hibernates-multitenant-feature-with-spring-data-jpa-in-a-spring-boot-application

https://www.baeldung.com/hibernate-5-multitenancy

https://www.baeldung.com/multitenancy-with-spring-data-jpa

注解本身只是元数据，即描述数据的数据，被描述的数据可以是类、方法、属性、参数、构造器等。注解仅是标记本身没有任何可执行的功能代码，但是我们只要标注了注解，我们就能得到想要的功能，这是怎么做到的呢？我们理解肯定是有某处代码根据我们标注的注解找到我们注解的类、方法、属性、参数等数据本身，并根据注解本身的含义以及注解属性里的内容执行功能代码。

第一种：BeanPostProcessor

BeanPostProcessor实现中有一类名称为*AnnotationBeanPostProcessor都是针对处理注解的，对容器内标注了指定注解的Bean，进行功能处理。如：

• AutowiredAnnotationBeanPostProcessor：让@Autowired、@Value、@Inject注解起效；
• CommonAnnotationBeanPostProcessor：让@PostConstruct、@PreDestroy注解起效；
• AsyncAnnotationBeanPostProcessor：让@Async或@Asynchronous注解起效；
• ScheduledAnnotationBeanPostProcessor：让@Scheduled注解起效；
• PersistenceAnnotationBeanPostProcessor：让@PersistenceUnit 、 @PersistenceContext注解起效；
• JmsListenerAnnotationBeanPostProcessor：让@JmsListener注解起效。 它们都会在构造器里指定其能处理的注解类型，并在对应的方法进行功能处理，我们下面演示一个简单的例子帮助大家理解，我们定义注解@InjectLogger向Bean注入org.slf4j.Logger来做系统日志。

我们先定义要使用的注解，只能注解在类上，默认的后缀为“-Bean”

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectLogger {
}

下面我们定义处理注解的 InjectLoggerAnnotationBeanPostPorcessor，我们在上节已经学习过，我们只需要实现BeanPostPorcessor接口即可：

@Component
public class InjectLoggerAnnotationBeanPostPorcessor implements BeanPostProcessor {
    private Class<? extends Annotation> changeAnnotationType; //1

    public InjectLoggerAnnotationBeanPostPorcessor() {
        this.changeAnnotationType = InjectLogger.class; //1
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        ReflectionUtils.doWithFields(bean.getClass(), field -> { //2
            ReflectionUtils.makeAccessible(field); //3
            if(field.isAnnotationPresent(changeAnnotationType)){ //4
                Logger logger = LoggerFactory.getLogger(bean.getClass()); //5
                field.set(bean, logger); //6
            }
        });
        return bean;
    }
}

1. 指明当前类处理@InjectLogger注解；
2. 通过反射机制对类的每个属性（Field）进行处理，第一个参数是Bean的Class，第二参数是入参为Field无返回值的函数接口的Lambda实现；
3. 通过反射机制让当前属性可访问；
4. 新建Logger的实例logger

5. 通过反射将logger值设置到bean实例的当前属性（field）上。 我们将注解使用到其他Bean上使用：

   @Component
   public class DemoLoggerService {
    @InjectLogger
    private Logger log;
   
    public void doSomething(){
        log.info("通过自定义InjectLoggerAnnotationBeanPostPorcessor让注解@InjectLogger注入Logger对象");
    }
   }
   

   通过在JavaConfig运行：

   @Bean
   CommandLineRunner changeAnnotationBeanPostProcessorClr(DemoLoggerService demoLoggerService){
    return args -> {
        demoLoggerService.doSomething();
    };
   }
   

第二种：BeanFactoryPostProcessor

前面我们讲了针对Bean进行处理的BeanPostProcessor，而BeanFactoryPostProcessor是针对Bean的配置元数据（注解等）进行处理操作，而这项工作属于BeanFactory的职责范畴。

• ConfigurationClassPostProcessor：使@PropertySource、@ComponentScan、@Component类、@Configuration、@Bean、@Import和@ImportResource注解起效；
• EventListenerMethodProcessor：使@EventListener注解起效； 我们也通过一个自定义的注解@CustomBean，来自己自动注册Bean，我们的`@CustomBean的作用即是配置元数据。

自定义的注解为：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomBean {
}

使用在Bean上：

@CustomBean
public class CustomBeanService {
    public void doSomething(){
        System.out.println("通过自定义的注解成功注册bean");
    }
}

同样，我们也实现BeanFactoryPostProcessor接口：

@Component
public class CustomBeanDefinitionRegistryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner((BeanDefinitionRegistry) beanFactory); //1
        scanner.addIncludeFilter(new AnnotationTypeFilter(CustomBean.class)); //2
        scanner.scan("top.wisely.springfundamentals.custom_scan"); //3

    }
}

1. 定义一个类路径Bean定义扫描器，它的入参是BeanDefinitionRegistry类型，而ConfigurableListableBeanFactory是它的子类，可强制转换使用，当然我们可以让我们的类直接实现BeanDefinitionRegistryPostProcessor接口，它的方法void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)直接提供了BeanDefinitionRegistry的对象；
2. 为扫描器添加包含的注解@CustomBean的过滤器；
3. 在包top.wisely.springfundamentals.custom_scan下扫描注解； 在JavaConfig中注入我们自定义的Bean，因为是我们自定义的，IDE不能自动检测而显示红色，但可以正常执行：

   @Bean
   CommandLineRunner customBeanDefinitionRegistryPostProcessorClr(CustomBeanService customBeanService){
    return args -> {
        customBeanService.doSomething();
    };
   }
   

第三种：AOP

我们还可以通过基于AOP来让注解具备功能，通过拦截标注了指定注解的方法或类，然后再建言执行功能代码。如：

• AnnotationTransactionAspect：让@Transactional注解起效；
• AnnotationCacheAspect：让@Cacheable注解起效；

第四种：组合元注解

Spring的大部分的元注解，我们可以使用元注解到其它的注解，即用元注解（元数据）描述注解，从而使其它的注解具备元注解的功能，一般我们认为组合注解是元注解在新的语义下的特例。

• @Component元注解：@Service、@Repository、@Controller、@Configuration：

  @Target({ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Component //组合了@Component注解，具备了声明Bean的能力
  public @interface Service {}
  

• @Import元注解：大量的@Enable*注解：

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Import(AsyncConfigurationSelector.class) //组合了@Import注解，具备了导入配置的能力
  public @interface EnableAsync {}
  

• @Conditional元注解：@Profile以及Spring Boot的大量条件注解@ConditionalOn*

  @Target({ ElementType.TYPE, ElementType.METHOD })
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Conditional(OnClassCondition.class)
  public @interface ConditionalOnClass {}
  

  总结

  Spring框架的注解的主要工作方式大体罗列在本文，如果大家发现还有其他的Spring注解的工作方式，欢迎补充。

• RestTemplate：可同步访问HTTP服务。
• WebClient：可同步或异步访问HTTP服务。
• Feign：在微服务架构中（不限于微服务），用声明式的方式访问HTTP服务。 在Spring 6.0中，我们有了一个更方便的HTTP请求的手段，HTTP Interfaces。HTTP Interfaces类似于Spring Data的Repository或者Spring Cloud OpenFeign一样，我们只需要声明接口就可以完成工作，框架会直接给我们自动代理一个实现。

在实际使用中HTTP Interfaces和Spring Cloud OpenFeign使用感受极其类似。

下面我进行一个极其简单的演示。

1、创建Spring Boot 3工程

打开https://start.spring.io，Spring Boot版本选择3.0.0（SNAPSHOT）（当前最新版本，若有更新版本选择最新版本），Java版本选择17（Spring Boot最低支持版本），依赖选择Spring Web、Spring Reactive Web、Lombok（此时我们还是常规使用Tomcat的同步调用，添加Spring Reactive Web是为了使用WebClient）。

2、一个在线REST HTTP服务

https://jsonplaceholder.typicode.com

提供多个REST资源。

我们可以对这些资源进行增删查改的操作，本例选用todos资源。

3、编写客户端和服务端之间的数据传值对象（DTO）

根据在线资源服务的数据结构编写DTO

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Todo {
   private Long id;
   private Long userId;
   private String title;
   private Boolean completed;
}

4、编写HTTP客户端

@HttpExchange("/todos")
public interface TodoClient {

    @GetExchange("/{todoId}")
    Todo getTodo(@PathVariable Integer todoId);

    @GetExchange
    List<Todo> getTodos();

    @PostExchange
    Todo save(@RequestBody Todo todo);
}

这里和Spring WebMVC的用法是很类似的，不过它声明的是远程的资源，和Spring Cloud OpenFeign一样。

• @HttpExchange：最通用的一个注解，在类级别将会被所有方法继承，如基础路径地址；在方法级别，需要指定具体的method类型。相当于@RequestMapping。
• @GetExchange：HTTP GET请求。相当于@GetMapping。
• @PostExchange：HTTP POST请求。相当于@PostMapping。
• @PutExchange：HTTP PUT请求。相当于@PutMapping。
• @DeleteExchange：HTTP DELETE请求。相当于@DeleteMapping。
• @PatchExchange：HTTP PATCH请求。相当于@PatchMapping。

  5、注册HTTP客户端

  @Configuration
  public class ClientConfig {
    @Bean
    public TodoClient todoClient() throws Exception {
        WebClient webClient = WebClient.builder()
                .baseUrl("https://jsonplaceholder.typicode.com")
                .build();
        HttpServiceProxyFactory factory = new HttpServiceProxyFactory(WebClientAdapter.forClient(webClient));
        factory.afterPropertiesSet();
        return factory.createClient(TodoClient.class);
    }
  }
  

  我们的HTTP客户端TodoClient是利用WebClient来实现的。这块以后WebClient应该从Spring Reactive Web剥离出来，或者提供更多其他的HTTP Client的实现，这样就不需要依赖于Spring Reactive Web了。

6、演示

@SpringBootApplication
@Slf4j
public class HttpInterfacesApplication {

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

    @Bean
    CommandLineRunner clr(TodoClient todoClient){
        return args -> {
            log.info(todoClient.getTodo(1).toString());
            log.info(todoClient.save(new Todo(null, 1L, "看书", false)).toString());
            for(Todo todo : todoClient.getTodos()){
                log.info(todo.toString());
            }
        };
    }

}

结语

HTTP interfaces使用起来比RestTemplate和WebClient要简单很多，使用声明式类似于OpenFeign的方式进行远程的HTTP资源的调用，但不需要额外引用Spring Cloud OpenFeign，极大的简化了代码和提高了开发效率。

Spring Boot uses the Spring Boot Loader to lauch the Spring Boot jar file usingjava -jar.

Let's uncompress the jar file and see its structure(jar is actually a zip file):

We see three sub-folders in the uncompressed folder：BOOT-INF,META-INF,org

example.jar
 |
 +-META-INF
 |  +-MANIFEST.MF
 +-org
 |  +-springframework
 |     +-boot
 |        +-loader
 |           +-<spring boot loader classes>
 +-BOOT-INF
    +-classes
    |  +-mycompany
    |     +-project
    |        +-YourClasses.class
    +-lib
       +-dependency1.jar
       +-dependency2.jar

BOOT-INF

1. BOOT-INF/classes: application classes
2. BOOT-INF/lib: nested dependency jars
3. BOOT-INF/classpath.idx: the ordering that jars should be added to the classpath
4. BOOT-INF/layers.idx: allows a jar to be split into logical layers for Docker/OCI image creation

META-INF

META-INF/MANIFEST.MF: contains information about the files contained in the JAR file

org

spring boot loader classes

Explore the Magic

We will explore the steps of running a standalone jar file:

1. java -jar
2. Looking for the executable jar’s main entry point in the META-INF/MANIFEST.MF

   Manifest-Version: 1.0
   Main-Class: org.springframework.boot.loader.JarLauncher
   Start-Class: top.wisely.springasync.SpringAsyncApplication
   Spring-Boot-Version: 2.7.2
   Spring-Boot-Classes: BOOT-INF/classes/
   Spring-Boot-Lib: BOOT-INF/lib/
   Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
   Spring-Boot-Layers-Index: BOOT-INF/layers.idx
   

3. Main-Class: org.springframework.boot.loader.JarLauncher is the main entry point. JarLauncher

4. BecauseJarLauncher extends ExecutableArchiveLauncher and ExecutableArchiveLauncher extends Launcher

5. JarLauncher's main method:

   public class JarLauncher extends ExecutableArchiveLauncher {
   //...
    public static void main(String[] args) throws Exception {
        new JarLauncher().launch(args);
    }
   //...
   }
   

6. So the real launch(args) method is in Launcher class:

   public abstract class Launcher {
    protected void launch(String[] args) throws Exception {
       if (!isExploded()) {
           JarFile.registerUrlProtocolHandler(); 
       }
       ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator()); //①
       String jarMode = System.getProperty("jarmode"); 
       String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass(); //②
       launch(args, launchClass, classLoader);  //③
   }
   }
   

① : classLoader - Create a new LaunchedURLClassLoader instance. all BOOT-INF/classes and BOOT-INF/jar classes are loaded by LaunchedURLClassLoader .

② : launchClass - get the Start-Class from META-INF/MANIFEST.MF.

③：launch Application using args,launchClass,classLoader.

That'a all for my first English article.

1.1 线程池模式

一个线程池可以维护多个线程，这些线程等待任务来进行并发处理。线程池模式避免了频繁创建和销毁短期任务线程，复用池中的线程从而提高了性能。线程池中的线程在处理任务时是并发进行的。

该模式允许创建的线程数量及其生命周期。 我们还能够安排任务的执行并将传入的任务保持在队列（Task Queue）中。

线程池数量的大小可根据程序可用的计算资源进行调整，它通常是程序的可调参数，经过调整以优化程序的性能。 确定最佳线程池大小对于优化性能至关重要。

1.2 Java的线程池ThreadPoolExecutor

Java中的ThreadPoolExecutor是一个可扩展的线程池的实现，它提供了对很多参数的微调设置。这些参数包括：

ThreadPoolExecutor的构造器：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
  //...
    }

示例：

ThreadPoolExecutor executorPool = new ThreadPoolExecutor(5, 10, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50));

• corePoolSize：第1个参数“5”。JVM会为前5个任务创建线程，后续的任务会放进队列里，直到队列满为止（第5个参数workQueue，50个任务）。

• maximumPoolSize：第2个参数“10”。JVM最多创建10个线程，这意味着当当前正有5个线程运行着5个任务，而这时任务队列的50个任务已满，此时如果有一个新的任务到达队列，JVM将创建一个新的线程，最多创建5个，直至10个。

• keepAliveTime：第3个参数“3秒”，超出核心线程而小于最大线程的这些线程，在一定的空闲时间之后将被清除掉。

• unit：第4个参数“秒”，keepAliveTime的时间单位。

• workQueue：第5个参数new ArrayBlockingQueue<Runnable>(50)，任务队列的大小。

JVM创建线程的规则如下：

1. 如果线程数少于corePoolSize，创建新的线程来跑任务。
2. 如何线程数等于或大于corePoolSize，将任务放进队列。
3. 如果队列满了，且线程数小于maximumPoolSize，创建新的线程跑任务。
4. 如果队列满了，且线程数量大于或等于maximumPoolSize，拒绝任务。

2、Spring的多线程

Spring/Spring Boot只需要在配置类上注@EnableAsync，在需要使用单独线程的方法上使用@Async注解即可。Spring会自动检索线程池的定义，可以是org.springframework.core.task.TaskExecutor或者是java.util.concurrent.Executor的名为taskExecutor的bean。若都未找到，则使用org.springframework.core.task.SimpleAsyncTaskExecutor来处理异步方法的调用。

我们最简单可以通过自定一个名为taskExecutor的Bean即可。

@Configuration
@EnableAsync
class AsyncConfigurationByBean {
    @Bean(name="taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("poolThread-");
        executor.initialize();
        return executor;
    }

}

Spring也提供了“AsyncConfigurer”接口用来定制实现异步多线程相关的配置。

@Configuration
@EnableAsync
class AsyncConfigurationByConfigurer implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("poolThread-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return AsyncConfigurer.super.getAsyncUncaughtExceptionHandler();
    }
}

3、Spring Boot的多线程

在Spring Boot下，通过TaskExecutionAutoConfiguration自动配置类，Spring Boot给我们已经自动配置好了线程池，TaskExecutionProperties提供了相关的属性配置。在Spring Boot下我们只需要在配置类上@EnableAsync，在“application.yml”上配置即可：

spring:
  task:
    execution:
      pool:
        core-size: 5
        max-size: 10
        queue-capacity: 50
      thread-name-prefix: poolThread-

4、多线程演示

新建一个使用异步方法的类和方法：

@Service
@Slf4j
class AsyncService {
    @Async
    public void doSomething(Integer i){
        log.info("当前是循环：" + i);
    }
}

在Spring Boot入口类调用：

@SpringBootApplication
@EnableAsync 
public class SpringAsyncApplication {

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

   @Bean
   CommandLineRunner commandLineRunner(AsyncService asyncService){
      return p -> {
         for(int i = 0 ; i < 10 ; i ++){
            asyncService.doSomething(i);
         }
      };
   }
}

运行结果：

从图中可以看出我们的核心线程数量是5，你可以按照上节的“JVM创建线程的规则”来调整核心线程、最大线程、队列数量的来尝试一下观察控制台输出的结果。

5、多线程异步结果演示

我们有时候会在单一的请求中调用多个方法，在同步的方法里，我们都是顺序执行，执行完一个再执行下一个。我们可以通过Spring的AsyncResult让多个方法并发执行并聚合他们的结果，并提高性能。

我们先看一下，在同步的情况下是什么样的：

@Service
class Service1 {
    public Integer doSomething() throws InterruptedException {
        Thread.sleep(2000);
        log.info("在Service1中");
        return 1;
    }
}

@Service
class Service2 {
    public Integer doSomething() throws InterruptedException {
        Thread.sleep(2000);
          log.info("在Service2中");
        return 2 ;
    }
}

    @Bean
    CommandLineRunner commandLineRunner(Service1 service1, Service2 service2){
        return p -> {
            long start = System.currentTimeMillis();
            Integer first = service1.doSomething();
            Integer second = service2.doSomething();
            Integer sum = first + second;
            long end = System.currentTimeMillis();
            Long cost = end - start;
            log.info("结果为:" + sum + ",耗时" + cost);
        };
    }

示例中，一个线程顺序执行两个方法，执行结果为：

我们现在使用@Async使方法变成异步，且使用AsyncResult包装异步结果返回。

CompletableFuture是Java8引入的，以提供一种编写异步、非阻塞和多线程代码的简单方法。我们使用AsyncResult包装返回值，并用它的.completable()方法获得CompletableFuture对象。

@Service
@Slf4j
class Service1 {
    @Async
    public CompletableFuture<Integer> doSomething() throws InterruptedException {
        Thread.sleep(2000);
        log.info("在Service1中");
        return new AsyncResult<Integer>(1).completable();
    }
}

@Service
@Slf4j
class Service2 {
    @Async
    public CompletableFuture<Integer> doSomething() throws InterruptedException {
        Thread.sleep(2000);
        log.info("在Service2中");
        return new AsyncResult<Integer>(2).completable();
    }
}

@Bean
CommandLineRunner commandLineRunner(Service1 service1, Service2 service2){
   return p -> {
      long start = System.currentTimeMillis();
      CompletableFuture<Integer> firstData = service1.doSomething();
      CompletableFuture<Integer> secondData = service2.doSomething();
      CompletableFuture<Integer> mergeResult = firstData.thenCompose(
                                          firstValue -> secondData.thenApply(
                                                secondValue -> firstValue + secondValue
                                          )
                                    );
      long end = System.currentTimeMillis();
      Long cost = end - start;
      log.info("结果为:" + mergeResult.get() + ",耗时" + cost);
   };
}

不要抱怨遗留代码，你几乎每天都在写。

2.Stop complaining about documentation. you're a programmer. read the source code.

不要抱怨文档。你是个程序员，去读源码。

3.Change is normal. Don't get too attached to code, or to a specific way to do something.

变化是正常的。 不要太执着于代码，或者做某事的特定方式

4.When writing code, always write it like someone else will read it and can’t ask you what it does.

写代码时，始终想着以后有人要阅读这些代码，而他却不能问你这些代码是干什么的。

5.“This is not a research farm.” A good implementation that’s completed is far better than an incomplete solution that tries to achieve perfection.

“这不是研究农场。” 一个已经完成的好的实现远比一个试图达到完美的不完整的解决方案要好得多。

6.The primary job of any software engineer is delivering value

任何软件工程师的主要工作是交付价值

7.The better you can work in different styles and be consistent in their problem domains, the less you’ll get stuck at technical barriers.

你越能以不同的风格工作并在他们的“问题领域”保持一致，你就越不会陷入技术障碍（解决方案领域）。

8.Don’t fixate - stay flexible about the least essential. These things can often change without meaningful impact.

不要固执——对最不重要的事情保持灵活。 这些事情经常改变但是并没有什么有意义的影响

1. Always provide good documentation and comments to explain context and why.

总是提供良好的文档来解释上下文和原因。

10.If you don't know what to call it, you don't know what it's for.

如果你不知道怎么称呼它，你就不知道它是干什么用的。

11.There's always a simpler way to think about solving a problem, strive for simplicity, because code is a liability, not an asset

总是有一种更简单的方式来思考解决问题，力求简单，因为代码是一种责任，而不是一种资产

12.Everything is a tradeoff. Pick one based on context

一切都是权衡。 根据上下文选择一个方案

13.The first step of any project is to grossly underestimate its complexity and difficulty.

任何项目的第一步都是严重低估其复杂性和难度。

14.Don't fanatic with tech stack (language, framework, db, etc)

不要热衷于技术栈（语言、框架、数据库等）

15.Don't impress me with some complicated techniques, impress me by making the shit work.

不要用一些复杂的技术来取悦我，要让工作运行起来取悦我

16.When you start as a developer you think that the most important part of your job is the technology. Writing code.

Years passes and you realize that is writing good, readable code.

And after many years, that is in communication. Understand and be understood.

当你开始作为一名开发人员时，你认为你工作中最重要的部分是技术 - 编写代码。

几年过去了，你意识到是编写好的、可读的代码。

多年后，意识到沟通才是最重要的。 理解和被理解。

17.Languages are just tools, learn the principles of software development and picking up new tools will be easier.

语言只是工具，学习软件开发原理，学习新工具会更容易

18.Just because you can, doesn't mean you should

仅仅因为你可以，并不意味着你应该

19.Don't be afraid to ask questions, it's not a weakness to admit you don't understand something.

不要害怕提出问题，承认自己不懂并不是一种弱点

20.Don’t implement every customer request. Most of them are useless.

不要实现每个客户的要求。 他们中的大多数都是无用的

21.Don't overdo and overdo background stuff. If it works as it's supposed to, nobody cares.

22.Explain to me like I'm 5

把我当5岁孩子一样和我解释

23.There's no such thing as a dumb question

没有愚蠢的问题

24.A working solution is much better than a perfect one.

一个可行的解决方案比一个完美的解决方案要好得多

25.Don't ever cut and paste code if you don't understand what it does. Only add code to projects that you are confident you know what it does.

如果您不了解代码的作用，请不要剪切和粘贴代码。 仅将你有信心知道作用的代码添加到项目中

26.If your solution is too complicated, there is a simpler one

如果你的解决方案太复杂，有一个更简单的

27.Don’t just fix the bug. Fix its root cause.

不要只修复bug，修复问题的根源

28.The answer will come to you on the toilet.

答案会在你上厕所的时候浮现

29.Self-documenting code is the best documentation.

自注释的代码是最好的文档

30.Keep it simple, make it work, optimize later.

保持简单，让它工作，以后再优化

31.Type it, don't do copy and paste.

敲代码，不要复制粘贴

32.Don't write clever code.

不要写聪明的代码

33.Don’t push to production on Fridays.

不要在周五上线

34.Separation of concerns.

关注隔离

35.Divide and conquer

分而治之

36.Understand what customer really needs, not what they want.

了解客户真正需要什么，而不是他们想要什么

又称最小意外原则，适用于用户界面和软件设计。 它建议系统的组件（代码）应该以大多数用户期望的方式运行。 该行为不应该使用户感到惊讶或诧异，根据操作的名称和其他线索，某项操作的结果应该是明显的、一致的和可预测的。 以下是该原则的正式陈述：“如果一个必要的特征具有很高的让人惊讶的因素，则可能需要重新设计该特征。”

Principle of least effort（用小用力原则）

又称最小阻力路径（path of least resistance），本质上是说人们会通过最少的工作来完成某件事。人们（程序员）将使用最熟悉和易于使用的工具、技术来解决问题。

Principle of Least Knowledge（最小可知原则）

又称迪米特法则（Law of Demeter），根据“信息隐藏”原则，给定对象（类、方法）应尽可能少地假设其他任何事物（包括其子组件）的结构或属性。 它可以被视为最小特权原则（Principle of Lleast privilege）的推论，该原则规定一个模块只拥有其合法目的所必需的信息和资源。

The Last Responsible Moment（最后责任时刻）

不过早做出仓促的决定，而是推迟承诺且保证重要和不可逆的决策的选项开放，直到不做出决定的成本变得大于做出决定的成本。越晚地做出决策（框架、技术选型），你就有更多的信息来辅助决策。

如果您正在考虑从 Maven 迁移到 Gradle，我希望了解更多有关 Spring Boot 团队的经验是有用的。 如果你是一个快乐的Maven 用户，请继续使用和支持适合你的工具。

原文地址：https://spring.io/blog/2020/06/08/migrating-spring-boot-s-build-to-gradle

我们在 2.3.0.M1 中对 Spring Boot 进行了相当大的改变。 这是使用 Gradle 而不是 Maven 构建的项目的第一个版本。 关于迁移的 Twitter 上的帖子 有很多人问我们为什么切换以及我们看到的好处（如果有的话）。 这篇博文旨在回答这些问题。

Spring 产品套件中的每个项目都以相当自主的方式运行。 我们力求在用户最容易看到的地方保持一致性--例如 API 设计，但选择最能满足项目需求的工具就不太明显。 一个例子是构建系统。 对构建系统的改变会影响那些为项目做出贡献的人，但如果我们做对了，它对用户是没有影响的。 这导致混合了基于 Maven 和 Gradle 的构建。 例如，自 2012 年 3.2.0.M1 以来，Spring Framework就一直使用 Gradle 构建；而 Spring Boot一年后诞生的，Spring Cloud也在此后不久开始，两者当时都使用基于 Maven 的构建。 与 Spring Boot 不同的是，Spring Cloud目前没有切换的计划，因为Maven满足他们的需求。 简而言之，如果您从这篇博文中只得到一件事，那就是您应该选择最能满足您项目需求的任何工具。

我们为什么要切换?

Spring Boot 团队考虑切换到Gradle的主要原因是减少构建项目所需的时间。 在进行测试修改时，我们对反馈循环的长度感到沮丧。 等待构建完成所花费的时间增加了修复错误和实现新功能所花费的时间。 我们在其他Spring 项目中看到了Gradle 的增量和并行构建以及在第三方项目中的 Gradle 构建缓存的好处。 我们希望我们可以在 Spring Boot 的构建中获得类似的好处。

我们过去曾尝试利用 Maven 对并行构建的支持。 由于 Spring Boot 构建的复杂性，尤其是对 Invoker 插件的使用，我们的尝试失败了。 我们通过在CI（持续集成）上将构建分成四个部分来解决这个问题。 该项目的主要核心是先构建的，然后并行构建三个独立的部分。 这种安排虽然有所帮助，但CI构建任务仍然需要一个小时或更长时间。 此外，由于拆分结构是特定于 CI 构建的，它并没有使开发人员的本地构建更快。

Gradle 有一个构建结构的广泛模型，了解每个任务的输入和输出及其相互依赖关系。 这种建模的承诺是它允许任务并行运行，同时也可以增量、缓存或完全避免。 换句话说，Gradle 旨在最大限度地减少构建任何给定更改所需的工作量，并行执行必要的工作。 如果我们坚持并广泛重组 Spring Boot 的构建，那么使用 Maven 并行构建可能是可行的。 而且，如果我们使用 Gradle Enterprise 的Maven支持，我们也可以享受构建缓存和避免的好处。 然而，为了充分享受这四个方面的好处，我们觉得我们必须尝试切换到 Gradle。

我们怎么切换?

我们看到的对 Gradle 的一种批评是，它导致构建比基于 Maven 的同类产品更难维护和理解。 Gradle的灵活性允许以微妙不同的方式完成任务，即使是在同一构建中的模块之间也是如此。 如果要成功切换，我们需要避免这种情况发生。 我们已经发布了四个Spring Boot 2.3 里程碑（候选版本和 Gradle 的最终版本），看起来已经成功了。 核心团队或任何其他贡献者都没有看到任何重大的构建问题。

Spring Boot 的一个关键特性是“约定优于配置”，我们也将这种方法应用于构建。遵循“ 避免在 build.gradle 文件中包含命令式逻辑 ”的建议，我们编写了几个可以找到的小插件在项目的 buildSrc中。例如我们有一个starter plugin 应用于每个 Spring Boot 启动模块，确保它们都被一致地配置、构建和发布。我们还有一个约定插件对正在应用的其他插件做出反应，并配置诸如源代码编码、JUnit 平台的使用以及使用-parameters编译等内容。

这种方法导致 build.gradle 文件几乎完全是声明性的。 尽管我们编写了许多插件来应用我们的约定并填补Gradle 生态系统中的空白， 但迁移到 Gradle 的提交 却从代码库中删除了近 9500 行。

切换有好处吗?

在减少项目的构建时间方面，将构建迁移到 Gradle 无疑是成功的。 如上所述，在 CI 和开发人员自己的机器上，一个完整的基于 Maven 的构建需要一个小时或更长时间。 在过去的四个星期里，使用 Gradle平均成功构建时间为 9 分 22 秒，如下面的屏幕截图所示：

我们从 JDK 8 CI 构建发布快照。 专注于那些，它在过去 4 周内成功了 183 次 与 平均构建 时间 19 分 37 秒。 查看成功的本地构建，我们可以看到:

过去 4 周内成功构建了 273 个

平均构建时间为 2 分 30 秒

Gradle 吸引我们的另一个好处是 我很享受 在为 Testcontainers 做贡献时的体验。 我们希望 Spring Boot 的贡献者能够尽快克隆和构建项目。 感谢远程构建缓存，可以 3 分钟内构建完成，这包括下载大量依赖项所花费的时间。

如果您对构建性能的更多细节感兴趣，可以在我们的公共 Gradle Enterprise 实例 上获得更多数据。

除了性能改进之外，我们还开始研究其他一些可用的数据。例如，我们已经意识到我们有一些不稳定的测试一段时间了。由于它们，构建失败的频率超出了我们的预期，我们现在可以在 Tests dashboard中看到这一点。我们已经开始使用 Gradle 的易碎测试缓解来识别 CI 上发生的任何易碎测试帮助我们了解我们是否已成功解决或解决问题。

结论

我们对迁移的进展以及我们所看到的构建时间的减少感到非常满意。 CI 构建现在平均需要大约 20 分钟，比以前快 3-4 倍。 本地构建平均需要 2 分 30 秒，比以前快 20-30 倍。

我想借此机会感谢 Gradle 团队在迁移过程中提供的帮助，并慷慨地为我们提供了 Gradle Enterprise 许可证以用于我们的开源项目。 我们已经将它与 Spring Framework、Spring Security 和 Spring Boot 一起使用，其他团队计划开始将它用于基于 Gradle 和 Maven 的构建。

我还要感谢我们正在使用的各种第三方插件的维护者。 他们提出了建议的更改并合并了拉取请求，以改进对增量构建和缓存的支持。 没有它们，我们将无法实现我们所看到的构建时间的减少。

如果您正在考虑从 Maven 迁移到 Gradle，我希望了解更多有关 Spring Boot 团队的经验是有用的。 如果你是一个快乐的 Maven 用户，请继续使用和支持适合你的工具。

Spring Boot 2.0 是 2.x 线的第一个版本，于 2018 年 2 月 28 日发布。我们刚刚发布了 Spring Boot 2.7，这意味着到目前为止，我们已经将 2.x 线维护了超过 4 年。 在此期间，我们总共发布了 95 个不同的版本！

整个 Spring 团队，以及我们社区中的许多贡献者，现在都在为下一代 Spring 做准备。 我们计划在 2022 年 11 月发布 Spring Boot 3.0。下一个主要版本将基于 Spring Framework 6.0，并且需要 Java 17 或更高版本。 它也将是第一个使用 Jakarta EE 9 API (jakarta.*) 而不是 EE 8 (javax.*) 的 Spring Boot 版本。

接下来的六个月提供了一个理想的机会，为自己的项目准备这个主要的版本。 在这篇博文中，我们将为您介绍现在可以做的一些事情，以便未来的迁移工作尽可能轻松。

升级到Java 17

Spring Boot 3.0 将需要 Java 17，但您无需等到该版本升级到最新的 LTS Java 版本。 任何最近的 Spring Boot 2.x 版本都可以很好地与 Java 17 配合使用。您还可以在自己的代码库中使用 Java 17 功能（例如：record）。

如果可能，我们强烈建议您立即升级 JDK。

升级到最新的Spring Boot 2.7.x

如果您当前使用的是旧版本的 Spring Boot 2.x，我们强烈建议您升级到 Spring Boot 2.7。 当 Spring Boot 3.0 发布时，我们将提供迁移指南，但它假定您是从 Spring Boot 2.7 而不是早期版本迁移。

我们的版本说明中一直会提供升级指南。 例如，如果您要从 Spring Boot 2.6 升级到 Spring Boot 2.7，就可以按照升级指南操作（https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.7-Release-Notes#upgrading-from-spring-boot-26）。

如果您从 Spring Boot 2.5 或更早版本升级，我们不建议跳过版本。 分步升级（例如 2.5 → 2.6 → 2.7）通常比尝试直接从 2.5 → 2.7 升级更容易。

检查对已废弃代码的调用

随着 Spring Boot 的发展，我们经常会弃用方法或类并提供替代品。 我们通常会提供 12 个月的重叠期，之后会删除不推荐使用的代码。 您可以在我们的 wiki（https://github.com/spring-projects/spring-boot/wiki/Deprecations）找到该政策的详细信息。

Spring Boot 3.0 将删除所有已弃用的代码，因此我们建议您检查现有代码是否已不依赖任何已弃用的方法。 如果提示了弃用警告，值得考虑使用 -Werror Java 编译器选项来使构建失败。

从旧版 application.properties 和 application.yaml 处理迁移

Spring Boot 2.4 改变了application.properties 和 application.yaml 文件的加载方式。 大多数用户都没有注意到这个更改，但一些项目可能已经将spring.config.use-legacy-processing 属性设置为 true 以旧行为运行。

旧版本的这项支持不会出现在 Spring Boot 3.0 中，因此您应该检查您的项目是否未设置spring.config.use-legacy-processing。

使用Spring MVC的PathPatternParser

Spring MVC 提供了两种解析模式的方法。 从 Spring Boot 2.6 开始，默认使用 PathPatternParser。

一些应用可能通过设置 spring.mvc.pathmatch.matching-strategy 属性手动切换回 AntPathMatcher 实现。 尽管这将在 Spring Boot 3.0版本继续工作，但我们建议尽量使用 PathPatternParser，因为它提供了更好的性能。

检查第三方项目是否有 Jakarta EE 9 兼容版本

Jakarta EE 9 是一个新的顶级 jakarta 包，取代了 EE 8 的 javax 顶级包。 例如，Jakarta EE 8 中的 Servlet 规范使用 javax.servlet 包，但在 EE 9 中已更改为 jakarta.servlet。

一般来说，不可能在同一个项目中混合使用 Java EE 和 Jakarta EE API。 您需要确保您自己的代码以及所有第三方库都使用 jakarta.*包导入。

好消息是大多数维护良好的库都在生产 Jakarta EE 9 兼容的变体。 例如 Hibernate、Thymeleaf、Tomcat、Jetty 和 Undertow 都已经这样做了。

我们建议您花一些时间检查您使用的任何与 Jakarta EE 集成的第三方库，并检查它们是否具有兼容 EE 9 的变体。 我们发现的最常见是导入 Servlet API 的项目。

检查第三方项目是否更新了 Spring 兼容版本

Spring Framework 6.0 不会与上一代二进制兼容。 如果您正在使用提供Spring集成的第三方jar，您应该检查他们是否正在计划与 Spring Framework 6 兼容的版本。

试用Spring Boot里程碑版本

尽管我们不推荐将其用于生产，但您可以立即尝试 Spring Boot 3.0 里程碑版本，看看迁移项目的难度会有多难。 在代码的分支上尝试里程碑版本是发现任何潜在问题的好方法。

我们总是对反馈感兴趣，并且在我们发布 GA 版本之前发现错误时会让我们非常高兴。

您可以在 github.com/spring-projects/spring-boot/issues提出问题（确保告诉我们您正在使用的 Spring Boot 版本）。

考虑商业支持

Spring Boot 2.7 是 2.x 系列中的最后一个计划版本。 我们已将此版本的开源支持再延长 6 个月，直至 2023 年 11 月。

此外，对 Spring Boot 2.7 的商业支持也已延长，有效期至 2025 年 2 月。

您可以在 spring.io/projects/spring-boot 找到项目支持详细信息。 有关商业支持的详细信息，请访问 tanzu.vmware.com/spring-runtime。

由商业支持请求触发的任何发布都将始终作为开源发布，因此商业客户也可以帮助开源社区。

"I can’t understand why people are frightened of new ideas. I’m frightened of the old ones." — John Cage "我不明白为什么人们害怕新想法。 我害怕那些旧的。" - 约翰凯奇。 勇敢迈出舒适区，去冒险吧！

Gradle渐渐地火了起来，但是大部分人还在使用Maven，本文将对Gradle和Maven进行全面的比较，大家可以据此作为选型比较的依据。

Maven和Gradle都属于“构建工具”，都是用来自动化工作，并把我们的源码编译成我们要发布的构件而存在。

历史

maven初始版本诞生于2004年，Gradle诞生于2008年，Maven诞生时间更早，但二者都拥有悠久的历史，它们都拥有优秀成熟的生态。

• maven初始版本诞生于2004年

• gradle初始版本诞生于2008年

性能

Gradle引入了 Maven中缺少的几个性能优化，以提高构建性能。这也是Spring、Spring Boot源码使用Gradle替换Maven的主要原因。

Gradle 构建缓存在本地重用Gradle任务的输出，并在机器之间共享任务输出。 在许多情况下，这将加快平均构建时间。

构建缓存在分支之间切换时也非常有用，因为先前构建的输出被保留并且不必重新创建。 性能节省与上面的缓存构建相当，在测试项目中，Gradle 比 Maven 快 17 到 100 倍。

在小型的多项目编译中，Gradle 在干净构建下速度快 2-3 倍，增量更改速度快 7 倍，缓存 Gradle任务输出时速度快 14 倍。

在中型的多项目编译中，Gradle 在干净构建下速度快4-5 倍，增量更改速度快 40 倍，缓存 Gradle任务输出时速度快 13 倍。

在大型大型单体式项目中，Gradle在干净构建下速度快 2-3 倍，增量更改速度快 7 倍，缓存Gradle任务输出时速度快 3 倍。

代码

Maven使用的是基于xml的pom.xml，Gradle使用基于Groovy语言的build.gradle。我们比较一下两个相同功能的Spring Boot程序，分别使用Maven和Gradle的区别。

由图可以看出，相同情况下，build.gradle是33行代码，pom.xml是69行代码。当然这主要的原因是xml本身就是一门很啰嗦的表意语言。也因此，用xml作为配置、协议也越来越少。

由图也可以看出Gradle比Maven易读性更强且更易维护！

功能

从表中可以看出，Gradle的功能是比Maven要更丰富的。

流行度

从各类统计数据来看，Maven使用的流行度、市场占有率是有绝对的领先优势的。但是这也不能说明太多的问题，当年的ie、xp系统、诺基亚手机也都是市场的霸主。

个别的统计有显示Gradle有领先的结果，但这不能说明Gradle真正领先。如由OpenLogic发布的《2022年度开源报告显示》：

结论 由上述比较，我们发现Gradle有明显于Maven的优势。我提出下面的建议：

1、新项目尝试使用Gradle来构建！

2、尝试迁移Maven的老项目将其使用Gradle构建。（如：Spring/Spring Boot编译工具从Maven迁移到了Gradle）

不愿迁移的理由很多：

1、对于Maven很熟悉了，不用迁移到新的工具！

2、又要学习一个新东西，卷不动了！

我觉得无论作为什么样的职业，对新的东西要保持敏锐的感知和学习，不要停留在自己舒适的区域，无论Gradle有没有那么优秀，或者有没有那么多问题，我们要坚持尝试一下。

最后送给大家一句话：

"I can’t understand why people are frightened of new ideas. I’m frightened of the old ones." — John Cage "我不明白为什么人们害怕新想法。 我害怕那些旧的。" - 约翰凯奇。

勇敢迈出舒适区，去冒险吧！