springboot 启动方式装配流程自定义starter 文件加载顺序常见设计模式-EW帮帮网

自动配置：Spring Boot 会根据项目中引入的依赖自动进行配置，减少了开发者手动配置的工作量。例如，当项目中引入了 Spring Data JPA 和 MySQL 驱动时，Spring Boot 会自动配置数据源和 JPA 相关的 Bean。

起步依赖：提供了一系列的起步依赖，这些依赖是一组经过精心挑选的依赖集合，开发者可以根据项目的需求选择相应的依赖，Spring Boot 会自动处理依赖关系。例如，spring-boot-starter-web 包含了构建 Web 应用所需的所有依赖。

嵌入式服务器：支持嵌入式服务器，如 Tomcat、Jetty 等，开发者可以将应用程序打包成可执行的 JAR 文件，直接运行，无需额外部署到服务器上。

Actuator：提供了生产级别的监控和管理功能，通过 RESTful 接口或 JMX 可以方便地查看应用程序的运行状态、性能指标等信息。

命令行界面（CLI）：Spring Boot CLI 允许开发者使用命令行快速创建和运行 Spring Boot 应用程序，支持 Groovy 脚本，进一步简化了开发过程。

快速搭建 Spring Boot 项目

方式一：使用 Spring Initializr

Spring Initializr 是一个基于 Web 的工具，可帮助开发者快速生成 Spring Boot 项目的基础结构。访问 Spring Initializr，按照以下步骤操作：

选择项目的基本信息，如项目类型（Maven 或 Gradle）、语言（Java、Kotlin 或 Groovy）、Spring Boot 版本等。
添加项目依赖，例如 Spring Web 用于构建 Web 应用。
点击 Generate 按钮下载项目压缩包，解压后导入到 IDE 中即可开始开发。

方式二：使用 IDE 插件

许多 IDE 都提供了 Spring Boot 项目创建的插件，例如 IntelliJ IDEA 中的 Spring Initializr 插件。通过 IDE 插件可以更方便地创建 Spring Boot 项目，步骤与使用 Spring Initializr 类似。

示例代码

以下是一个简单的 Spring Boot Web 应用示例：

1. 创建项目并添加依赖

在 pom.xml 中添加 spring-boot-starter-web 依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. 创建主应用类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloWorldApplication {

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

3. 创建控制器类

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

4. 运行应用程序

运行 HelloWorldApplication 类的 main 方法，启动 Spring Boot 应用程序。在浏览器中访问 http://localhost:8080/hello，即可看到返回的 Hello, World! 信息。

配置文件

Spring Boot 使用 application.properties 或 application.yml 作为配置文件，用于配置应用程序的各种属性。例如，配置服务器端口：

server.port=8081

server:
  port: 8081

部署和监控

部署

Spring Boot 应用程序可以打包成可执行的 JAR 文件，通过命令行直接运行：

java -jar your-application.jar

监控

通过添加 spring-boot-starter-actuator 依赖，可以使用 Actuator 提供的监控和管理功能。例如，访问 http://localhost:8080/actuator/health 可以查看应用程序的健康状态。

与其他技术集成

Spring Boot 可以方便地与其他技术进行集成，如数据库（MySQL、Oracle、MongoDB 等）、消息队列（RabbitMQ、Kafka 等）、缓存（Redis 等）。通过添加相应的起步依赖和进行简单的配置，即可实现集成。

总之，Spring Boot 极大地简化了 Spring 应用的开发过程，提高了开发效率，是构建现代 Java 应用的首选框架之一。

Spring 时代我们一般通过 XML 文件来配置 Bean，

后来开发人员觉得 XML 文件来配置不太好，

于是 SpringBoot 注解配置就慢慢开始流行起来。

内置容器：Jetty，Tomcat，Undertow。/ˈʌndətəʊ/

启动方式

借助内置的Tomcat或者运行main方法启动

使用 @SpringBootApplication 注解，右击 Run AS -> Java Application

打包成可执行 JAR 文件启动：

通过命令行 java -jar 的方式

通过spring-boot-plugin的方式

装配原理

Spring Boot 的自动装配是其核心特性之一，它能够根据项目中引入的依赖自动配置 Spring 应用，极大地简化了开发过程。下面将详细介绍 Spring Boot 自动装配的原理。

核心注解

1. `@SpringBootApplication`

这是一个组合注解，通常标注在 Spring Boot 应用的主类上，它主要包含了以下三个重要注解：

@SpringBootConfiguration：本质上就是 @Configuration 注解，用于表明该类是一个配置类，能够定义 Bean。

@EnableAutoConfiguration：开启自动装配功能，让 Spring Boot 根据项目依赖自动配置 Spring 应用。

@ComponentScan：开启组件扫描，会自动扫描主类所在包及其子包下被 @Component、@Service、@Repository、@Controller 等注解标注的类，并将它们注册为 Bean。

2. `@EnableAutoConfiguration`

该注解是自动装配的关键，它借助 @Import 注解导入 AutoConfigurationImportSelector 类。这个类负责加载自动配置类。

自动装配的流程

1. 加载自动配置类的元数据

在 META - INF/spring.factories 文件中，定义了一系列的自动配置类。Spring Boot 在启动时，会通过 SpringFactoriesLoader 类加载这个文件，并读取其中以 org.springframework.boot.autoconfigure.EnableAutoConfiguration 为键的所有自动配置类。

例如，在 Spring Boot 的核心依赖中，spring.factories 文件可能包含如下内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
...

2. 筛选自动配置类

加载完所有自动配置类后，Spring Boot 会根据一系列的条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnProperty 等）对这些自动配置类进行筛选，只有满足条件的自动配置类才会被应用。

@ConditionalOnClass：当类路径下存在指定的类时，对应的自动配置类才会生效。

@ConditionalOnMissingBean：当容器中不存在指定类型的 Bean 时，对应的自动配置类才会生效。

@ConditionalOnProperty：当配置文件中存在指定的属性，并且属性值满足指定条件时，对应的自动配置类才会生效。

3. 配置自动配置类

筛选出满足条件的自动配置类后，Spring Boot 会将这些自动配置类作为配置类进行处理，将其中定义的 Bean 注册到 Spring 容器中。

示例代码分析

以下是一个简单的自动配置类示例：

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 当类路径下存在 MyService 类时，该自动配置类才会生效
@ConditionalOnClass(MyService.class)
@Configuration
public class MyAutoConfiguration {

    // 当容器中不存在 MyService 类型的 Bean 时，创建一个 MyService 实例并注册到容器中
    @ConditionalOnMissingBean
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

在上述示例中，MyAutoConfiguration 是一个自动配置类。@ConditionalOnClass(MyService.class) 表示只有当类路径下存在 MyService 类时，该自动配置类才会生效；@ConditionalOnMissingBean 表示只有当容器中不存在 MyService 类型的 Bean 时，才会创建一个 MyService 实例并注册到容器中。

总结

Spring Boot 的自动装配原理基于约定优于配置的思想，通过 @EnableAutoConfiguration 注解开启自动装配功能，利用 SpringFactoriesLoader 加载自动配置类的元数据，再根据条件注解筛选出满足条件的自动配置类，最后将这些自动配置类中的 Bean 注册到 Spring 容器中，从而实现自动配置的目的。

1、容器在启动的时候会调用 EnableAutoConfigurationImportSelector.class 的

selectImports方法「获取一个全面的常用 BeanConfiguration 列表」

2、之后会读取 spring-boot-autoconfigure.jar 下面的spring.factories，

「获取到所有的 Spring 相关的 Bean 的全限定名 ClassName」

3、之后继续「调用 filter 来一一筛选」，过滤掉一些我们不需要不符合条件的 Bean

4、最后把符合条件的 BeanConfiguration 注入默认的 EnableConfigurationPropertie 类里面的属性值，并且「注入到 IOC 环境当中」

@springBootApplication里面有三个主要注解

1.@SpringBootConfiguration：该注解与Configuration注解作用相同，

用来声明当前也是一个配置类(使用Configuration配置类等同于XML文件)。

2.@ComponentScan：组件扫描，默认扫描当前引导类所在的包及其子包。

将@Controller/@Service/@Component/@Repository等注解加载到IOC容器中。3.@EnableAutoConfiguration：开启自动配置功能

@ConditionalOnClass 判断是否有对应字节码

@Import：给IOC容器导入组件

@Import+@configuration+srping spi

springboot自定义starter

Spring Boot 的自定义 Starter 可以将一些通用的功能封装起来，方便在不同项目中复用。下面为你详细介绍创建自定义 Starter 的步骤和示例。

1. 创建项目结构

首先，你需要创建一个 Maven 项目，这个项目将作为自定义 Starter 的载体。在项目的 pom.xml 中添加必要的依赖。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.4</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
    </dependencies>

</project>

2. 创建配置属性类

配置属性类用于绑定应用配置文件（如 application.properties 或 application.yml）中的属性。

`MyServiceProperties.java`

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
    private String message = "Default message";

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

3. 创建服务类

服务类是自定义 Starter 提供的核心功能类。

`MyService.java`

public class MyService {
    private final String message;

    public MyService(String message) {
        this.message = message;
    }

    public String sayHello() {
        return "Hello, " + message;
    }
}

4. 创建自动配置类

自动配置类负责根据条件创建 Bean 并进行配置。

`MyServiceAutoConfiguration.java`

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(MyServiceProperties.class)
public class MyServiceAutoConfiguration {

    private final MyServiceProperties properties;

    public MyServiceAutoConfiguration(MyServiceProperties properties) {
        this.properties = properties;
    }

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService(properties.getMessage());
    }
}

5. 创建 `spring.factories` 文件

在 src/main/resources/META - INF 目录下创建 spring.factories 文件，用于指定自动配置类。

`spring.factories`

properties

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyServiceAutoConfiguration

6. 打包和使用自定义 Starter

打包

在项目根目录下执行 mvn clean install 命令，将自定义 Starter 打包并安装到本地 Maven 仓库。

使用

在其他 Spring Boot 项目的 pom.xml 中添加自定义 Starter 的依赖：

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

配置

在 application.properties 或 application.yml 中配置自定义属性：

my.service.message=Custom message

使用服务

在需要使用服务的地方注入 MyService 并调用其方法：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp implements CommandLineRunner {

    @Autowired
    private MyService myService;

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println(myService.sayHello());
    }
}

通过以上步骤，你就可以创建并使用自定义的 Spring Boot Starter 了。自定义 Starter 可以将一些常用的功能封装起来，提高代码的复用性和可维护性。

Springboot 约定优于配置

四个方面回答

1、约定优于配置是一种软件设计的范式，

它的核心思想是减少软件开发人员对于配置项的维护，从而让开发人员聚焦在业务逻辑上。

2、Springboot就是约定优于配置的产物，它是spring框架下的一个脚手架，可以快速开发spring生态下的应用程序。

3、基于传统的spring框架开发，需要做很多与业务无关配置项，像

管理jar包的依赖、

web.xml维护

dispatch-servlet.xml

应用部署到web容器

第三方组件集成到springIOC中维护。

Springboot 已经不需要了，基于约定优于配置思想。

4、Springboot 约定优于配置体现

Springboot 约定优于配置体现（springboot Starter启动依赖，它能帮助我们管理所有jar包版本）

如果当前项目依赖web jar，它会自动内置tomcat容器来运行web应用不需要单独部署。

自动装配机制的实现中通过扫描约定路径下的spring.factories文件，去识别配置类，从而进行bean的自动装载。

默认会加载resource目录下的application.properties文件

5、核心本质：更加高效、便捷实现软件系统开发维护。

jar包classPath路径下的META-INF/spring.factoires文件的所有配置类的全类名

核心思想就是约定大于配置,一切自动完成。可以大大的简化你的开发模式,集成的常用框架,它都有对应的组件支持。

搭建简单，开箱即用

要开放接口，要配置servlet

要使用IOC，得在xml里配置各种bean

配置简单，专注编码

想使用异步化，加个@EnableAsync就可以开启异步化功能

想使用AOP，加个@Aspect就可以各种拦截了

部署简单，一键启动

SpringBoot内置了嵌入式Tomcat, Jetty等容器。

自带监控

提供大量的starter

cloud.tencent.com/developer/article/1807425

约定大于配置

按约定编程，是一种软件设计范式，当存在特殊需求的时候，自定义配置即可。

spring boot的配置文件，默认是application.yml或者.properties文件，并且只能有一个。

Maven的目录结构。默认resources配置文件夹和java目录一级。一个用来写java代码，一个用来放配置文件。

@Scheduled注解

@Scheduled 注解是 Spring 框架提供的一个用于创建定时任务的注解，在 Spring Boot 应用中使用非常方便。以下从注解概述、常用属性、使用示例、注意事项等方面进行详细介绍。

注解概述

@Scheduled 注解允许开发者在方法上进行标注，使得该方法可以按照指定的时间间隔或时间点自动执行。使用这个注解可以避免编写复杂的定时任务调度代码，提高开发效率。要使用 @Scheduled 注解，需要在 Spring Boot 主应用类上添加 @EnableScheduling 注解来启用 Spring 的定时任务功能。

常用属性

@Scheduled 注解有几个常用属性，用于指定任务的执行时间和频率。

1. `fixedRate`

含义：指定任务执行的固定时间间隔，单位为毫秒。无论任务执行时间长短，下一次任务都会在上一次任务开始后的指定时间间隔后启动。
示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 5000) // 每 5 秒执行一次
    public void fixedRateTask() {
        System.out.println("Fixed rate task executed at: " + System.currentTimeMillis());
    }
}

2. `fixedDelay`

含义：指定任务执行完成后，下一次任务开始的延迟时间，单位为毫秒。即任务执行结束后，等待指定的时间间隔再启动下一次任务。
示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(fixedDelay = 3000) // 任务执行完成后，延迟 3 秒再执行下一次
    public void fixedDelayTask() {
        System.out.println("Fixed delay task executed at: " + System.currentTimeMillis());
    }
}

3. `initialDelay`

含义：指定任务首次执行的延迟时间，单位为毫秒。通常与 fixedRate 或 fixedDelay 一起使用，用于控制任务第一次启动的时间。
示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(initialDelay = 2000, fixedRate = 5000) // 首次延迟 2 秒执行，之后每 5 秒执行一次
    public void initialDelayTask() {
        System.out.println("Initial delay task executed at: " + System.currentTimeMillis());
    }
}

4. `cron`

含义：使用 Cron 表达式来指定任务的执行时间。Cron 表达式是一个字符串，由 6 或 7 个字段组成，分别表示秒、分、小时、日、月、周、年（年可选）。
示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(cron = "0 0 12 * * ?") // 每天中午 12 点执行
    public void cronTask() {
        System.out.println("Cron task executed at: " + System.currentTimeMillis());
    }
}

使用示例

以下是一个完整的使用 @Scheduled 注解的 Spring Boot 示例：

1. 创建 Spring Boot 项目

确保项目中添加了 Spring Boot 的依赖，并且 spring-boot-starter-web 依赖已包含。

2. 启用定时任务

在主应用类上添加 @EnableScheduling 注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class ScheduledTaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScheduledTaskApplication.class, args);
    }
}

3. 创建定时任务类

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 2000) // 每 2 秒执行一次
    public void task1() {
        System.out.println("Task 1 started at: " + LocalDateTime.now());
        try {
            Thread.sleep(1000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 1 ended at: " + LocalDateTime.now());
    }

    @Scheduled(cron = "0/5 * * * * ?") // 每 5 秒执行一次
    public void task2() {
        System.out.println("Task 2 started at: " + LocalDateTime.now());
    }
}

注意事项

默认是单线程执行：默认情况下，@Scheduled 注解的任务是单线程执行的。如果一个任务执行时间过长，会影响其他任务的执行。若需要并行执行任务，需要配置线程池。

Cron 表达式的正确性：使用 cron 属性时，要确保 Cron 表达式的正确性，否则任务可能无法按预期执行。

异常处理：定时任务中如果抛出异常，可能会影响后续任务的执行。因此，建议在任务方法中进行异常处理。

综上所述，@Scheduled 注解是 Spring 框架中一个非常实用的工具，可以方便地创建定时任务。开发者可以根据具体需求选择合适的属性来指定任务的执行时间和频率。

@Scheduled注解配置定时任务串行、并行

在 Spring Boot 里，@Scheduled 注解能轻松创建定时任务，而这些定时任务既可以串行执行，也能并行执行，下面为你详细介绍这两种执行方式。

串行执行定时任务

默认情况下，@Scheduled 注解创建的定时任务是串行执行的。也就是说，当一个定时任务开始执行时，其他定时任务需要等待该任务执行完毕才能开始。以下是一个串行执行定时任务的示例：

1. 创建 Spring Boot 项目

确保你的项目中添加了 Spring Boot 的依赖，并且 spring-boot-starter-web 依赖已包含。

2. 启用定时任务

在主应用类上添加 @EnableScheduling 注解来启用 Spring 的定时任务功能。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class ScheduledTaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScheduledTaskApplication.class, args);
    }
}

3. 创建定时任务类

创建一个包含 @Scheduled 注解方法的类，这些方法将作为定时任务执行。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 2000) // 每 2 秒执行一次
    public void task1() {
        System.out.println("Task 1 started at: " + LocalDateTime.now());
        try {
            Thread.sleep(3000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 1 ended at: " + LocalDateTime.now());
    }

    @Scheduled(fixedRate = 2000) // 每 2 秒执行一次
    public void task2() {
        System.out.println("Task 2 started at: " + LocalDateTime.now());
        try {
            Thread.sleep(1000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 2 ended at: " + LocalDateTime.now());
    }
}

在上述示例中，task1 和 task2 这两个定时任务默认是串行执行的。也就是说，当 task1 开始执行时，task2 需要等待 task1 执行完毕才能开始执行。

并行执行定时任务

若想让定时任务并行执行，需要配置一个线程池，让每个定时任务在不同的线程中执行。以下是实现并行执行定时任务的步骤：

1. 创建线程池配置类

创建一个配置类，配置一个线程池，用于执行定时任务。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

@Configuration
@EnableScheduling
public class SchedulingConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(5); // 创建一个包含 5 个线程的线程池
    }
}

2. 创建定时任务类

与串行执行的示例相同，创建包含 @Scheduled 注解方法的类。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 2000) // 每 2 秒执行一次
    public void task1() {
        System.out.println("Task 1 started at: " + LocalDateTime.now());
        try {
            Thread.sleep(3000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 1 ended at: " + LocalDateTime.now());
    }

    @Scheduled(fixedRate = 2000) // 每 2 秒执行一次
    public void task2() {
        System.out.println("Task 2 started at: " + LocalDateTime.now());
        try {
            Thread.sleep(1000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 2 ended at: " + LocalDateTime.now());
    }
}

在上述示例中，通过配置线程池，task1 和 task2 这两个定时任务可以并行执行。也就是说，当 task1 开始执行时，task2 可以在另一个线程中同时开始执行，无需等待 task1 执行完毕。

综上所述，默认情况下 @Scheduled 注解创建的定时任务是串行执行的，若要实现并行执行，需要配置一个线程池。

springboot文件加载顺序

在 Spring Boot 里，配置文件的加载顺序十分关键，它会影响应用程序最终使用的配置。下面为你详细介绍 Spring Boot 中配置文件的加载顺序。

1. 配置文件类型

Spring Boot 支持多种类型的配置文件，常见的有 application.properties 和 application.yml，此外还有 application-{profile}.properties 和 application-{profile}.yml 这类特定环境的配置文件。

2. 加载顺序

配置文件的加载是按照一定顺序进行的，后面加载的配置会覆盖前面加载的配置。以下是详细的加载顺序（从低优先级到高优先级）：

2.1 打包在 jar 包中的默认配置文件

classpath:/application.properties

classpath:/application.yml

这些文件是应用程序的基础配置，会最先被加载。例如，你在项目的 src/main/resources 目录下创建了 application.properties 文件，其中配置了 server.port=8080，这会作为初始的服务器端口配置。

2.2 打包在 jar 包中的特定环境配置文件

classpath:/application-{profile}.properties

classpath:/application-{profile}.yml

这里的 {profile} 代表特定的环境，比如 dev（开发环境）、prod（生产环境）等。当你激活了某个特定环境时，对应的配置文件会被加载，并且会覆盖默认配置文件中的相同配置。例如，当你激活了 dev 环境，classpath:/application-dev.properties 文件中的配置会生效。

2.3 外部的默认配置文件

file:./config/application.properties

file:./config/application.yml

这些文件位于应用程序运行目录下的 config 子目录中。如果存在这些文件，它们会覆盖打包在 jar 包中的默认配置文件。例如，你在应用程序运行的目录下创建了 config 目录，并在其中放置了 application.properties 文件，修改了 server.port=8081，那么应用程序会使用这个新的端口配置。

2.4 外部的特定环境配置文件

file:./config/application-{profile}.properties

file:./config/application-{profile}.yml

同样，{profile} 代表特定的环境。这些文件会覆盖前面所有加载的配置文件中的相同配置。例如，在 config 目录下创建 application-dev.properties 文件并修改配置，当激活 dev 环境时，该文件的配置会生效。

2.5 外部根目录下的默认配置文件

file:./application.properties

file:./application.yml

这些文件位于应用程序运行的根目录下，它们的优先级比 ./config 目录下的配置文件高。如果存在这些文件，会覆盖前面加载的所有配置。

2.6 外部根目录下的特定环境配置文件

file:./application-{profile}.properties

file:./application-{profile}.yml

这是优先级最高的配置文件，会覆盖前面所有的配置。

3. 激活特定环境

可以通过以下几种方式激活特定环境：

3.1 在 `application.properties` 或 `application.yml` 中指定

在 application.properties 中添加：

properties

spring.profiles.active=dev

在 application.yml 中添加：

spring:
  profiles:
    active: dev

3.2 通过命令行参数指定

在启动应用程序时，使用 --spring.profiles.active=dev 参数来激活 dev 环境。例如：

java -jar your-application.jar --spring.profiles.active=dev

4. 其他配置源

除了上述配置文件，Spring Boot 还支持其他配置源，如命令行参数、系统环境变量等，它们的优先级通常比配置文件高。例如，通过命令行参数 --server.port=8082 可以覆盖配置文件中设置的端口号。

综上所述，了解 Spring Boot 配置文件的加载顺序，有助于你正确配置应用程序，确保使用的配置符合预期。

Spring Boot 启动时会扫描以下 5 个位置的 application.properties 或 apllication.yml 文件，并将它们作为 Spring boot 的默认配置文件。

file:./config/ （项目根路径下的config文件夹）

file:./ （项目根路径）

classpath:/config/ （类路径下的config文件夹）

classpath:/ （类路径）

如果在不同的目录中存在多个配置文件，它的读取顺序是：

1、config/application.properties（项目同级目录中config目录下）config/application.yml

2、application.properties（项目同级目录下）application.yml

3、resources/config/application.properties（项目resources目录中config目录下）resources/config/application.yml

4、resources/application.properties（项目的resources目录下） resources/application.yml

顺序可以通过实验验证：

1~8 个位置分别定义不同的 server 端口号 9001~9008

即可验证结果顺序

注：

1、如果同一个目录下，有application.yml也有application.properties，默认先读取application.properties。

2、如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。

3、创建SpringBoot项目时，一般的配置文件放置在项目的resources目录下，因为配置文件的修改，通过热部署不用重新启动项目，而热部署的作用范围是classpath下

配置文件的生效顺序，会对值进行覆盖

Properties

Yml

等

 优先级从⾼到低，⾼优先级的配置覆盖低优先级的配置，所有配置会形成互补配置。

命令⾏参数。所有的配置都可以在命令⾏上进⾏指定；

Java系统属性（System.getProperties()）

操作系统环境变量

jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置⽂件

jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置⽂件再来加载不带profile

jar包外部的application.properties或application.yml(不带spring.profile)配置⽂件

jar包内部的application.properties或application.yml(不带spring.profile)配置⽂件

@Configuration注解类上的@PropertySource

链接：SpringBoot配置文件——加载顺序 - 简书

springboot 启动Tomcat

Spring Boot 默认内置了 Tomcat 服务器，能够轻松实现嵌入式 Tomcat 的启动。以下将详细介绍 Spring Boot 启动 Tomcat 的相关内容，包含基本原理、启动步骤、配置修改以及外置 Tomcat 部署的情况。

基本原理

Spring Boot 运用自动配置机制，当检测到项目中存在 spring-boot-starter-web 依赖时，会自动配置嵌入式 Tomcat 服务器。通过 SpringApplication.run() 方法启动应用程序，同时也会启动内置的 Tomcat 服务器，从而能够处理 HTTP 请求。

启动步骤

1. 创建 Spring Boot 项目

你可以使用 Spring Initializr（https://start.spring.io/）来创建一个新的 Spring Boot 项目，确保在依赖中添加 Spring Web，此依赖包含了 spring-boot-starter-web，会自动引入 Tomcat 服务器。

2. 编写主应用类

在项目中创建主应用类，通常会添加 @SpringBootApplication 注解，并包含 main 方法。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

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

3. 启动应用程序

运行主应用类的 main 方法，Spring Boot 会自动启动内置的 Tomcat 服务器。在控制台输出中，你会看到类似以下的信息，表明 Tomcat 已经成功启动：

Tomcat started on port(s): 8080 (http) with context path ''

修改 Tomcat 配置

你可以通过配置文件（如 application.properties 或 application.yml）来修改 Tomcat 的默认配置。

使用 `application.properties`

properties

# 修改服务器端口
server.port=8081

# 设置上下文路径
server.servlet.context-path=/demo

使用 `application.yml`

server:
  port: 8081
  servlet:
    context-path: /demo

部署到外置 Tomcat

如果你希望将 Spring Boot 应用部署到外置的 Tomcat 服务器，可以按照以下步骤操作：

1. 修改打包方式

在 pom.xml 中，将打包方式从 jar 改为 war：

<packaging>war</packaging>

2. 排除嵌入式 Tomcat

在 pom.xml 中，排除嵌入式 Tomcat 的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

3. 继承 `SpringBootServletInitializer`

创建一个类继承 SpringBootServletInitializer，并重写 configure 方法：

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(DemoApplication.class);
    }
}

4. 打包并部署

使用 Maven 命令 mvn clean package 打包项目，生成的 war 文件可以部署到外置的 Tomcat 服务器中。

通过以上步骤，你可以在 Spring Boot 中启动内置的 Tomcat 服务器，也可以将应用部署到外置的 Tomcat 服务器上。

1. ⾸先，SpringBoot在启动时会先创建⼀个Spring容器

2. 在创建Spring容器过程中，会利⽤@ConditionalOnClass技术来判断当前classpath中是否存在 Tomcat依赖，如果存在则会⽣成⼀个启动Tomcat的Bean

3. Spring容器创建完之后，就会获取启动Tomcat的Bean，并创建Tomcat对象，并绑定端⼝等，然后启动Tomcat。

tomcat配置优化

对 Tomcat 进行配置优化能够提升其性能、稳定性与安全性，以下将从性能、稳定性和安全性三个方面为你详细介绍优化配置的方法。

性能优化

1. 调整线程池参数

Tomcat 使用线程池来处理请求，合理调整线程池参数可以提高并发处理能力。在 server.xml 文件中找到 <Connector> 元素，修改以下参数：

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="200"
           minSpareThreads="50"
           maxSpareThreads="150"
           acceptCount="100" />

maxThreads：最大线程数，即 Tomcat 能够同时处理的最大请求数。根据服务器的硬件资源和应用的并发需求进行调整。

minSpareThreads：最小空闲线程数，Tomcat 启动时会创建的初始线程数。

maxSpareThreads：最大空闲线程数，超过这个数量的空闲线程会被销毁。

acceptCount：当所有线程都在处理请求时，允许在队列中等待的最大请求数。

2. 启用 APR 模式

APR（Apache Portable Runtime）是一个高性能的 I/O 模型，能够显著提高 Tomcat 的性能。首先需要安装 APR 库和 Native 库，然后在 server.xml 中修改 <Connector> 元素：

<Connector port="8080" protocol="org.apache.coyote.http11.Http11AprProtocol"
           connectionTimeout="20000"
           redirectPort="8443" />

3. 调整压缩配置

启用响应压缩可以减少数据传输量，提高网络传输效率。在 server.xml 中修改 <Connector> 元素：

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           compression="on"
           compressionMinSize="2048"
           noCompressionUserAgents="gozilla, traviata"
           compressableMimeType="text/html,text/xml,text/plain,text/css,text/javascript,application/javascript" />

compression：启用压缩，值为 on。

compressionMinSize：最小压缩大小，超过这个大小的响应才会被压缩。

compressableMimeType：指定需要压缩的 MIME 类型。

稳定性优化

1. 调整 JVM 参数

合理调整 JVM 参数可以提高 Tomcat 的稳定性和性能。在 catalina.sh（Linux）或 catalina.bat（Windows）文件中添加以下参数：

JAVA_OPTS="-Xms512m -Xmx1024m -XX:MaxPermSize=256m -XX:+UseParallelGC"

-Xms：JVM 初始堆大小。

-Xmx：JVM 最大堆大小。

-XX:MaxPermSize：永久代最大大小（JDK 8 及以上版本使用 -XX:MetaspaceSize 和 -XX:MaxMetaspaceSize）。

-XX:+UseParallelGC：使用并行垃圾回收器。

2. 配置连接超时时间

在 server.xml 中修改 <Connector> 元素的 connectionTimeout 参数，避免长时间占用连接资源：

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

3. 监控和日志配置

配置 Tomcat 的监控和日志功能，及时发现和解决问题。可以使用 Access Log 记录所有请求信息，在 server.xml 中添加以下配置：

<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
       prefix="localhost_access_log" suffix=".txt"
       pattern="%h %l %u %t &quot;%r&quot; %s %b" />

安全性优化

1. 关闭不必要的服务和端口

检查 server.xml 文件，关闭不必要的服务和端口，减少安全风险。例如，关闭 shutdown 端口：

<Server port="-1" shutdown="SHUTDOWN">

2. 配置安全的 Connector

在 server.xml 中配置安全的 <Connector>，使用 HTTPS 协议：

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="150" SSLEnabled="true">
    <SSLHostConfig>
        <Certificate certificateFile="conf/localhost.crt"
                     certificateKeyFile="conf/localhost.key"
                     type="RSA" />
    </SSLHostConfig>
</Connector>

3. 防止目录遍历攻击

在 web.xml 中添加以下配置，防止目录遍历攻击：

<init-param>
    <param-name>listings</param-name>
    <param-value>false</param-value>
</init-param>

通过以上配置优化，可以提高 Tomcat 的性能、稳定性和安全性。在进行优化时，需要根据服务器的硬件资源和应用的实际需求进行调整。

    uri-encoding: UTF-8

    #最小线程数

    min-spare-threads: 10

    #最大线程数

    max-threads: 200

    #最大链接数

    max-connections: 10000

    #最大等待队列长度

    accept-count: 100

    #请求头最大长度kb

    max-http-header-size: 1048576

    #请请求体最大长度kb

    #max-http-post-size: 2097152

Spring Boot 中常见设计模式

在 Spring Boot 开发里，合理运用设计模式能让代码结构更清晰、可维护性和可扩展性更强。下面为你介绍 Spring Boot 中常见的设计模式及其应用场景。

单例模式

概念

单例模式确保一个类仅有一个实例，并且提供一个全局访问点。

Spring Boot 中的应用

Spring 框架默认采用单例模式创建 Bean，也就是说在整个应用的生命周期里，Spring 容器只会创建某个 Bean 的一个实例。

import org.springframework.stereotype.Service;

@Service
public class SingletonService {
    public void doSomething() {
        System.out.println("SingletonService is doing something.");
    }
}

在上述代码里，SingletonService 类被 @Service 注解标注，Spring 容器会把它当作单例 Bean 来管理。

工厂模式

概念

工厂模式定义一个创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

Spring Boot 中的应用

Spring 的 Bean 工厂就是工厂模式的典型应用。借助 BeanFactory 或者 ApplicationContext 来创建和管理 Bean。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class BeanFactoryExample {
    @Autowired
    private ApplicationContext context;

    public <T> T getBean(Class<T> clazz) {
        return context.getBean(clazz);
    }
}

在上述代码中，BeanFactoryExample 类通过 ApplicationContext 获取 Bean 实例，类似于一个简单的工厂。

代理模式

概念

代理模式为其他对象提供一种代理以控制对这个对象的访问。

Spring Boot 中的应用

Spring AOP（面向切面编程）运用代理模式来实现切面逻辑的织入。Spring 提供了两种代理方式：JDK 动态代理和 CGLIB 代理。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("Before method execution");
    }
}

在上述代码中，LoggingAspect 类是一个切面，Spring AOP 会为目标对象创建代理，在目标方法执行前执行 beforeAdvice 方法。

观察者模式

概念

观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。

Spring Boot 中的应用

Spring 的事件机制就是观察者模式的应用。通过发布事件和监听事件来实现组件之间的解耦。

import org.springframework.context.ApplicationEvent;

// 自定义事件类
public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }
}

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

// 事件监听器
@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("Received custom event: " + event);
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

// 事件发布者
@Service
public class EventPublisher {
    private final ApplicationContext context;

    public EventPublisher(ApplicationContext context) {
        this.context = context;
    }

    public void publishEvent() {
        CustomEvent event = new CustomEvent(this);
        context.publishEvent(event);
    }
}

在上述代码中，CustomEvent 是自定义事件类，CustomEventListener 是事件监听器，EventPublisher 是事件发布者。当 EventPublisher 发布事件时，CustomEventListener 会收到通知并执行相应的逻辑。

策略模式

概念

策略模式定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。

Spring Boot 中的应用

在 Spring Boot 里，策略模式可用于根据不同的条件选择不同的业务逻辑实现。

// 策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略实现类
import org.springframework.stereotype.Component;

@Component
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using credit card.");
    }
}

import org.springframework.stereotype.Component;

@Component
public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " using PayPal.");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

// 策略上下文
@Service
public class PaymentContext {
    private final Map<String, PaymentStrategy> paymentStrategies = new HashMap<>();

    @Autowired
    public PaymentContext(CreditCardPayment creditCardPayment, PayPalPayment payPalPayment) {
        paymentStrategies.put("creditCard", creditCardPayment);
        paymentStrategies.put("paypal", payPalPayment);
    }

    public void executePayment(String strategy, double amount) {
        PaymentStrategy paymentStrategy = paymentStrategies.get(strategy);
        if (paymentStrategy != null) {
            paymentStrategy.pay(amount);
        } else {
            System.out.println("Invalid payment strategy.");
        }
    }
}

在上述代码中，PaymentStrategy 是策略接口，CreditCardPayment 和 PayPalPayment 是具体的策略实现类，PaymentContext 是策略上下文，根据不同的策略名称选择不同的支付方式。

模板模式在 Spring Boot 的数据访问层中较为常用。例如，Spring 提供的 JdbcTemplate 就是模板模式的体现。它定义了数据访问操作的基本模板，把不变的流程（如资源获取、释放，事务管理等）固定下来，而把具体的 SQL 查询、更新等操作留给子类或调用者实现，既保证了操作流程的规范性，又提供了足够的灵活性。

观察者模式也存在于 Spring Boot 中。Spring 的事件机制就是基于观察者模式构建的。例如，当一个应用事件（如上下文启动、关闭事件）发生时，事件发布者会将事件发布出去，而事件监听者会在接收到事件信号后执行相应的操作，实现了对象之间的松散耦合。

代理模式同样重要。在 Spring Boot 的 AOP（Aspect - J Auto Configuration）中，代理模式发挥着关键作用。通过创建代理对象来代替原始对象执行某些操作，从而实现对原始对象的功能扩展或控制。比如，在实现事务管理、日志记录等功能时，会通过代理对象对目标对象进行拦截和处理，且不改变目标对象的内部结构。

装饰器模式也有应用。在需要对已有 Bean 的功能进行扩展或修饰时，装饰器模式可以派上用场。通过对现有 Bean 添加装饰器，可以在不改变 Bean 原有功能的基础上，增加新的功能特性，比如对一个简单的服务 Bean 添加缓存装饰器，就可以提高服务的响应速度。

组件

Spring Boot 提供了多种组件，这些组件可以帮助开发者快速构建功能丰富、高效稳定的应用程序。以下是一些常见的 Spring Boot 组件及其介绍：

1. Spring Boot Starter 系列

Spring Boot Starter 是一系列依赖的集合，它将相关的依赖打包在一起，方便开发者引入和使用。常见的 Starter 组件如下：

Spring Boot Starter Web

功能：用于构建基于 Spring MVC 的 Web 应用程序，包含了嵌入式 Tomcat 服务器、Spring MVC、Jackson 等依赖，可快速搭建 RESTful API 或 Web 页面。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Spring Boot Starter Data JPA

功能：简化了使用 JPA（Java Persistence API）进行数据库访问的过程，集成了 Hibernate 作为 JPA 实现，支持多种数据库，如 MySQL、Oracle 等。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Spring Boot Starter Security

功能：为 Spring Boot 应用提供安全认证和授权功能，支持多种认证方式，如基于表单的认证、OAuth2 认证等。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. Spring Boot Actuator

功能：提供生产级别的监控和管理功能，通过 RESTful 接口或 JMX 可以方便地查看应用程序的运行状态、性能指标、健康检查等信息。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置 application.properties 以暴露更多端点：

properties

management.endpoints.web.exposure.include=*

3. Spring Boot DevTools

功能：提供开发时的增强功能，如自动重启应用程序、实时加载静态资源等，提高开发效率。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

4. Spring Boot Configuration Processor

功能：用于生成配置元数据，当在配置文件中使用自定义配置属性时，IDE 可以提供自动补全和提示功能。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

5. Spring Boot Test

功能：提供测试框架和工具，支持单元测试、集成测试等，集成了 JUnit、Mockito、Spring Test 等测试框架。
示例：在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

6. Spring Boot Admin

功能：用于监控和管理 Spring Boot 应用程序，提供可视化界面，可查看应用的健康状态、日志、环境信息等。
使用步骤：
- 服务端：创建一个 Spring Boot 项目，添加 spring-boot-admin-starter-server 依赖。

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
    <version>3.1.1</version>
</dependency>

在主应用类上添加 @EnableAdminServer 注解。

客户端：在需要监控的 Spring Boot 应用中添加 spring-boot-admin-starter-client 依赖，并配置服务端地址。

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>3.1.1</version>
</dependency>

properties

spring.boot.admin.client.url=http://localhost:8080

以上是 Spring Boot 中一些常见的组件，开发者可以根据项目需求选择合适的组件来构建应用程序。

任务调度

@Scheduled注解用于在特定时间段内触发调度程序。 /ˈʃedjuːld/

Cron表达式 ,字符串被切割为6个或者7个域

从左到右（用空格隔开）：秒分小时月份中的日期月份星期中的日期年份(可选，留空)

{Seconds} {Minutes} {Hours} {DayofMonth} {Month} {DayofWeek} {Year}

基于注解@Scheduled默认为单线程，开启多个任务时，任务的执行时机会受上一个任务执行时间的影响

@Configuration      //1.主要用于标记配置类，兼备Component的效果。

@EnableScheduling   // 2.开启定时任务

public class SaticScheduleTask {

    //3.添加定时任务

    @Scheduled(cron = "0/5 * * * * ?")

    //或直接指定时间间隔，例如：5秒

    //@Scheduled(fixedRate=5000)

    private void configureTasks() {

        System.err.println("执行静态定时任务时间: " + LocalDateTime.now());

    }

}

定时任务调度框架： Quartz、Elastic-job  [ɪˈlæstɪk] 是当当开源的一款非常好用的作业框架、XXL-JOB

Spring Boot Cache

@EnableCaching开启基于注解的缓存
@Cacheable：针对方法配置，能够根据方法的请求参数对其结果进行缓存
@CacheEvict：清空缓存 [ɪˈvɪkt]
@CachePut：既调用方法，又更新缓存数据
@Caching：定义复杂的缓存规则

  //@Cacheable(cacheNames = "user",key = "#id")

    @Cacheable(cacheNames = "user",key = "#id",,condition = "#id > 0")

    //当参数为对象格式时，key = #参数值.id 或者 #p0.id

    //当参数值为id的时候，可直接 key = “#id” 或是 #p0

    //@Cacheable(cacheNames = "user")

    @Override

    public Suser selectByPrimaryKey(int id) {

        return userDao.selectByPrimaryKey(id);

    }

@Cacheable的参数：

cacheNames：缓存的名称，必须至少指定一个

key：缓存的关键字，可以为空，按照spEL表达式编写，如果为空则按照所有参数进行组合定义

condition：使用缓存的条件，可以为空，使用spEl表达式编写，结果为“true”才执行缓存，“false”则不缓存

自带线程池

springboot自动装配的两个常用线程池对象，如果引入了spring-boot-autoconfigure这个依赖，

则会自动装配两个线程池对象ThreadPoolTaskExecutor，ThreadPoolTaskScheduler

（参考org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration。），

分别对应jdk的两个线程池，是静态代理增强，故ThreadPoolTaskScheduler的api是最丰富的。

Spring默认线程池simpleAsyncTaskExecutor

然后还需要在@SpringBootApplication启动类或者@Configuration注解类上添加注解@EnableAsync启动多线程注解。

springboot自带的线程池ThreadPoolTaskExecutor、ThreadPoolTaskScheduler的深入应用——异步任务监听回调,任务中断案例_threadpooltaskexecutor submitlistenable-CSDN博客

@ControllerAdvice注解，用于全局处理异常

@ExceptionHandler注解

自定义异常：定义一个扩展RuntimeException类的子类

拦截器

@Component注解，它应该实现HandlerInterceptor接口。

必须使用WebMvcConfigurerAdapter向InterceptorRegistry注册此Interceptor

https://www.yiibai.com/spring-boot/spring_boot_interceptor.html

Cors 跨资源共享

方法一、直接采用SpringBoot的注解@CrossOrigin（也支持SpringMVC）

方法二、处理跨域请求的Configuration

增加一个配置类，CrossOriginConfig.java。继承WebMvcConfigurerAdapter或者实现WebMvcConfigurer接口，其他都不用管，项目启动时，会自动读取配置。

方法三、采用过滤器（filter）的方式

参考：Springboot处理CORS跨域请求的三种方法-腾讯云开发者社区-腾讯云

springboot 启动方式 装配流程 自定义starter 文件加载顺序 常见设计模式

springboot介绍

核心特性

快速搭建 Spring Boot 项目

方式一：使用 Spring Initializr

方式二：使用 IDE 插件

示例代码

1. 创建项目并添加依赖

2. 创建主应用类

3. 创建控制器类

4. 运行应用程序

配置文件

部署和监控

部署

监控

与其他技术集成

启动方式

装配原理

核心注解

1. @SpringBootApplication

2. @EnableAutoConfiguration

自动装配的流程

1. 加载自动配置类的元数据

2. 筛选自动配置类

3. 配置自动配置类

示例代码分析

总结

springboot自定义starter

1. 创建项目结构

2. 创建配置属性类

MyServiceProperties.java

3. 创建服务类

MyService.java

4. 创建自动配置类

MyServiceAutoConfiguration.java

5. 创建 spring.factories 文件

spring.factories

6. 打包和使用自定义 Starter

打包

使用

配置

使用服务

Springboot 约定优于配置

@Scheduled注解

注解概述

常用属性

1. fixedRate

2. fixedDelay

3. initialDelay

4. cron

使用示例

1. 创建 Spring Boot 项目

2. 启用定时任务

3. 创建定时任务类

注意事项

@Scheduled注解配置定时任务串行、并行

串行执行定时任务

1. 创建 Spring Boot 项目

2. 启用定时任务

3. 创建定时任务类

并行执行定时任务

1. 创建线程池配置类

2. 创建定时任务类

springboot文件加载顺序

1. 配置文件类型

2. 加载顺序

2.1 打包在 jar 包中的默认配置文件

2.2 打包在 jar 包中的特定环境配置文件

2.3 外部的默认配置文件

2.4 外部的特定环境配置文件

2.5 外部根目录下的默认配置文件

2.6 外部根目录下的特定环境配置文件

3. 激活特定环境

3.1 在 application.properties 或 application.yml 中指定

3.2 通过命令行参数指定

4. 其他配置源

配置文件的生效顺序，会对值进行覆盖

springboot 启动Tomcat

基本原理

启动步骤

springboot 启动方式装配流程自定义starter 文件加载顺序常见设计模式

1. `@SpringBootApplication`

2. `@EnableAutoConfiguration`

`MyServiceProperties.java`

`MyService.java`

`MyServiceAutoConfiguration.java`

5. 创建 `spring.factories` 文件

`spring.factories`

1. `fixedRate`

2. `fixedDelay`

3. `initialDelay`

4. `cron`

3.1 在 `application.properties` 或 `application.yml` 中指定

使用 `application.properties`

使用 `application.yml`

3. 继承 `SpringBootServletInitializer`