springboot面试题

简介

Spring Boot来简化Spring应用开发的框架,它遵循"约定优先于配置"的核心思想， 使用SpringBoot只需很少的配置，大部分的时候直接使用默认的配置即可。

使用springBoot可以快捷的开发应用程序

springboot特点

优点：

• 容易上手，提供了常用的默认配置，提升开发效率
• 封装了各种启动器，可以方便的在各种应用场景使用，避免依赖手动引入和版本冲突

缺点：

入门容易精通难：因为很多东西都封装好了，所以就容易忽略对原理的学习，优化的话就需要多了解了解原理

过度配置：Spring Boot 的一个主要特点是它的自动配置，但这也可能成为一个问题。在某些情况下，Spring Boot 可能会自动配置你不需要或不想要的东西，这可能会导致性能问题或不可预见的行为。

 SpringBoot、Spring MVC有什么区别？

Spring MVC是一个实现了Web MVC设计模式的Web框架，主要用于构建Web层。

Spring Boot则是一个简化Spring应用开发的框架，设计目标是使开发人员能够快速构建独立、可运行的Spring应用程序。

在Spring MVC中，通常需要配置多个配置文件，如Web.xml(配置类实例化监听器，过滤器，servlet)、SpringMVC.xml（视图解析器、处理器映射、拦截器、消息转换器等）等，项目结构相对复杂。

Spring Boot则大大简化了配置过程，它采用约定优于配置的方式，通过自动化配置和默认设置减少了开发者的工作量。

Spring MVC应用的启动相对繁琐，需要手动配置和启动多个组件。

Spring Boot则提供了内嵌的Web容器，使得构建和启动独立的Web应用程序变得更加简单。

Spring MVC虽然功能强大，但与其他技术的整合通常需要手动配置。

Spring Boot则提供了大量的Starter，可以方便地与各种常见技术整合

Spring Boot在简化配置、快速构建应用程序方面更具优势，而Spring MVC则更注重灵活性和自定义配置。

简述 Spring Boot 的目录结构

Spring Boot的目录结构通常遵循标准的Maven或Gradle项目结构，但有一些特定的目录和文件在Spring Boot应用程序中具有特殊的含义。以下是Spring Boot应用程序的常见目录结构：

- src/main/java：主要的Java源代码目录，包含应用程序的Java类文件。
- src/main/resources：资源文件目录，包含应用程序的配置文件、静态资源文件、模板文件等。
- src/test/java：测试代码目录，包含应用程序的单元测试和集成测试的Java类文件。
- src/test/resources：测试资源文件目录，包含测试代码所需的配置文件、测试数据等。
- pom.xml（Maven项目）或build.gradle（Gradle项目）：项目的构建配置文件，定义了项目的依赖、插件和构建脚本等。
- src/main/resources/application.properties或src/main/resources/application.yml：Spring Boot的主要配置文件，用于配置应用程序的属性和特性。
- src/main/resources/static：静态资源文件目录，包含应用程序的CSS、JavaScript、图片等静态资源文件。
- src/main/resources/templates：模板文件目录，包含应用程序的视图模板文件，如Thymeleaf、Freemarker等模板引擎的模板文件。
- src/main/resources/static：静态资源文件目录，包含应用程序的CSS、JavaScript、图片等静态资源文件。

springboot是如何简化开发过程的

• 默认配置：springboot提供了各种框架的默认配置，可以方便快速进入开发阶段
• 简化 Maven 配置：pring Boot 提供了一系列的“starters”依赖，这些依赖可以简化 Maven 的依赖管理。你只需要添加一个 starter，Spring Boot 就会自动引入所有相关的依赖。
• 无需 XML 配置：Spring Boot 不需要任何复杂的 XML 配置。所有的配置都可以通过简单的属性文件、YAML 文件或者环境变量进行。
• 嵌入式 web容器：Spring Boot 支持嵌入式的 Tomcat 和 Jetty 服务器，开发者不需要在本地安装任何服务器，就可以进行应用程序的开发和测试。+

如何在 Spring Boot 启动的时候运行一些特定的代码

可以通过实现ApplicationRunner或CommandLineRunner接口来实现。

1. ApplicationRunner接口：该接口定义了一个run方法，用于在Spring Boot应用程序启动后执行特定的代码。run方法接收一个ApplicationArguments对象作为参数，可以用于获取命令行参数。

   @Component
   public class MyApplicationRunner implements ApplicationRunner {

       @Override
       public void run(ApplicationArguments args) throws Exception {
           // 在应用程序启动后执行的代码
       }
   }

CommandLineRunner接口：该接口也定义了一个run方法，用于在Spring Boot应用程序启动后执行特定的代码。run方法接收一个String数组作为参数，可以用于获取命令行参数。

   @Component
   public class MyCommandLineRunner implements CommandLineRunner {
       @Override
       public void run(String... args) throws Exception {
           // 在应用程序启动后执行的代码
       }
   }

ApplicationRunner和CommandLineRunner接口的实现类可以有多个，它们的执行顺序可以通过@Order注解或实现Ordered接口来控制。

它们的区别主要体现在参数的不同和使用场景的不同。

1. 参数类型：
- ApplicationRunner接口的run方法接收一个ApplicationArguments对象作为参数。ApplicationArguments对象提供了对应用程序启动时传递的命令行参数和选项的访问。
- CommandLineRunner接口的run方法接收一个String数组作为参数。该数组包含了应用程序启动时传递的命令行参数。

2. 使用场景：
- ApplicationRunner接口适用于需要访问和处理更复杂命令行参数的场景。例如，当应用程序需要处理命令行选项、非标准参数格式或自定义参数解析逻辑时，可以使用ApplicationRunner接口。
- CommandLineRunner接口适用于简单的命令行参数处理场景。例如，当应用程序只需要获取和使用命令行参数的值时，可以使用CommandLineRunner接口。

springboot内嵌web容器说明下

Spring Boot内置了三种常用的服务器，分别是Tomcat、Jetty和Undertow

Spring Boot 默认使用的内置服务器是 Tomcat，但你也可以通过添加相应的 Spring Boot Starter 依赖来切换到其他服务器，如 Jetty 

需要在你的 pom.xml 文件中添加 spring-boot-starter-web 依赖,打jar包后直接进行java -jar myapp.jar来运行myapp应用程序

使用内嵌还是使用独立的服务器:

看项目需求是什么样的，使用内嵌的更简单、方便、不需要去安装和维护tomcat；使用独立的性能更高，有更多的配置选项，也方便对tomcat进行监控

SpringBoot需要独立的容器运行吗

Spring Boot应用程序不需要独立的容器来运行。Spring Boot内嵌了一个Servlet容器（如Tomcat、Jetty或Undertow），可以直接将应用程序打包成可执行的JAR文件，并通过Java命令来启动应用程序。

这种方式称为"内嵌式容器"，它将应用程序和Servlet容器打包在一起，使得应用程序可以独立运行，不需要额外安装和配置外部的Servlet容器。

当你使用Spring Boot创建一个Web应用程序时，只需编写一个主类，并在该类上添加@SpringBootApplication注解，然后使用mvn package命令构建项目。构建完成后，你可以使用java -jar命令来启动应用程序，Spring Boot会自动启动内嵌的Servlet容器，并加载应用程序

这种内嵌式容器的方式使得Spring Boot应用程序的部署和运行变得非常简单和便捷，Spring Boot还提供了一些配置选项，可以对内嵌式容器进行自定义和调整，以满足特定的需求。

springboot是如何做到避免xml配置的

 注解驱动开发：Spring Boot使用了大量的注解来驱动配置，Spring Boot 鼓励使用注解来配置和管理应用程序的各个组件。通过使用注解，你可以在类或方法级别上添加特定的注解，告诉 Spring Boot 如何配置和处理这些组件

自动配置：Spring Boot 提供了大量的自动配置类，这些类根据你的项目的依赖和配置自动配置 Spring 应用程序的各个组件。例如，如果你在项目中添加了 Spring Data JPA 的依赖，Spring Boot 将自动配置 JPA 相关的 Bean，无需手动编写 XML 配置。

Spring Boot使用了自动配置机制。

约定大于配置：Spring Boot 遵循一些约定，根据这些约定自动配置应用程序。例如，Spring Boot 默认会扫描主应用程序类所在的包及其子包，自动注册组件。这意味着你无需显式配置组件扫描。

外部化配置：Spring Boot 支持将应用程序的配置信息外部化，可以使用属性文件、YAML 文件、环境变量等来配置应用程序的行为。这样可以避免在 XML 配置中硬编码大量的配置信息。

如何确定使用哪些自动化配置

自动化配置类(xxxAutoConfiguration类)上面标注有好多@Conditional开头的注解（spring提供的注解），这种注解作用是判断达没达到加载配置类到容器的要求，达到要求才会实例化这个配置类的实例交给spring管理，并加载指定配置。

判断条件：类路径上是否存在特定的类、配置文件中的属性设置、是否存在某个 bean 等条件

如：

@ConditionalOnJava 系统的java版本是否符合要求

@ConditionalOnMissingBean 容器中不存在指定Bean；

@ConditionalOnWebApplication  当前是否是web环境

自动配置的原理

官网上有说明，我们可以配置的内容：

https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#boot-features-external-config

J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure.jar；该包中定义了很多场景的自动配置类

 

原理：

springboot项目启动时会加载@SpringBootApplication标注的启动类，开启自动配置功能。

自动配置功能是依靠@EnableAutoConfiguration注解来完成的，该注解会扫描所有jar包类路径下的META-INF/spring.factories文件，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中，它的值指定了各种配置类（xxxAutoConfiguration类的命名方式），每一个这样的  xxxAutoConfiguration类都会完成各自的自动化配置：会从配置文件中获取指定key的值（如spring.http.encoding的值）映射到xxxProperties类中，xxxProperties中定义了很多配置的默认值，所以配置文件能配置什么就可以参照某个功能对应的这个属性类；根据这些属性类各种功能就能获取到需要的配置值了。

 

自动配置原理是基于Spring框架的条件注解和自动配置类的机制实现的。自动配置是通过@EnableAutoConfiguration注解来实现的。这个注解会启用Spring Boot的自动配置机制，并根据项目的依赖和配置来自动配置Spring应用程序的各个组件。

自动配置的过程主要包括以下几个步骤：

1. Spring Boot会根据项目的依赖和配置信息，扫描classpath下的META-INF/spring.factories文件，该文件中定义了各个自动配置类的全限定名。

2. Spring Boot会根据条件注解（如@ConditionalOnClass、@ConditionalOnBean等）来判断是否满足自动配置的条件。只有满足条件的自动配置类才会被加载。

3. 当满足条件的自动配置类被加载时，Spring Boot会根据自动配置类中的配置信息，自动配置相应的组件（如数据源、事务管理器、Web容器等）。

4. 如果项目中存在自定义的配置，那么自定义的配置会覆盖自动配置的默认值。

 

如何能看那些自动配置类生效，那些不生效

在application.properties/yml文件指定debug=true启动项目打印的日志中就可以看到

 

classpath说明：

• 是jvm用来查找类文件和其他资源文件（如属性文件、XML 配置等）的所有地方
• 编译后的类目录：通常是项目的 target/classes 目录
• 依赖的 JAR 文件：通常位于项目的 target/lib
• 环境变量和 JVM 参数：classpath 也可以通过设置环境变量 CLASSPATH 或在启动 JVM 时使用 -cp 或 -classpath 参数来指定。
• JAR 包内部的 classpath：虽然不常见，但某些 JAR 包可能会在其 META-INF/MANIFEST.MF 文件中指定它们自己的 Class-Path 条目

 

总结：

spring启动时会扫描所有classpath上的jar包，查找这些 JAR 包中的META-INF/spring.factories文件，也会查找项目自身的根路径下（编译后是target/classes/META-INF，如果打成jar后就是jar的根路径/META-INF） spring.factories文件，通过它找到各种自动化配置类（xxxAutoConfiguration），根据自动化配置类上的加载条件决定是否加载默认配置，可以加载的实例化配置类并加载默认配置。

springboot达成jar包后的目录

my-project.jar  
├── META-INF/  
│   ├── MANIFEST.MF  
│   ├── maven/  
│   │   └── ... (Maven 相关的元数据)  
│   └── spring.factories  
├── com/  
│   └── example/  
│       └── ... (你的编译后的类文件)  
└── ... (其他资源和类文件)

如何禁用一个特定自动配置类    

使用@EnableAutoConfiguration注解的exclude属性

@SpringBootApplication
@EnableAutoConfiguration(exclude = SomeAutoConfiguration.class)
public class YourApplication {

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

还可以在application.properties或application.yml配置文件中使用spring.autoconfigure.exclude属性来禁用自动配置类

spring.autoconfigure.exclude=org.example.SomeAutoConfiguration

springboot默认配置

默认配置位于spring-boot-autoconfigure.jar中。这个包中包含了许多自动配置类，用于根据应用程序的依赖和配置，自动配置各种功能和组件。
在包的/META-INF/spring.factories 文件中列出了常用的自动配置类。

开发者也可以通过自定义配置来覆盖默认的自动配置。可以在应用程序的配置文件（如 application.properties 或 application.yml）中设置相应的属性，或者编写自定义的配置类来修改默认的配置。

autoconfigure和第三方starter的自动配置类冲突情况

spring-boot-autoconfigure.jar中是springboot提供了一套默认的自动化配置，第三方的starter有的有自己的自动化配置类。如果冲突的话，默认第三方的会覆盖或扩展springboot提供的默认配置

如果开发者想覆盖或扩展默认的自动化配置。这可以通过在项目的 src/main/resources/META-INF/spring.factories 文件中添加或修改配置来实现。

启动类一般放在那里

一般都放在根包下，比如根包是com.xgss,那它就放在 com.xgss目录下

动类通常命名为Application或{ProjectName}Application，以便快速识别。

SpringBoot的核心注解 以及常用注解 

1. 核心注解：
- @SpringBootApplication：这是一个组合注解，用于标记Spring Boot应用程序的入口类。它包含了@Configuration、@EnableAutoConfiguration和@ComponentScan等注解，用于启用自动配置和组件扫描。
- @Configuration：用于标记一个类为配置类，其中定义了一些Bean的配置信息。
- @EnableAutoConfiguration：用于启用Spring Boot的自动配置机制。
- @ComponentScan：用于指定要扫描的组件的基础包路径。

2. 常用注解：
- @RestController：用于标记一个类为RESTful风格的控制器，其中的方法会返回JSON格式的数据。
- @RequestMapping：用于映射HTTP请求的URL路径到控制器的方法上。
- @Autowired：用于自动注入依赖的Bean。
- @Value：用于注入配置文件中的属性值。
- @GetMapping、@PostMapping、@PutMapping、@DeleteMapping：用于映射HTTP请求的GET、POST、PUT、DELETE方法到控制器的方法上。
- @PathVariable：用于获取URL路径中的参数值。
- @RequestBody：用于接收HTTP请求的请求体中的数据。
- @ResponseBody：用于将方法的返回值直接作为HTTP响应的内容返回。

Spring Boot 的核心配置文件有哪几个，区别

1. application.properties：这是Spring Boot的主要配置文件，使用基于键值对的格式进行配置。可以在该文件中配置各种应用程序的属性，如服务器端口、数据库连接、日志级别等。

2. application.yml：这是另一种常用的Spring Boot配置文件，使用基于YAML（YAML Ain't Markup Language）的格式进行配置。相比于properties文件，YAML文件更加易读和易写，支持层级结构和复杂数据类型。

这两个配置文件的区别主要体现在以下几个方面：

- 格式：application.properties使用基于键值对的格式，而application.yml使用基于YAML的格式。YAML格式相对于键值对格式更加灵活和易读。

- 层级结构：YAML文件支持层级结构，可以使用缩进来表示层级关系，使得配置文件更加结构化和清晰。而properties文件只支持一级的键值对，不支持层级结构。

- 数据类型：YAML文件支持复杂的数据类型，如列表、映射等。这使得在配置文件中表示复杂的数据结构更加方便。而properties文件只支持字符串类型的值。

- 优先级：在Spring Boot中，application.properties的优先级高于application.yml。如果同时存在同名的配置项，那么application.properties中的配置会覆盖application.yml中的配置。

总的来说，application.properties和application.yml都是Spring Boot的核心配置文件，用于配置应用程序的各种属性。它们的区别在于格式、层级结构、数据类型和优先级等方面。开发者可以根据自己的喜好和需求选择使用其中的一种配置文件。

在springboot项目没有application.properties和application.yml文件的情况下也不影响项目的启动，默认的端口号是8080，springboot都提供了默认的配置。

除了这两个核心配置文件外，Spring Boot 还支持其他配置文件，如 bootstrap.properties 和 bootstrap.yml。这些文件主要用于应用程序的初始化阶段，特别是在需要加载外部配置（如从配置中心获取配置）时。但通常，bootstrap 配置文件不是必需的。

此外，Spring Boot 还支持多环境配置，允许你为不同的环境（如开发、测试、生产）定义不同的配置参数。这通常通过在文件名中添加环境标识来实现，如 application-dev.properties、application-prod.yml 等。

 

应用程序的生命周期

1. 初始化阶段：在这个阶段，应用程序进行各种初始化操作。例如，加载配置文件、建立数据库连接、分配空间、设置默认值等。这些操作通常是在应用程序启动时执行的，为程序的正常运行做好准备。
2. 执行阶段：在初始化完成后，应用程序进入执行阶段。此阶段的核心是程序逻辑的执行，即代码的执行。程序会根据业务需求调用相应的函数和方法，实现特定的功能。在执行过程中，程序会利用各种资源，如CPU、内存、磁盘、网卡等，完成其任务。
3. 运行和维护阶段：程序在执行过程中，可能会进行多次运行，并可能涉及对资源的动态管理和优化，以确保程序的稳定运行和性能优化。同时，根据业务需要，可能还需要进行维护操作，如更新配置、修复bug等。
4. 结束阶段：当程序完成任务或用户主动关闭时，应用程序会进入结束阶段。在这个阶段，程序会释放占用的资源，进行清理工作，如关闭连接、垃圾回收、数据保存等。这有助于确保系统资源的有效利用和程序的正常退出。

开启SpringBoot特性有哪几种方式

1. 使用@SpringBootApplication注解：在Spring Boot应用程序的入口类上添加@SpringBootApplication注解，这是一个组合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan等注解。它会启用Spring Boot的自动配置机制，并扫描和加载应用程序中的组件。

2. 使用@EnableAutoConfiguration注解：在配置类上添加@EnableAutoConfiguration注解，可以单独启用Spring Boot的自动配置机制。这个注解会根据项目的依赖和配置信息，自动配置应用程序的各个组件。

3. 使用@Configuration注解：在配置类上添加@Configuration注解，可以定义一些Bean的配置信息。这样的配置类可以被Spring Boot自动扫描并加载。

4. 使用@Enable*注解：Spring Boot提供了一系列的@Enable*注解，用于启用特定的功能或特性。例如，@EnableCaching用于启用缓存功能，@EnableScheduling用于启用定时任务功能，@EnableAsync用于启用异步方法调用功能等。

5. 使用配置文件：通过在application.properties或application.yml配置文件中设置相应的属性，可以开启和配置Spring Boot的特性。例如，通过设置spring.data.mongodb.uri属性来启用MongoDB数据库的连接。

springboot和ssm比较

SSM是WEB应用框架，涵盖整个应用层；spring boot你可以看做一个启动、配置、快速开发的辅助框架，本身针对的是微服务。只是为了提高开发效率。

所以可以使用springboot与ssm整合，可以跟高效地开发程序。

springboot和微服务

Spring Boot 可以作为构建微服务架构的基础框架，用于开发微服务

微服务则是一种架构风格，是将应用程序拆分成多个小型、独立的服务，每个服务都运行在自己的进程中，通过轻量级通信机制（如 RESTful API）进行通信。

springboot和springCloud

Spring Cloud 是构建在 Spring Boot 之上的一个扩展，它通过提供额外的功能和组件，用于解决分布式系统中的常见问题，如服务注册与发现、负载均衡、服务调用、配置管理、断路器等。使得开发者可以更方便地构建和管理分布式系统和微服务架构。

SpringCloud依赖于springBoot，spingBoot不依赖SpringCloud。

springboot启动流程

1. 加载配置文件：Spring Boot 会加载应用程序的配置文件，包括 application.properties 或 application.yml 文件中的配置项。这些配置项可以用于配置应用程序的各种属性，如端口号、数据库连接等。

2. 创建应用程序上下文：加载启动类并根据配置文件创建spring容器（ApplicationContext），用于管理应用程序的各个组件和 Bean。

3. 执行自动配置并加载spring管理的bean：Spring Boot 会根据应用程序的依赖和配置，自动配置各种功能和组件。它会根据类路径上的依赖和配置项，自动配置数据库连接、Web 服务器、安全性等功能，以减少开发者的配置工作。执行完自动配置就会实例化spring管理的bean，bean的初始化等操作。

4. 启动内嵌服务器：如果应用程序是Web应用，根据应用程序的配置和依赖，Spring Boot 会自动选择并启动适当的内嵌服务器。启动成功后服务器就可以接收请求并交给应用程序处理了

starters说明

Spring Boot 的 Starter 是一种依赖管理机制，用于简化应用程序的配置和依赖管理。它通过提供一组预定义的依赖，自动配置和初始化应用程序所需的功能和组件。

springboot根据不同的功能场景提供了封装好的启动器用来简化该功能场景的依赖管理，使我们不需要在关心需要导入的依赖及依赖之间的版本兼容问题

如：

web场景就用spring-boot-starter-web

jdbc场景就用spring-boot-starter-jdbc

redis场景就用spring-boot-starter-redis

test场景就用spring-boot-starter-test

log场景就用spring-boot-starter-logging

spring-boot-starter-web

我们想要开发web项目就需要引入该依赖

它为我们提供一些SpringMVC必要的组件，如视图解析器

默认使用嵌入式的tomcat作为web容器对外提供HTTP服务。

我们web项目常用到的注解引入该依赖才可以使用：

@SpringBootApplication 启动类注解

@Controller

@RequestMapping

@ResponseBody

@Autowired

等

 

因为该starter中封装了如下依赖：

org.springframework.web,org.springframework.spring-webmvc,spring-boot-starter-tomcat,spring-boot-starter等

starters原理

starters中引入了该场景中所需要的依赖，并启动相应的默认配置

 

自定义starters

官方建议自定义的starter使用xxx-spring-boot-starter命名规则。

项目中

创建maven项目；

添加依赖：添加需要的依赖项，用于实现 Starter 提供的功能。

编写自动配置类：编写自动配置类来配置和初始化 Starter 提供的功能和组件。自动配置类应该使用条件注解（如 @ConditionalOnClass、@ConditionalOnProperty）来根据条件来决定是否应用某个自动配置。

定义 Starter 属性：在 Starter 模块的 src/main/resources 目录下，创建一个 META-INF/spring.factories 文件，并在其中定义 Starter 的属性。这些属性可以包括自动配置类的全限定名、需要的依赖项等。

打包和发布：使用 Maven 的命令或插件将 Starter 模块打包成一个可发布的 JAR 文件。可以使用 Maven 的 install 命令将 Starter 安装到本地 Maven 仓库，或使用其他方式发布到远程仓库。

springboot使用jar启动

pom文件中需要设置spring-boot-maven-plugin插件，使用mvn packag命令就可以打出可以直接运行的jar包了

 

Spring Boot 有哪几种读取配置的方式

1. 使用@Value注解读取配置值。
2. 使用@ConfigurationProperties注解读取配置值。
3. 使用Environment对象读取配置值。

@ConfigurationProperties注解怎么使用

在需要注入配置属性的类上添加@ConfigurationProperties注解，并指定前缀

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private int age;
}

在配置文件中添加对应的属性

myapp.name=Tom
myapp.age=20

在Spring Boot应用中使用@Autowired注解将MyAppProperties对象注入到需要使用的类中

@Service
public class MyService {
    @Autowired
    private MyAppProperties myAppProperties;
}

使用Environment对象如何读取配置值

在需要注入配置属性的类上添加@Autowired注解，并指定类型为Environment。

@Service
public class MyService {
    @Autowired
    private Environment env;
}

在配置文件中添加对应的属性

myapp.name=Tom
myapp.age=20

在需要使用配置属性的地方，通过env对象获取对应的属性值

String name = env.getProperty("myapp.name"); // Tom
int age = Integer.parseInt(env.getProperty("myapp.age")); // 20

使用Environment对象读取配置值时，需要将属性名转换为字符串形式，并且需要手动进行类型转换。因此，建议使用@ConfigurationProperties注解来读取配置值，更加方便和安全。

如何知道springboot为我们配置了那些内容

在spring-boot-autoconfigure.jar包中找到我们想要查看的场景的配置类（xxxAutoConfiguration类）

根据该包下的xxxProperties类可以知道要配置的配置项，如果要修改配置项就把配置内容写入到项目的配置文件中

 

比如：

springmvc的配置类WebMvcAutoConfiguration（定义了静态文件目录，欢迎页，浏览器标签图标等）

ThymeleafProperties类中定义了默认的编码，模板页面默认地址，默认后缀名等

Spring Boot的配置优先级顺序

1. 默认配置：包括内置的默认配置和自动配置。这些默认配置通常由Spring Boot提供，并在应用程序启动时自动加载。

2. 外部配置文件：如application.properties或application.yml。这些配置文件可以位于应用程序的classpath下的config目录中，或者通过spring.config.location属性指定的其他位置。
3. 配置中心：如果应用程序使用了配置中心，Spring Boot会从配置中心获取配置信息，并将其应用到应用程序中。

4. 环境变量：Spring Boot会将环境变量映射到应用程序的配置属性上。环境变量可以覆盖命令行参数和外部配置文件中的配置值。

5. 命令行参数：Spring Boot会解析命令行参数，并将其映射到应用程序的配置属性上。命令行参数可以覆盖外部配置文件中的配置值。

在配置加载的过程中，后面的配置会覆盖前面的配置。例如，命令行参数会覆盖外部配置文件中的配置值，环境变量会覆盖命令行参数和外部配置文件中的配置值。

application.properties的加载先于自动化配置的配置文件，但优先级高于自动化配置的内容。

优先级：命令行参数>环境变量参数>配置中心参数>application.properties/yml参数>自动配置类参数

springmvc的使用

springboot对springmvc做了很多的自动配置（在WebMvcAutoConfiguration类中）

自动配置的内容：

视图解析器

静态文件的资源路径

webjars资源路径

首页的路径

浏览器标签图标资源路径

转换器（比如页面穿过来的123要转为Integer类型就用到转化器）

格式化器（比如页面传过来的2016.10.12在后台就要转为时间类型就用到格式化器）

等

 

 

如何扩展

比如加入拦截器

编写自己的配置类（使用@Configuration标注），并继承WebMvcConfigurerAdapter，想要扩展什么功能，重写其中的方法就行

原理：

springboot自动配置类加载的时候会把我们编写的配置类也进行加载

• 、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己加入的组件（@Bean、@Component）如果有就用用户的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来；

编写组件(如视图解析器)，然后放入到spring容器中（@Bean,@Component都可以放进去）

其他总结

如何打可执行jar包

pom.xml中配置上spring-boot-maven-plugin插件，

该插件可以通过mvn package命令来打可执行jar包，使用 java -jar命令就可以启动

也可以执行mvn spring-boot:run命令来使用内置tomcat启动项目

 

springboot和jsp

内置的tomcat默认不支持jsp页面，可以使用模板引擎（freemarker,thymeleaf）,默认使用的thymeleaf

 

springBoot核心组件

starter:简化jar包的引用，解决jar版本冲突问题。

auto-configuration:实现自动化配置，简化配置

Springboot cli：命令行功能，可以方便使用脚本编写启动项目等

actuator:用于配置查看，监控统计系统

 

配置文件说明

使用application.properties或application.yml文件作为全局配置文件，可以对默认配置进行修改

 

springBoot项目如何单元测试

使用@RunWith注解和@SpringBootTest注解，可以使用注入到Spring容器中的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest1 {
@Test
public void test1(){

 

如何加载指定位置的配置文件

springBoot默认是加载classPath下的application.properties或application.yml，如果所有配置项都配置到里面就优点乱

可以使用@PropertySource注解标注在配置文件对应的类上指定配置文件：

@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

 

如何导入xml配置文件并生效

默认放在classPath的xml不会被加载，可以使用@ImportResource注解放在启动类上，如：

@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication
public class MyApplication{
public static void main(String[] args){};
}

注：springboot推荐使用配置类的方式来进行配置应用，而不是用配置文件

 

如何编写配置类

@Configuration注解标注在类上，标明这个类是一个配置类

@Configuration
public class MyAppConfig {
    //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService02(){
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

配合@ComponentScan注解能扫描到这个类就可以

如何在不同的环境使用不同的配置文件

可以有多种方式：

第一种：编写多个指定Profile的配置文件

文件名可以是 application-{profile}.properties/yml，profile可以任意指定

默认使用application.properties

 

第二种：

使用文档快，文档块用---进行分割，激活也是使用spring.profiles.active指定，如：

server:
  port: 8081
spring:
  profiles:
    active: prod
---
server:
  port: 8083
spring:
  profiles: dev
---
server:
  port: 8084
spring:
  profiles: prod  #指定属于哪个环境

激活方式：

1、在配置文件中指定  spring.profiles.active=dev

2、命令行：命令行指定配置的参数内容

​ java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；

​ 可以直接在测试的时候，配置传入命令行参数，命令行的方式优先级高于配置文件中指定的

​ 3、虚拟机参数：

​ -Dspring.profiles.active=dev

这里的dev指的就是profile的内容，虚拟机方式优先级也高于配置文件

4、配置文件位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件，（file代表当前项目根路径）

–file:./config/   当前项目根路径下的config文件夹中

–file:./   当前项目根路径下

–classpath:/config/  

–classpath:/

优先级由高到底，高优先级的配置会覆盖低优先级的配置；

 

SpringBoot会从这四个位置全部加载主配置文件进行互补配置

我们还可以通过spring.config.location来改变默认的配置文件位置，修改后还是会加载其他位置的配置文件共同形成互补配置。指定的优先级最高。

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

 

springboot的日志管理

springBoot的日志功能在spring-boot-starter-logging依赖中提供，提供了日志场景中的功能

springBoot底层使用的是sl4j+logback,如果有其他日志实现也都会转为调用sl4j的api使用logback实现。所以我们引入其他使用其他日志实现的框架的时候，需要把这个日志实现给exclusion排除掉。如果特别想用其他的实现springboot也有提供方案可以去官网查看。

使用：springBoot的starter中已经处理好了日志的配置，我们直接调用sl4j的api就可以；如果向使用自己的配置不使用默认的配置，在properties配置文件中指定或者在在src/main/resources目录下放入logback.xml或logback-spring.xml（文件名称官网有规范不能随便起）（Spring Boot官方推荐使用带有-spring后缀的配置文件，同时存在logback.xml和logback-spring.xml，Spring Boot会优先加载logback-spring.xml）

 

sl4j和logback说明

sl4j提供日志的门面方法不提用日志的实现，logback提供日志实现，log4j也是提供日志实现，logback是对log4j的升级版

我们使用的时候应该调用sl4j提供的方法，因为sl4j不提供实现，自然就调用了logback的api

 

logback.xml和logback-spring.xml区别：

logback.xml会绕过spingboot直接被日志框架识别解析使用，logback-spring.xml可以被springBoot识别解析可以在基本配置的基础上，扩展一些功能，比如springProfile标签，指定不同环境使用不同的日志策略

 

//记录器

Logger logger = LoggerFactory.getLogger(getClass());

 

//日志的级别；

//由低到高   trace<debug<info<warn<error

//可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效

logger.trace("这是trace日志...");

logger.debug("这是debug日志...");

//SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别

logger.info("这是info日志...");

logger.warn("这是warn日志...");

logger.error("这是error日志...");

 

springboot事务管理

当我们使用了spring-boot-starter-jdbc或spring-boot-starter-data-jpa依赖的时候，框架会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager。所以我们不需要任何额外 配置就可以用@Transactional注解进行事务的使用。

当你添加了mybatis-plus-boot-starter依赖时，通常不需要再添加spring-boot-starter-jdbc依赖。mybatis-plus-boot-starter本身已经包含了与数据库交互所需的大部分依赖，包括spring-boot-starter-jdbc

 

springBoot已经在TransactionAutoConfiguration自动配置类中对事物配置好了，我们只要在使用事务的地方加上@Transactional注解就可以了

@Transactional注解默认的隔离级别是使用数据库设置的隔离级别，innodb存储引擎默认的隔离级别是可重复读。

@Transactional默认的事务传播行为是REQUIRED，代表当前存在事务，则加入当前事务；如果当前没有事务，则新建一个事务。

springBoot默认的静态文件路径

"classpath:/META-INF/resources/",

"classpath:/resources/",

"classpath:/static/",

"classpath:/public/"

"/"：当前项目的根路径

 

这些文件夹使用多个时静态文件都可以访问到

也可以在配置文件中指定静态文件路径

 

SpringBoot模板引擎

由于springBoot可以把web项目打成jar包执行，使用内置的tomcat，所以默认不支持jsp

推荐使用模板引擎

模板引擎：

模板引擎可以把数据和模板根据语法进行组合来生成静态文件，常用的模板引擎有freemarker,thymeleaf

 

springBoot默认使用thymeleaf模板引擎，模板文件默认放置位置为classpath:/templates/

模板引擎缓存：

默认模板使用了缓存，修改了模板页面不能立刻生效，可以在配置文件中

# 禁用缓存

spring.thymeleaf.cache=false

在项目运行期间，IDEA不会让其修改内容生效，按Ctrl+F9重新编译就可以实时生效

 

WebJars

在Servlet3中，允许我们直接访问WEB-INF/lib下的jar包中的/META-INF/resources目录资源，即WEB-INF/lib/{*.jar}/META-INF/resources下的资源可以直接访问。

WebJars也是利用了此功能，将所有前端的静态文件打包成一个jar包，可以方便的对前端静态资源进行管理。

 

WebJars是以jar包的方式来引入web前端资源（如js&css），可以利用借助版本管理工具(Maven、gradle等)进行版本管理。避免了文件混乱、版本不一致等问题。

 

webjars静态文件存放规则：xxx.jar/META-INF/resources/webjars/${name}/${version}/具体的文件名。

 

springboot中访问webjars中的文件

所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源

如：localhost:8080/webjars/jquery/3.3.1/jquery.js

 

对于自己的静态文件默认可以放：（在ResourceProperties文件中定义的默认值）

"classpath:/META-INF/resources/",

"classpath:/resources/",

"classpath:/static/",

"classpath:/public/"

"/"：当前项目的根路径

 

如何找到依赖：

https://www.webjars.org/网站上有依赖的说明

如何更换web容器

比如将默认的tomcat更换为jetty,只需要修改pom.xml将spring-boot-starter-web中依赖的spring-boot-starter-tomcat更换为spring-boot-starter-jetty即可，配置文件也不需要修改。

<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>
<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-jetty</artifactId>  
</dependency>

如何对内嵌的tomcat做配置

我们可以使用application.yml文件、环境变量、命令行参数或者编程方式进行设置

对于配置文件的方式：

server:  
  port: 8081  
  servlet:  
    context-path: /myapp
    session:  
      timeout: 30m # 设置Session有效期为30分钟
  tomcat:  
    max-threads: 200 #最大线程数量
    min-spare-threads: 10 #最小线程数量

对于内存参数的设置不能通过application.yml进行设置，可以在启动的时候添加设置参数

java -Xms256m -Xmx512m -jar myapp.jar

如果用maven打包，也可以在pom文件中配置，打包的时候可以指定

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-maven-plugin</artifactId>  
            <configuration>  
                <jvmArguments>  
                    -Xms256m -Xmx512m  
                </jvmArguments>  
            </configuration>  
        </plugin>  
    </plugins>  
</build>

如何去掉内嵌的web容器使用外部的

修改pom.xml文件，移除spring-boot-starter-web依赖中的<scope>provided</scope>标签（如果有的话），从依赖中排除spring-boot-starter-tomcat,

并添加javax.servlet-api依赖（IDE或构建工具可能需要知道Servlet API的类和方法，以便能够编译你的代码。确保开发环境的正确配置和代码的顺利编译）

<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>
<dependency>  
    <groupId>javax.servlet</groupId>  
    <artifactId>javax.servlet-api</artifactId>  
    <version>你的Servlet API版本</version>  
    <scope>provided</scope> <!--表示这个依赖在运行时由外部容器（这里是Tomcat）提供，而不是被打包进最终的WAR文件中。 -->
</dependency>

在pom.xml中将打包方式修改为war

<packaging>war</packaging>

构建你的WAR文件后，将其部署到外部的Tomcat服务器的webapps目录下。Tomcat服务器会自动解压WAR文件并启动你的Spring Boot应用程序。

配置Tomcat服务器的server.xml或其他相关配置文件。启动外部的Tomcat服务器，Spring Boot应用程序就会在Tomcat中运行。

SpringBoot 实现热部署有哪几种方式

热部署：修改代码后，无需重启项目，就能将增量的内容自动编译并部署

1. 使用开发工具支持：大多数集成开发环境（IDE）都提供了对Spring Boot应用程序的热部署支持（可以单独使用）。例如，使用IntelliJ IDEA可以启用Spring Boot的自动编译和热部署功能，使得在代码修改后应用程序可以自动重新加载。

2. 使用Spring Boot DevTools：Spring Boot DevTools是一个开发工具包，提供了许多开发时的便利功能，包括热部署。通过在项目的依赖中添加spring-boot-devtools，并在开发环境中启动应用程序，可以实现热部署功能。当代码发生变化时，应用程序会自动重新加载。

3. 使用Spring Loaded：Spring Loaded是一个独立的Java类热部署解决方案，可以与Spring Boot集成。通过在项目的依赖中添加springloaded，并在开发环境中启动应用程序，可以实现热部署功能。当代码发生变化时，应用程序会自动重新加载。

4. 使用JRebel：JRebel是一个商业化的Java类热部署工具，可以与Spring Boot集成。通过在项目的依赖中添加JRebel的相关配置，并在开发环境中启动应用程序，可以实现热部署功能。当代码发生变化时，应用程序会自动重新加载。

 Spring Boot 可以兼容老 Spring 项目吗 

Spring Boot可以与传统的Spring框架无缝集成，并且可以使用现有的Spring组件和功能。这意味着您可以将现有的Spring项目迁移到Spring Boot，而无需进行大量的代码更改。

在迁移过程中，您可以逐步引入Spring Boot的特性和功能，例如自动配置、起步依赖、外部化配置等，以提高开发效率和简化配置。同时，您仍然可以使用传统的Spring配置方式，如XML配置文件、注解配置等。

Spring Boot中的监视器 

actuator启动器提供了一系列生产级别的特性（说明这个模块提供的特性和工具是为生产环境运行的应用所设计），使得监控和管理 Spring Boot 应用变得更加简单。

项目中引入spring-boot-starter-actuator依赖来使用监视器功能，主要提供的功能有

1. 监控应用健康：你可以检查应用的健康状态，例如数据库连接、缓存、消息队列等。
2. 查看应用的环境属性：例如所有的 Spring 配置属性。
3. 查看 Beans：查看应用中所有的 Spring Beans。
4. 查看应用的线程状态。
5. 查看应用的日志级别，并动态修改它。
6. 查看应用的度量信息：例如系统的负载、JVM 的内存使用、垃圾回收、HTTP 请求等。
7. 查看应用的 HTTP 映射。
8. 查看应用的环境属性。 ...等等。

1. 一旦依赖添加到项目中，Actuator 的端点就可以通过 /actuator 路径访问（例如：http://localhost:8080/actuator/health）。

2. 默认情况下，为了安全起见，启用了health和info端点。如果你想启用其他端点或改变默认配置，你可以在 application.properties 或 application.yml 文件中进行配置。

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,env

由于 Actuator 暴露了很多有关应用的敏感信息，所以在生产环境中使用时，应确保对其进行适当的安全配置。通常，结合 Spring Security 可以轻松实现对 Actuator 端点的安全访问控制。

端点：

端点代表应用中的一个特定的访问点，它暴露特定的数据或功能，供开发者或者运维人员查看或操作。

端点就像应用的一个小窗口，通过这个窗口，你可以获得应用的某个方面的信息或进行某些管理操作。

关键端点：

• /actuator/health：展示应用的健康信息。这个端点通常用于生产环境中的健康检查。

• /actuator/info：展示应用的任意应用特定信息。这些信息通常是从 application.properties 文件中的 info 配置属性中获取的。

• /actuator/metrics：提供了丰富的应用度量信息。

• /actuator/env：展示应用的环境属性。

• /actuator/beans：展示应用中的所有 Spring Beans。

• /actuator/loggers：查看和修改应用的日志配置。

访问http://localhost:8080/actuator路径，而不指定具体的端点时，通常会返回包含所有已暴露端点的信息的JSON响应。这个响应列出了可用的Actuator端点及其访问路径。响应中的_links字段包含了每个已暴露端点的名称和路径。

{
    "_links": {
        "self": {
            "href": "http://localhost:8080/actuator",
            "templated": false
        },
        "beans": {
            "href": "http://localhost:8080/actuator/beans",
            "templated": false
        },
        "health": {
            "href": "http://localhost:8080/actuator/health",
            "templated": false
        },
        "info": {
            "href": "http://localhost:8080/actuator/info",
            "templated": false
        },
        "metrics": {
            "href": "http://localhost:8080/actuator/metrics",
            "templated": false
        },
        // 更多端点...
    }
}

SpringBoot 打成jar和普通的jar有什么区别

Spring Boot打成的jar和普通的jar主要区别在于结构和运行方式：

1. 结构差异：Spring Boot打包成的jar文件，解压后可以在\BOOT-INF\classes目录下找到代码，而普通的jar文件解压后直接就是包名，包里就是代码。因此，Spring Boot打包成的jar不能被直接引用，若要引用需要在pom.xml文件中增加配置，将Spring Boot项目打包成两个jar，一个可执行，一个可引用。
2. 运行方式：Spring Boot打包成的jar叫做可执行 jar，可以通过命令（java -jar xxx.jar）来运行；而普通的jar文件无法通过该命令直接运行，主要是被其他应用依赖。

 bootstrap.properties和application.properties 有何区别

是两种不同的配置文件，它们在使用场景、加载顺序和作用范围上有一些区别。

1. 使用场景：bootstrap.properties是用于配置Spring Boot的基础设施和全局属性的系统级别参数的配置文件（如注册中心信息、安全认证等）,主要配置不经常修改的配置；application.properties是应用程序的主要配置文件，用于配置应用程序的各种属性和行为。
2. 加载顺序：application.properties在bootstrap.properties之后加载；bootstrap.properties主要用于加载应用程序上下文之前的配置
3. 作用范围：bootstrap.properties的作用范围是全局的，它会被所有的Spring应用程序共享。而application.properties的作用范围是应用程序级别的，它包含了应用程序特定的配置信息。
4. 优先级：application.properties会覆盖bootstrap.properties的配置

springboot集成mybatis

在 Spring Boot 的 pom.xml 文件中添加以下 MyBatis 依赖：

<dependency>  
  <groupId>org.mybatis</groupId>  
  <artifactId>mybatis</artifactId>  
  <version>3.5.7</version>  
</dependency>

在 Spring Boot 的 application.properties 或 application.yml 文件中配置数据源和 MyBatis 的相关属性。

spring.datasource.url=jdbc:mysql://localhost:3306/test  
spring.datasource.username=root  
spring.datasource.password=123456  
spring.datasource.driver-class-name=com.mysql.jdbc.Driver  
  
mybatis.mapper-locations=classpath:mapper/*.xml  
mybatis.type-aliases-package=com.example.demo.domain

SqlSessionFactory 配置：在Spring Boot中，通常使用DataSource作为参数来创建SqlSessionFactory，例如：

@Bean  
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {  
    SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();  
    sessionFactory.setDataSource(dataSource);  
  
    return sessionFactory.getObject();  
}

事务管理器的配置：在Spring Boot中，通常使用默认的事务管理器，例如：

@Bean  
public PlatformTransactionManager transactionManager(DataSource dataSource) {  
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);  
    return new DataSourceTransactionManager(jdbcTemplate);  
}

编写 Mapper 接口和映射文件

 

我们也可以直接添加依赖mybatis-spring-boot-starter来使用mybatis，该启动器已经自动配置了事务管理器和SqlSessionFactory 配置，可以更轻松的集成mybatis

我们也可以直接添加依赖mybatis-plus-boot-starter，使用mybatis-plus进行间接使用mybatis,可以避免编写xml文件

springboot项目如何部署

执行maven构建命令生成jar或war文件

如果是jar文件（如果使用内置tomcat的web项目也是打的jar包），放到服务器上使用java -jar进行启动项目

如果是war文件，放入服务器上的tomcat 的webapps目录下面，启动tomcat

怎么做统一异常处理

方案一：使用@ControllerAdvice和@ExceptionHandler

@ControllerAdvice  
public class GlobalExceptionHandler {  
  
    @ExceptionHandler(value = Exception.class)  
    @ResponseBody  
    public ResponseEntity<ErrorResponse> handleGeneralException(Exception ex) {  
        // 处理异常，并返回自定义的响应体  
        ErrorResponse errorResponse = new ErrorResponse("General Error", ex.getMessage());  
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);  
    }  
  
    @ExceptionHandler(value = CustomException.class)  
    @ResponseBody  
    public ResponseEntity<ErrorResponse> handleCustomException(CustomException ex) {  
        // 处理自定义异常，并返回自定义的响应体  
        ErrorResponse errorResponse = new ErrorResponse(ex.getMessage(), ex.getDetails());  
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);  
    }  
  
    // 其他异常处理方法...  
}

方案二：使用@RestControllerAdvice

@RestControllerAdvice是@ControllerAdvice和@ResponseBody的组合。如果你所有的异常处理方法都返回@ResponseBody，那么可以直接使用@RestControllerAdvice。

@RestControllerAdvice  
public class GlobalExceptionHandler {  
    // ... 与上面的示例相同 ...  
}

数据库连接池的使用

线程池配置参数：

HikariCP被用作默认的数据库连接池

HikariCP采用了一种“公平的”连接获取策略。当多个线程请求获取连接时，它会优先分配给等待时间较长的线程，避免了线程饥饿的情况

HikariCP通过使用ConcurrentBag作为其并发集合类实现，来存储元素并避免频繁锁定和解锁。

ConcurrentBag内部同时使用了ThreadLocal和CopyOnWriteArrayList来存储元素。ThreadLocal用于存储每个线程私有的连接，这样每个线程在尝试获取连接时，可以首先从自己的ThreadLocal中获取，从而避免了锁竞争。CopyOnWriteArrayList则是一个线程共享的列表，用于存储公共的连接。

当线程需要获取连接时，ConcurrentBag首先会尝试从该线程的ThreadLocal中获取连接。如果ThreadLocal中没有可用的连接，它会尝试从共享的CopyOnWriteArrayList中获取。

当某个线程尝试从自己的ThreadLocal中获取连接失败时，ConcurrentBag的“窃取”机制会允许它查看其他线程的ThreadLocal中的连接。但是，这并不是直接访问其他线程的ThreadLocal实例，而是通过ConcurrentBag的内部机制进行间接访问。

重要的是，被“窃取”的连接必须是当前未被其他线程使用的。这通常意味着这些连接是处于空闲状态，并且可以被安全地用于新的请求。在“窃取”过程中，会有一系列的检查和同步操作来确保连接的安全性和一致性。

 

可以配置的参数：

maximumPoolSize：最大连接数

minimumIdle：最小连接数（没有超过这个数，达到空闲时间也不会被关闭）

idleTimeout：空闲时间（线程池中的线程数量超过了最小连接数后，超过空闲时间的会被关闭）

maxLifetime：连接最大时间 （不管是否达到最小连接数，时间到都会被关闭。无论其是否正在处理业务，都会被关闭。会抛出异常）

connectionTimeout：等待从连接池获取连接的最大时间，时间内没有获取到连接，会抛出异常。

dataSourceClassName：完全限定的数据源类名。这通常是数据库驱动的特定类，例如用于MySQL的com.mysql.cj.jdbc.MysqlDataSource。

jdbcUrl：数据库的JDBC URL。

username 和 password：用于连接到数据库的用户名和密码。

autoCommit：是否自动提交事务。默认是1，也就是开启状态

connectionTestQuery：用于验证从连接池获取的连接是否仍然有效的SQL查询。如果查询执行成功，则认为连接是有效的。

poolName：连接池的名称，主要用于日志记录和监控。

leakDetectionThreshold：如果连接池怀疑有连接泄露，并且连接的使用时间超过这个阈值，那么会记录一条警告日志。

initializationFailTimeout：在放弃初始化连接池之前等待的时间长度。