目录
MyServiceAutoConfiguration.java
3.1 在 application.properties 或 application.yml 中指定
3. 继承 SpringBootServletInitializer
4. Spring Boot Configuration Processor
Spring Boot 一款用于简化 Spring 应用开发的框架,它通过提供默认配置和自动配置功能,减少了大量的样板代码和配置文件,使得开发者能够更快速地搭建和开发基于 Spring 的应用程序。以下从多个方面对 Spring Boot 进行详细介绍:
springboot介绍
核心特性
- 自动配置: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、核心本质:更加高效、便捷实现软件系统开发维护。