SpringBoot四大神器之Stater&AutoConfiguration
SpringBoot四大神器
SpringBoot 四大神器之二 Starter
Spring Boot 特性
Spring Boot 可以轻松创建可以“直接运行”的独立的、生产级的基于 Spring 的应用程序。
- 创建独立的 Spring 应用程序
- 直接嵌入 Tomcat、Jetty 或 Undertow（无需部署 WAR 文件）
- 提供自以为是的“入门”依赖项以简化您的构建配置
- 尽可能自动配置 Spring 和 3rd 方库
- 提供生产就绪功能，例如指标、健康检查和外部化配置
- 完全无需代码生成，无需 XML 配置
SpringBoot Starter
传统方式搭建项目需要做什么？
1.加入相关的jar包
2．配置web.xml，加载spring和spring mvc
3．配置数据库连接、配置spring事务
4．配置加载配置文件的读取，开启注解
5．配置日志文件
…
配置完成之后部署tomcat调试
-
难点是什么?
包依赖
bean配置
-
这些是不是必需要做的?
-
Spring boot中，这些是不是starter帮我们做了?
SpringBoot Starter搭建项目做了什么？
- starter引入相关的jar
- starter自动完成bean配置
自动配置
自动配置：条件依赖注解：
@ConditionalOnClass @ConditionalOnMissingClass
@ConditionalOnBean @ConditionalOnMissingBean
@ConditionalOnProperty
@ConditionalOnResource
@ConditionalOnWebApplication @ConditionalOnNotWebApplication
@ConditionalOnExpression
@AutoConfigureAfter @AutoConfigureBefore @AutoConfigureOrder 指定顺序
疑问
疑问1:这些bean的依赖关系是如何自动处理的?
如︰如果我们没有配置datasource，那mybatis会被加载吗? 不会
疑问2:这些bean配置需要的参数是如何规定并获取的?
如:配置datasource需要数据库连接参数，mybatis也有自己的配置参数
疑问3:这些bean配置是如何被发现并加载的?
思考:
如果我们开发的一些通用组件，被很多项目使用，我们是不是可以制作一个starter，来简化使用。
开发自己的starter
Starter是一个集成接合器，完成两件事
引入相关的jar
自动配置
Spring boot规范
starter.jar完成引入相关的jar
autoConfigure.jar完成自动配置
也可以只用一个jar
Starter命名规范
Spring提供的starter: 以spring-boot-starter开头
-
spring-boot-starter-xxx-x.y.z.jar
-
spring-boot-starter-autoconfigure-x.y.z.jar
第3方的starter:
-
Xxx-spring-boot-starter-x.y.z.jar
-
xxx-spring-boot-autoconfigure-x.y.z.jar
动手制作一个第三方的starter
- 第一步：准备第三方的jar
- 第二步：制作starter
- 创建工程
- 引入spring-boot-starter、spring-boot-autoconfigure、第三方jar
- 如果需要生成配置元信息，加入spring-boot-configuration-processor依赖
- 编写自动配置类
- 编写发现配置文件：META-INF/spring.factories
- 打包发布
实例
-
第一步：准备第三方的jar，也就是独立的项目，这个项目只有一个UserService类
public class UserService { private String name; private int age; private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } @Override public String toString() { return "UserService{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + '}'; } public void doSomething(){ System.out.println("com.fengb.user.UserService.doSomething"); } } -
第二步：制作start，也就是创建一个项目
-
创建一个叫user-spring-boot-starter的项目
-
pom文件导入jar
<!--导入spring-boot-starter--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>2.6.3</version> </dependency> <!--导入第三方jar--> <dependency> <groupId>com.fengb.user</groupId> <artifactId>user</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <!--导入生成配置元信息的jar--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <version>2.5.12</version> </dependency> -
编写自动配置类和配置信息类
UserAutoConfiguration
@Configuration @EnableConfigurationProperties(UserProperties.class) public class UserAutoConfiguration { @Bean public UserService userService(@Autowired UserProperties properties){ UserService userService = new UserService(); userService.setName(properties.getName()); userService.setAge(properties.getAge()); userService.setSex(properties.getSex()); return userService; } }UserProperties
@ConfigurationProperties(prefix = "myuser") public class UserProperties { /** * 姓名 */ private String name; /** * 年龄 */ private int age; /** * 性别 */ private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } } -
编写发现配置文件：META-INF/spring.factories，在resources目录下
# Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.fengb.user.UserAutoConfiguration -
发布
-
-
第三步：使用
导入自定义的starter
<dependency> <groupId>com.fengb.user</groupId> <artifactId>user-spring-boot-starter</artifactId> <version>1.0-SNAPSHOT</version> </dependency>starter帮我们导入了相关的jar，并且配置了相关bean信息
测试类
@RestController public class UserController { @Autowired private UserService userService; @RequestMapping("/getUser") public String getUser(){ userService.doSomething(); return userService.toString(); } }配置信息
在application.properties中配置UserProperties信息
#user myuser.name=xiaojun myuser.age=20 myuser.sex=1spring-boot-configuration-processor生成配置元信息，如下是生成的信息
spring-boot-configuration-processor生成配置元信息后，在application.properties中提示，如下图：
META-INF/spring-configuration-metadata.json
{ "groups": [ { "name": "myuser", "type": "com.fengb.user.UserProperties", "sourceType": "com.fengb.user.UserProperties" } ], "properties": [ { "name": "myuser.age", "type": "java.lang.Integer", "description": "年龄", "sourceType": "com.fengb.user.UserProperties", "defaultValue": 0 }, { "name": "myuser.name", "type": "java.lang.String", "description": "姓名", "sourceType": "com.fengb.user.UserProperties" }, { "name": "myuser.sex", "type": "java.lang.String", "description": "性别", "sourceType": "com.fengb.user.UserProperties" } ], "hints": [] }访问：http://localhost:8080/getUser
SpringBoot 四大神器之三 AutoConfiguration
Spring Boot并不属于一种新的技术，只不过Spring Boot的启动器帮我们配置了若干个被spring管理的bean，当我们项目依赖这些jar并启动Spring应用时，Spring的container容器已经把jar包下的对象加以创建及管理了。
简而言之，Spring Boot自动配置代表了一种基于类路径上存在的依赖关系自动配置Spring应用程序的方法，还可以通过定义消除自动配置类中包含的某些bean。这一可以使开发更快更统一。
Spring Boot auto configuration的本质就是自动配置spring的各种bean，然后应用可以通过@Autowired等注入方式来直接只用bean。比如自动配置redisTemplate，jdbcTemplate等bean。
AutoConfiguration继承体系
1、继承spring-boot-starter-parent
2、继承spring-boot-dependencies
3、引入spring-boot-autodonfigure
AutoConfiguration的加载触发
1、注解EnableAutoConfiguration
2、AutoConfigurationImportSelector
3、通对selectImports加载自动配置信息
4、通getCandidateConfigurations加载META-INF/spring.factories
AutoConfiguration 官方集成框架
-
RabbitAutoConfiguration
-
JpaRepositoriesAutoConfiguration
-
ElasticsearchDataAutoConfiguration
-
RedisAutoConfiguration
-
EmbeddedMongoAutoConfiguration
-
HibernateJpaAutoConfiguration
更多参考官方地址：https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-auto-configuration-classes.html#auto-configuration-classes-from-autoconfigure-module
通过启动类创建Spring Boot应用
创建Spring Boot应用非常简单，只要创建一个包含main的启动类即可。
@SpringBootApplication
public class SpringbootDemoApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootDemoApplication.class);
}
}
上面这个类被称为Spring Boot应用的启动类，它通过一个java的main（）方法来引导和启动一个Spring应用。它通常包含了以下内容：
- 创建一个Spring ApplicationContext实例。
- 接收命令行参数并将其转为Spring属性。
- 按照配置加载所有Spring Bean。可以根据项目需求进行其他操作。
其中需要重点关注的就是@SpringBootApplication注解
@SpringBootApplication注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}
@SpringBootApplication注解应用的注解包含
-
元注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited -
非元注解
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
接下来看下@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan这三个注解
@SpringBootConfiguration
@SpringBootConfiguration注解继承自@Configuration注解，是在Spring Boot2中出现的一个新的注解。之前我们都是使用的 @Configuration注解，可以用 @Configuration来替换它，2个都是实现同样的功能。
它表示该类是一个配置类，应该对其进行扫描，以获得进一步的配置和bean定义。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
}
@EnableAutoConfiguration
@EnableAutoConfiguration注解用于启用Spring Application Context的自动配置
自动配置尝试尽可能智能，并在您定义更多自己的配置时进行后退。您始终可以使用两种方法来手动排除任何您不想应用的配置：
- 使用excludeName（）
- 使用spring.autoconfigure.exclude属性文件中的属性。
@ComponentScan
此注解提供了与Spring XML context:component-scan元素并行的支持。
无论是basePackageClasses()或basePackages()可以定义特定的软件包进行扫描。如果未定义特定包，则将从声明此注解的类的包进行扫描。
自动配置
自动配置-―条件依赖注解:
@ConditionalOnClass @ConditionalOnMissingClass 指定的类存在或不存在
@ConditionalOnBean @ConditionalOnMissingBean 指定的bean存在或不存在
@ConditionalOnProperty 指定的属性值存在或不存在
@ConditionalOnResource 类路径是否有指定的值
@ConditionalOnWebApplication @ConditionalOnNotWebApplication 是否为Web应用
@ConditionalOnExpression 当抛出某个异常的情况下
@AutoConfigureAfter @AutoConfigureBefore @AutoConfigureOrder 指定顺序
要创建自定义自动配置，我们需要创建一个注释为@Configuration的类并注册它
让我们为MySQL数据源创建自定义配置：
@Configuration
public class MySQLAutoconfiguration {
//...
}
下一个必须的步骤是通过在标准文件资源/ META-INF/spring.factories中的属性org.springframework.boot.autoconfigure.EnableAutoConfiguration下添加类的名称，将类注册为自动配置候选者：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.peterwanghao.samples.springboot.autoconfiguration.MySQLAutoconfiguration
如果我们希望我们的自动配置类优先于其他自动配置候选者，我们可以添加@AutoConfigureOrder（Ordered.HIGHEST_PRECEDENCE）注解。
自动配置是使用标有@Conditional注解的类和bean设计的，以便可以替换自动配置或其特定部分。
请注意，只有当应用程序中未定义自动配置的bean时，自动配置才有效。如果您定义了bean，那么将覆盖默认值
基于类的条件注解
@ConditionalOnClass和@ConditionalOnMissingClass
Class conditions允许我们指定使用@ConditionalOnClass注解指定的类，或者使用@ConditionalOnMissingClass注解来指定不存在于 classpath 上的类。
让我们指定只有存在类DataSource的情况下才会加载MySQLConfiguration，在这种情况下我们可以假设应用程序将使用数据库：只有DataSource.class存在的情况下，才有效
@Configuration
@ConditionalOnClass(DataSource.class)
public class MySQLAutoconfiguration {
//...
}
基于bean条件注解
如果我们只想在指定的bean存在的情况下包含bean，我们可以使用@ConditionalOnBean和@ConditionalOnMissingBean注解。
举例说明，让我们将一个entityManagerFactory bean 添加到我们的配置类中，并指定如果存在一个名为dataSource的bean 并且尚未定义一个名为entityManagerFactory的 bean，我们就创建这个bean ：
@Bean
@ConditionalOnBean(name = "dataSource")
@ConditionalOnMissingBean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource());
em.setPackagesToScan("com.peterwanghao.samples.springboot.autoconfiguration.example");
em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
if (additionalProperties() != null) {
em.setJpaProperties(additionalProperties());
}
return em;
}
让我们配置一个只在尚未定义类型为JpaTransactionManager的bean时才会加载的transactionManager bean ：
@Bean
@ConditionalOnMissingBean(type = "JpaTransactionManager")
JpaTransactionManager transactionManager(final EntityManagerFactory entityManagerFactory) {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory);
return transactionManager;
}
基于属性的条件注解
@ConditionalOnProperty注解用于指定是否配置将基于Spring环境属性的存在和值被加载。
首先，让我们为配置添加一个属性源文件，
@PropertySource("classpath:mysql.properties")
public class MySQLAutoconfiguration {
//...
}
我们可以配置主DataSource bean，它将用于创建与数据库的连接，只有在存在名为usemysql的属性时才会加载它。
我们可以使用属性havingValue来指定必须匹配的usemysql属性的某些值。
如果usemysql属性设置为local，让我们使用默认值定义dataSource bean，该默认值连接到名为myDb的本地数据库：
@Bean
@ConditionalOnProperty(name = "usemysql", havingValue = "local")
@ConditionalOnMissingBean
public DataSource dataSource() {
final DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true&&serverTimezone=GMT%2B8");
dataSource.setUsername("root");
dataSource.setPassword("123456");
return dataSource;
}
如果usemysql属性设置为自定义，则数据源 bean将使用自定义属性值的数据库URL，用户和密码进行配置：
@Bean(name = "dataSource")
@ConditionalOnProperty(name = "usemysql", havingValue = "custom")
@ConditionalOnMissingBean
public DataSource dataSource2() {
final DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl(env.getProperty("mysql.url"));
dataSource.setUsername(env.getProperty("mysql.user") != null ? env.getProperty("mysql.user") : "");
dataSource.setPassword(env.getProperty("mysql.pass") != null ? env.getProperty("mysql.pass") : "");
return dataSource;
}
该mysql.properties文件将包含usemysql属性：
usemysql=local
如果使用MySQLAutoconfiguration的应用程序希望覆盖默认属性，则它需要做的就是为mysql.properties文件中的mysql.url，mysql.user和mysql.pass属性添加不同的值以及添加usemysql = custom行。
基于资源的条件注解
@ConditionalOnResource，只有存在某个配置文件时，才有效
让我们定义一个名为additionalProperties（）的方法，该方法将返回一个Properties对象，该对象包含entityManagerFactory bean 使用的特定于Hibernate的属性，仅当存在资源文件mysql.properties时：
@ConditionalOnResource(resources = "classpath:mysql.properties")
@Conditional(HibernateCondition.class)
final Properties additionalProperties() {
final Properties hibernateProperties = new Properties();
hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("mysql-hibernate.hbm2ddl.auto"));
hibernateProperties.setProperty("hibernate.dialect", env.getProperty("mysql-hibernate.dialect"));
hibernateProperties.setProperty("hibernate.show_sql",
env.getProperty("mysql-hibernate.show_sql") != null ? env.getProperty("mysql-hibernate.show_sql")
: "false");
return hibernateProperties;
}
我们可以将Hibernate特定的属性添加到mysql.properties文件中：
mysql-hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
mysql-hibernate.show_sql=true
mysql-hibernate.hbm2ddl.auto=create-drop
自定义条件
如果我们不想使用Spring Boot中的任何可用条件，我们还可以通过扩展SpringBootCondition类并重写getMatchOutcome（）方法来定义自定义条件。
让我们为additionalProperties（）方法创建一个名为HibernateCondition的条件，该方法将验证类路径上是否存在HibernateEntityManager类：
申请条件
我们还可以通过添加@ConditionalOnWebApplication或@ConditionalOnNotWebApplication注释来指定只能在Web上下文内部/外部加载配置。
禁用自动配置
如果我们想要从加载中排除自动配置，我们可以将带有exclude或excludeName属性的@EnableAutoConfiguration注解添加到配置类：
@Configuration
@EnableAutoConfiguration(exclude={MySQLAutoconfiguration.class})
public class AutoconfigurationApplication {
//...
}
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {
}
禁用特定自动配置的另一个方法是设置spring.autoconfigure.exclude属性：
spring.autoconfigure.exclude=com.peterwanghao.samples.springboot.autoconfiguration.MySQLAutoconfiguration
SpringBoot参数详解
SpringBoot参数配置规则
SpringBoot应用中可以在哪里配置参数?
classpath:/下的application.properties 和application.yml
参数配置文件的名称有什么要求没？
application.properties和application.yml
只能取这样的名字么？参数配置文件的位置有要求么？
classpath:/
只能放在这里吗？
classpath:/ 指的是resources目录
参数配置文件的规则
参数配置文件的约定名称
application.properties / application.yml
参数配置文件的约定位置(优先级从高到低)为：
- 运行程序的当前目录下的config子孙目录file：./config/*/
- 运行程序的当前目录下的config子目录file：./config
- 运行程序的当前目录file:./
- classpath:/config子目录
- classpath:/根目录
问题：为什么这么约定，直接放在classpath:/下不可以么？
看下ConfigFileApplicationListener
public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
// Note the order is from least to most specific (last one wins)
private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/*/,file:./config/";
private static final String DEFAULT_NAMES = "application";
/**
* The "active profiles" property name.
*/
public static final String ACTIVE_PROFILES_PROPERTY = "spring.profiles.active";
/**
* The "includes profiles" property name.
*/
public static final String INCLUDE_PROFILES_PROPERTY = "spring.profiles.include";
/**
* The "config name" property name.
*/
public static final String CONFIG_NAME_PROPERTY = "spring.config.name";
/**
* The "config location" property name.
*/
public static final String CONFIG_LOCATION_PROPERTY = "spring.config.location";
/**
* The "config additional location" property name.
*/
public static final String CONFIG_ADDITIONAL_LOCATION_PROPERTY = "spring.config.additional-location";
//..........................
}
- spring.config.name：来指定配置文件的名称，修改默认配置文件的名称
- spring.config.location：来指定配置文件的位置，修改默认配置文件的位置
哪在什么地方指定spring.config.name和spring.config.location属性值？
参数指定方式规则
- 指定spring.config.name和spring.config.location属性的三种方式
- 程序命令行参数：–spring.config.name=xxx
- JVM参数：-Dspring.config.name=xxx
- 操作系统环境变量：spring.config.name=xxx
- spring.config.name属性特殊说明
- spring.config.location可以配置多个值（用逗号分割）
- 查找的顺序是配置的反顺序，即：从后先前查找
- spring.config.location属性特殊说明
- spring.config.location指定配置文件所在目录（以/结尾）或文件名，可以配置多个值（用逗号分割）
- 查找的顺序是配置的反顺序，即：从后先前查找
- spring.config.additional-location属性说明
除了默认的规则外用来指定额外补充的配置文件目录或者配置文件
优先级高于spring.config.location
其他方式配置参数
除了可以在参数配置文件中配置参数外，还有其他方式配置参数吗？
SpringBoot参数配置语法
配置文件格式
配置文件的格式为xxx.properties和xxx.yml这两种
例如：
- applicaton.properties
- appliation.yml
参数引用
${xxx.xxx}
例如：
my.info=${my.name} age is ${my.age}
参数随机值
如果你的配置中需要随机值，可以通过RandomValuePropertySource源获得随机的int、long、 uuid、字符串
例如：
myuser.age=${random.int}
参数值加密
password=eadesdrefdaf8efacnanaeijr91qw
-
实现一个EnvironmentPostProcessor,在里面完成密文值的解密
-
将这个实现加到META-INF/spring.factories 中，让其生效
YAML语法
很简单，参考学习: https://blog.csdn.net/vincent_hbl/article/details/75411243
去看架构基础》标记语言之YAML
SpringBoot参数使用详解
SpringBoot参数三种使用方式
-
方式一：@Value
@Value("${myuser.name}") -
方式二：注入Enviroment的bean
-
方式三：@ConfigurationProperties(prefix=“myuser”)
- 加在一个bean类上，给bean的属性进行赋值，属性需有
getters and setters - 有两种使用方式
使用方式一：
可以把@ConfigurationProperties直接定义在类上
@EnableConfigurationProperties(UserProperties.class) public class UserAutoConfiguration { //...... } @ConfigurationProperties(prefix = "myuser") public class UserProperties { /** * 姓名 */ private String name; /** * 年龄 */ private int age; /** * 性别 */ private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } }使用方式二：
可以把@ConfigurationProperties还可以直接定义在@bean的注解上或者类bean上
- @bean的注解上
@Component public class UserFactory { @Bean @ConfigurationProperties(prefix = "myuser") public User user(){ return new User(); } }- 类bean上
@Component("User") @ConfigurationProperties(prefix = "myuser") public class User { /** * 姓名 */ private String name; /** * 年龄 */ private int age; /** * 性别 */ private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + '}'; } } - 加在一个bean类上，给bean的属性进行赋值，属性需有
@ConfigurationProperties属性名灵活绑定
类中属性名一般会采用驼峰方式，配置参数名也要驼峰吗?
类中属性名一般会采用驼峰方式，配置参数名可以用如下方式:
Spring Boot 使用一些宽松的规则将Environment属性绑定到bean，因此属性名称和 bean 属性名称@ConfigurationProperties之间不需要完全匹配。Environment这很有用的常见示例包括破折号分隔的环境属性（例如，context-path绑定到contextPath）和大写环境属性（例如，PORT绑定到port）。
- 宽松规则
| Property | Note |
|---|---|
my.main-project.person.first-name | 推荐用于.properties和.yml文件。 |
my.main-project.person.firstName | 标准驼峰式语法。 |
my.main-project.person.first_name | 下划线表示法，这是在文件中使用的另一种.properties格式.yml。 |
MY_MAINPROJECT_PERSON_FIRSTNAME | 大写格式，在使用系统环境变量时推荐使用。 |
- 每个属性源的宽松绑定规则
| 属性来源 | 简单的 | 列表 |
|---|---|---|
| 属性文件 | Camel case、kebab case 或下划线表示法 | [ ]使用逗号分隔值的标准列表语法 |
| YAML 文件 | Camel case、kebab case 或下划线表示法 | 标准 YAML 列表语法或逗号分隔值 |
| 环境变量 | 下划线作为分隔符的大写格式（请参阅从环境变量绑定）。 | 下划线包围的数值（请参阅从环境变量绑定） |
| 系统属性 | Camel case、kebab case 或下划线表示法 | [ ]使用逗号分隔值的标准列表语法 |
命名方式：
Camel case：驼峰命名方式kebab case：短横线命名方式- 下划线
@ConfigurationProperties和@Value
| 特征 | @ConfigurationProperties | @Value |
|---|---|---|
| 轻松绑定 | 是的 | 有限（见下文注释） |
| 元数据支持 | 是的 | 不 |
SpEL评估 | 不 | 是的 |
SpringBoot Profiles详解
profile是什么?
-
Spring配置文件提供的一种隔离应用程序配置的方法，使其仅在特定环境中可用。
-
可通过profile指定Bean的应用环境(如开发、测试、生产等环境)
-
可通过profile指定不同环境的配置参数值
profile指定bean的应用环境
任何@Component、@Configuration都可以用@Profile来标记，以便在加载时进行限制。
<beans profile="dev">
<bean id="user" class="com.bfeng.springbootdemo.user.UserController"></bean>
</beans>
profile指定不同环境的参数配置
方式一：通过不同的环境配置文件来区分
application.properties application-dev.properties或者application-dev.yml
方式二：在同一个配置文件中进行区分
---：分割不同配置
---
spring:
profiles:
active: default
myuser:
name: ${random.int}-default
age: 19
sex: 1
---
spring:
profiles:dev
myuser:
name: ${random.int}-dev
age: 19
sex: 1
---
spring:
profiles:test
myuser:
name: ${random.int}-test
age: 19
sex: 1
---
spring:
profiles:prod
myuser:
name: ${random.int}-prod
age: 19
sex: 1
指定程序启用的profiles
- 通过配置参数spring.profiles.active来指定应用启用的profiles（目前对应使用方式一）
环境变量、jvm参数、命令行程序参数、application.properties中都可以
命令行参数：-Dspring.profiles.active=dev
java -jar -Dspring.profiles.active=dev xxx.jar
JVM参数： --spring.profiles.active=prod
java -jar xxx.jar --spring.profiles.active=dev
系统属性： spring.profiles.active=test
- 编程式指定启用的环境
SpringApplication.setAdditionalProfiles(...)
注意事项
没有通过spring.profiles.active指定启用的profiles时，将使用-default的（如果有)
通过spring.config.location指定的配置文件不会应用profile，目录会
SpringBoot通用应用属性配置
SpringBoot我们具体配置那些参数？怎么配置？到哪里去查找？
查找地址：https://docs.spring.io/spring-boot/docs/current/reference/html/index.html
具体使用那些参数，请到进入应用程序属性里边查找，包含核心属性、缓存属性、数据属性、集成属性等等
ex: 1
spring:
profiles:dev
myuser:
name: ${random.int}-dev
age: 19
sex: 1
spring:
profiles:test
myuser:
name: ${random.int}-test
age: 19
sex: 1
spring:
profiles:prod
myuser:
name: ${random.int}-prod
age: 19
sex: 1
#### 指定程序启用的profiles
- 通过配置参数spring.profiles.active来指定应用启用的profiles（目前对应使用方式一）
环境变量、jvm参数、命令行程序参数、application.properties中都可以
```properties
命令行参数：-Dspring.profiles.active=dev
java -jar -Dspring.profiles.active=dev xxx.jar
JVM参数： --spring.profiles.active=prod
java -jar xxx.jar --spring.profiles.active=dev
系统属性： spring.profiles.active=test
[外链图片转存中…(img-vMW8rLo9-1748236777843)]
- 编程式指定启用的环境
SpringApplication.setAdditionalProfiles(...)
注意事项
没有通过spring.profiles.active指定启用的profiles时，将使用-default的（如果有)
通过spring.config.location指定的配置文件不会应用profile，目录会
SpringBoot通用应用属性配置
SpringBoot我们具体配置那些参数？怎么配置？到哪里去查找？
查找地址：https://docs.spring.io/spring-boot/docs/current/reference/html/index.html
[外链图片转存中…(img-wozRwxmJ-1748236777843)]
具体使用那些参数，请到进入应用程序属性里边查找，包含核心属性、缓存属性、数据属性、集成属性等等
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
