Java学习笔记（13）SpringBoot知识点（1）

什么是SpringBoot

Spring Boot 是一个基于 Spring Framework 的快速开发框架，旨在简化 Java 应用程序的开发，尤其是构建基于 Spring 的独立、生产级应用。它通过预配置和自动化配置，降低了开发复杂度，让开发者无需手动配置繁琐的 Spring 配置文件。

核心特点

1. 自动化配置

   • Spring Boot 提供了一系列的 starter，根据项目依赖自动配置应用所需的环境。例如，添加了 spring-boot-starter-web 依赖，Spring Boot 会自动配置嵌入式的 Tomcat 和 MVC 框架。

2. 嵌入式服务器

   • Spring Boot 内置了常用的服务器（如 Tomcat、Jetty），你可以将应用直接运行为一个独立的 Jar 包，不需要额外安装和配置服务器。

3. 简化的依赖管理

   • Spring Boot 提供了统一的版本管理，开发者只需要选择starter依赖即可，而无需手动处理各种库的版本兼容问题

4. 生产级的特性

   • 包括健康检查，应用监控，指标暴露等，使得Spring Boot应用于部署和管理

5. 无代码生成

   • Spring Boot不依赖代码生成，它只通过合理的约定和灵活的配置实现快速开发

常用的Spring Boot依赖（Starters）

• spring-boot-starter-web：用于构建Web应用，包括Restful API。
• spring-boot-starter-data-jpa: 集成jpa，支持数据库访问
• spring-boot-starter-security：提供安全性功能
• spring-boot-starter-test：集成长常用的测试工具

使用场景

• 快速构建微服务
• 构建Restful Web服务
• 开发独立运行的Java应用程序
• 搭建企业级应用的后段服务

SpringBoot的特征

自动配置（Auto-Configueration）

* 特征：
    * Spring Boot提供了智能的默认配置，自动配置Spring应用里的各个组件
    * 通过注解@EnableAutoConfiguration或@SpringBootApplication启动自动配置，减少手动配置XML或Java代码的工作量
* 优点：
    * 大大简化了开发配置过程，尤其适用快速原型开发

内嵌服务器（Embedded Server）

* 特征：
    * 支持内嵌的Web容器（如Tomcat，Jetty，Undertow）
    * 开发者无需单独部署到外部服务器，可以直接运行Jar包
* 优点：
    * 提升开发，测试和部署的效率

无需xml配置（Convention over Configuration）

* 特征：    
    * SpringBoot提倡“约定优先配置”，尽可能减少繁琐的配置文件（Spring XML文件）
    * 通过注解和默认配置，完成大多数需求
* 优点：
    * 减少开发者对于复杂XML文件的依赖

生产环境准备（Production-Ready Features）

* 特征：
    * 内置许多适用于生产环境的功能，如健康检查、指标监控、应用报告等
    * 通过Actuator模块实现应用的监控和管理
* 优点：
    * 便于快速上线并对应用进行监控

Stater POM简化依赖管理

* 特征：
    * 提供一系列Starter POM，如 spring-boot-starter-web、spring-boot-starter-data-jpa，包含了一组常用的依赖
    * 开发者只需要引入Starter，相关依赖会自动加载
* 优点：
    * 避免手动引入和配置多个依赖，减少依赖冲突

易于测试

* 特征：
    * 提供了对单元测试，集成测试良好的支持
    * 例如：通过@SpringBootTest可以加载完整的Spring应用上下文进行测试
* 优点：
    * 开发者可以快速编写和运行测试用例。

Spring Boot CLI

* 特征：
    * Spring Boot 提供命令行工具 (CLI)，支持使用 Groovy 脚本快速开发应用。
* 优点：
    * 对于简单的应用和快速原型开发非常高效。     

配置灵活

* 特征
    * 提供了多种方式来配置应用，包括
        * application.properties
        * application.yml
        * 环境变量
        * 命令行参数
    * 支持外部配置，方便应用在不同环境下部署。
*  优点
    * 开发者可以根据需求灵活地调整配置。

扩展性强

* 特征：
    * Spring Boot 基于 Spring 框架，提供了强大的扩展能力。
    * 可以无缝集成 Spring 生态系统中的其他组件，如 Spring Data、Spring Security 等。
* 优点：
    * 开发者可以轻松构建复杂的企业级应用。       

开箱即用

* 特征：
    提供了一组开箱即用的默认设置，开发者可以直接使用而无需过多调整。
    同时允许开发者覆盖默认配置。
* 优点：
    适合新手快速上手，同时也满足高级用户的自定义需求。

Spring启动类注解

@SpringBootApplication

作用: 这是Spring Boot应用程序的核心注解，用于标识一个主程序类。

内部包含的注解：

1. @SpringBootConfiguration

   • 本质是个很特殊的@Configuration，表示该类提供了Spring的配置

2. @EnableAutoConfiguration

   • 启用SpringBoot的自动配置机制，根据项目中的依赖自动配置Spring上下文

3. @ComponentScan

   • 扫描@Component、@Service、@Repository、@Controller等注解，并注册为Spring的bean

@SpringBootConfiguration

作用：标记当前类是SpringBoot的配置类，等价于Spring的@Configuration
通常不使用：一般由@SpringBootApplication隐式包含

@EnableAutoConfiguration

作用：启用Spring Boot的自动配置功能，根据类路径中的依赖和环境配置自动配置 Spring 上下文。

常用属性：

1. exclude：

   • 排除特定的自动配置类

2. exculdeName：

   • 通过类名字符串排除自动配置类

@ComponentScan

作用：指定包扫描路径，扫描并注册标记为@Component、@Controller、@Service、@Repository 的类
默认行为：默认扫描启动类所在包以及其子包

@Configuration

作用：表示该类是一个配置类，用于定义Bean

@Import

作用：导入其他配置类

@PropertySource

作用：用于加载外部属性文件

@Enable... 系列注解

Spring 框架中还有许多 @Enable... 注解，如

• @EnableScheduling：启用定时任务
• @EnableAsync：启用异步处理
• @EnableCaching：启用缓存

@SpringBootApplication会出现exculde@DataSourceAutoConfiguration的原因

（1）项目暂时不需要数据库

• 在一些场景中，项目仅仅是一个纯粹的逻辑服务（如消息队列消费者、定时任务服务）或者暂时不需要数据库支持。
• 如果不排除 DataSourceAutoConfiguration，Spring Boot 会强制要求配置数据源，导致应用启动失败。

（2）需要自定义数据源配置

• 在某些复杂的场景下，应用可能有多个数据源，或者需要动态配置数据源。
• 开发者会禁用 Spring Boot 的默认数据源自动配置机制，改为手动配置或自定义数据源的初始化逻辑。

（3）数据库配置可能依赖外部环境

• 数据库连接信息可能依赖于生产环境中的配置中心或外部服务，而不是通过固定的 application.properties 配置。
• 在开发或测试阶段，这些信息可能尚未准备好，因此需要排除默认的数据源自动配置。

SpringBoot支持配置文件的格式

1.properites

java.xxx.name = xxxx

2.yml

java:
    xxxx:
        name:xxxx

SpringBoot的启动方式

1. main方法（适用于在idea上）
2. 命令行java -jar的方式
3. mvn/gradle

SpringBoot配置途径

配置文件（application.properties/application.yaml）

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456

命令行参数

java -jar application.jar --server.port=9090 --spring.datasource.username=admin

环境变量

• 通过系统环境变量进行配置，常用于 Docker 容器或云环境中。
• Spring Boot 会自动读取这些环境变量并覆盖对应的配置。

export SERVER_PORT=8082
export SPRING_DATASOURCE_USERNAME=root

java系统属性

在运行 Java 应用时，通过 -D 参数设置系统属性。

java -Dserver.port=8083 -Dspring.datasource.password=123456 -jar application.jar

@Value注解

在代码中通过 @Value 注解直接注入配置值。

@RestController
public class MyController {
    @Value("${server.port}")
    private int serverPort;

    @GetMapping("/port")
    public String getPort() {
        return "Server Port: " + serverPort;
    }
}

使用 @ConfigurationProperties

通过 @ConfigurationProperties 批量注入配置。

1. 配置文件

app:
    name:MyApp
    version:1.0

2. 配置类

@Component
@ConfigurationProperties (prefix="app")
public class AppProperties {
    private String name;
    private String version;
}

3. 使用配置

@RestController
public class AppController {
    @Autowired
    private AppProperties appProperties;

    @GetMapping("/info")
    public String getInfo() {
        return "App: " + appProperties.getName() + ", Version: " + appProperties.getVersion();
    }
}

Spring Profile

通过 Spring Profile 实现环境的切换和配置隔离。

1. 配置文件

application-dev.yaml(开发环境配置)

server:
  port: 8081

application-prod.yaml(生产环境配置)

server:
  port: 8082

2. 激活Profile

命令行：

java -jar application.jar --spring.profiles.active=prod

配置文件：

spring.profiles.active=dev

外部配置文件

• 可以将配置文件放置在项目外部，运行时加载外部文件。
• 将配置文件 application.properties 放置到 /config 或根目录，并运行应用：

java -jar application.jar --spring.config.location=/path/to/application.properties

隐藏配置（加密配置）

敏感信息如数据库密码可以通过加密工具隐藏，并在运行时解密。

示例：
使用 Jasypt 加密：

1. 加密后的配置
spring.datasource.password=ENC(encrypted_password_here)

2. 在启动参数中传递解密密钥：
java -Djasypt.encryptor.password=secret_key -jar application.jar

Spring Cloud Config

在分布式环境中，使用Spring Cloud Config服务器集中管理配置。

配置文件存储在远程 Git 仓库，应用程序启动时从 Config Server 获取配置。

数据库存储配置

在某些场景下，应用配置可能存储在数据库中，运行时动态加载。

使用带Random.* 前缀的属性

在 Spring Boot 中，Random.* 前缀提供了一种便捷的方式，用于随机生成属性值。它是 Spring Framework 内置的功能，常用于生成随机的数值、UUID 等，适合动态配置一些测试参数或者临时值。

使用方式

配置文件中使用

random.int = ${random.int}
random.int-range=random.int(1,100)
random.long=${random.long}
random.long-range=${random.long(1000,5000)}
random.uuid=${random.uuid}
random.value=${random.value}

代码中使用

1.使用@value注解

@Restcontroller
public class RandomController {
    
    @Value(${random.value})
    public int randomInt;
}

2.使用Environment对象

import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RandomController {

    private final Environment env;

    public RandomController(Environment env) {
        this.env = env;
    }

    @GetMapping("/random")
    public String getRandomValues() {
        int randomInt = Integer.parseInt(env.getProperty("random.int"));
        long randomLong = Long.parseLong(env.getProperty("random.long"));
        String randomUuid = env.getProperty("random.uuid");
        return String.format("Random Int: %d, Long: %d, UUID: %s", randomInt, randomLong, randomUuid);
    }
}

3.注意点
Spring Boot 中的 Random.* 是通过 RandomValuePropertySource 实现的。以下是核心机制的解释：

 1.随机值属性源 (RandomValuePropertySource)：
    * Spring 在初始化 Environment 时会注册一个特殊的 PropertySource，叫做 RandomValuePropertySource。
    * 当你访问一个 random.int 或其他 Random.* 属性时，Spring 会拦截这些请求并动态调用随机生成逻辑
2.实时解析
    * 每次调用 Environment.getProperty("random.int")，Spring 都会触发 RandomValuePropertySource 的逻辑，生成新的随机值。
    * 因此，通过 Environment 获取的 Random.* 属性是动态的。
3.与 @Value 注解的差异
    * @Value("${random.int}") 是在应用启动时解析一次，并将值固定注入到字段中。
    * 而 Environment.getProperty("random.int") 每次访问都会触发新值的生成。

通过@PropertySource配置（加载外部文件）

@PropertySource的基本用法

1.加载属性文件

使用 @PropertySource 加载指定的.properties 文件，并结合 @Value注解获取属性值：

config.properties文件内容：

app.name=MyApplication
app.version=1.0.0

Java配置类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:config.properties")
public class AppConfig {

    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;

    public String getAppName() {
        return appName;
    }

    public String getAppVersion() {
        return appVersion;
    }
}

@PropertySource("classpath:config.properties")：表示从 classpath 下加载 config.properties 文件。
@Value("${app.name}")：用于将 app.name 的值注入到变量中。

使用Environment获取属性

除了使用 @Value，也可以通过 Spring 提供的 Environment 对象动态获取属性值：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

@Configuration
@PropertySource("classpath:config.properties")
public class AppConfig {

    @Autowired
    private Environment environment;

    public String getAppName() {
        return environment.getProperty("app.name");
    }

    public String getAppVersion() {
        return environment.getProperty("app.version");
    }
}

2.加载多个属性文件

如果需要加载多个属性文件，可以在 @PropertySource 中使用数组语法：

@Configuration
@PropertySource({"classpath:config.properties", "classpath:other-config.properties"})
public class MultiConfig {

    @Value("${app.name}")
    private String appName;

    @Value("${other.property}")
    private String otherProperty;

    // ...
}

3. 配置文件的优先级

当同一个属性在多个文件中定义时，后加载的文件会覆盖先加载的文件。

@PropertySource({"classpath:config.properties", "classpath:override-config.properties"})

4.文件路径的支持

Classpath路径：

@PropertySource("classpath:config.properties")

绝对路径：

@PropertySource("file:/path/to/config.properties")

相对路径：

@PropertySource("file:./config/config.properties")

Spring 表达式：

@PropertySource("file:${config.path}/config.properties")

支持的配置格式

@PropertySource 主要支持 .properties 文件。如果需要加载 .yml 文件，可以使用 Spring Boot 提供的配置方式，而不是 @PropertySource。

使用@PropertySource配合默认值

通过 @Value 注解时，可以为某些属性设置默认值，避免属性文件中缺失对应配置时报错。

@Value("${app.description:Default Description}")
private String appDescription;

使用 ignoreResourceNotFound

如果某些属性文件可能不存在，可以使用 ignoreResourceNotFound 参数避免启动失败：

动态刷新（结合 Spring Cloud 或手动实现）

@PropertySource 加载的属性文件默认只会在应用启动时加载一次。如果需要动态刷新，可以结合 @RefreshScope 或实现自定义逻辑（通常建议使用 Spring Cloud Config）。