spring自定义配置文件_spring的配置文件怎么写

⑴ 二、springboot配置文件

1. 配置文件

Spring Boot使用一个全局的配置文件

application.properties

application.yml

配置文件的作用：修改Spring Boot自动配置的默认值，SpringBoot在底层都给我们自动

配置好。有什么配置项，可以移步官方文档

配置文件一般放在src/main/resources目录或者类路径/confifig下，当然还有很多位置可

以放，它们会有不同优先级，后面会讲到。

YAML （YAML Ain't Markup Language）

简单介绍



<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-configuration-processor</artifactId>

<optional>true</optional>

</dependency>



<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>以前的配置文件：大多是xml

.yml是YAML语言的文件，以数据为中心，比json、xml等更适合做配置文件

全局配置文件的可以对一些默认配置值进行修改

配置实例

xml：

yml:

2. YAML语法

基本语法

K:(空格)V 标识一对键值对

以空格的缩进来控制层级关系

只要是左对齐的一列数据，都是同一层级的

属性和值也是大小写敏感

实例：

值的写法

普通的值

k: v 字面量直接来写，字符串默认不用添加单引号

" " 双引号不会转义字符串里面的特殊字符；

<server>

<port>8081</port>

</server>

server:

port: 8081

server:

port: 8081

path: /hello // 冒号后面的空格不要拉下' ' 单引号会转义字符，特殊字符最终是一个普通的字符串

对象

普通写法：

行内写法

frends:{ lastName: zhang,age: 18 }

Map

示例：

maps: {k1: v1,k2: v2}

数组

普通写法：

pets: // var onj = {pets: ['cat','pig','dog']}

- cat

- pig

- dog

行内写法

pets:[cat, pig, dog]

配置文件获取

将配置文件中的每一个值映射到此组件中

1. Persion

name: "wang \n qian" // 输出：wang 换行 qian

frends:

lastName: zhang

age: 20package com.wrq.boot.bean;

@Component

@ConfigurationProperties(prefix = "persion")

public class Persion {

private String name;

private int age;

private double weight;

private boolean boss;

private Date birth;

private Map<String,Object> maps;

private List<Object> list;

private Dog dog;

此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！

}

@ConfifigurationProperties 意思是:我们类里面的属性和配置文件中的属性做绑定

不使用此注解，可以在bean的属性添加@value()注解，如下：

@Component

// @ConfigurationProperties(prefix = "persion")

public class Persion {

@value("${persion.name}") // $()读取配置文件、环境变量中的值

private String name;

@value("#{11*2}") // #{SpEL} 采用表达式

private int age;

@value("true") // 直接赋值

private boolean boos;

}

此处采用@ConfifigurationProperties的方式，@value()和@ConfifigurationProperties的

区别见下方表格。prefifix = "persion" 配置文件中那个下面的属性来一一映射

@Component 如果想要这个注解起作用，必须放到容器里面

2. Dog

package com.wrq.boot.bean;

public class Dog { // 用作Persion中的属性

private String name;

private int age;

此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！

}

3. 配置文件

方式一: application.yml

persion:

name: 王大锤

age: 18

weight: 125

boss: false

birth: 2018/5/5

maps: {k1: v1,k2: v2}

list:

- wangli

- wang

dog:

name: xiaogou

age: 2

方式二: application.propertiespersion.name = 王大锤

persion.age = 18

persion.weight = 125

persion.boss = false

persion.birth = 2018/5/5

persion.maps.k1 = v1

persion.maps.k2 = v2

persion.dog.name = xiaogou

persion.dog.age = 15

4. 测试类：BootApplicationTests

package com.wrq.boot;

@RunWith(SpringRunner.class)

@SpringBootTest

public class BootApplicationTests {

@Autowired

Persion persion;

@Test

public void contextLoads() {

System.out.print(persion);

}

}

5. 运行 BootApplicationTests方法

控制台打印：

application.yml的结果：

Persion{name='王大锤', age=18, weight=125.0, boss=false, birth=Sat May

05 00:00:00 CST 2018, maps={k1=v1, k2=v2}, list=[wangli, wang],

dog=Dog{name='xiaogou', age=2}}

application.properties的结果：

Persion{name='ï¿½ï¿½Ç¬', age=18, weight=125.0, boss=false, birth=Sat

May 05 00:00:00 CST 2018, maps={k2=v2, k1=v1}, list=[wangli, wang],

dog=Dog{name='xiaogou', age=15}}

把Bean中的属性和配置文件绑定，通过yml文件和properties都可以做到,但是properties

文件出现乱码。

properties中文读取乱码：File->Settings->File Encodings最底部选utf-8、Tranparent打

上勾

注解比较

@value和@ConfifigurationProperties获取值比较

名词解释:

松散绑定

last-name和lastName都可以获取导致，则代表支持松散绑定

JSR303@Component

@ConfigurationProperties(prefix = "persion") // 如果使用的是@value注入值

时，无法使用校验

@Validated // 添加此注解

public class Persion {

@Email // 配置文件书写的属性必须是邮箱格式，不符合报错！

private String name;

}

复杂类型封装

如果获取配置文件中map的值时,@value是获取不到值的

@value("${persion.maps}") // 由于使用的是@value，无法获取配置文件中的map

private Map<String,Object> maps;

@PropertySource

@PropertySource：加载指定配置文件

@ConfifigurationProperties()默认是从全局配置文件中获取值，也就是

application.properties这个文件中获取值。

如果做的配置很多，全局的配置文件就会特别大，为了方便管理。我会创建不同的配置文

件定向管理不同的配置。

如创建persion.properties文件单独存放persion需要的配置

@PropertySource就是用来导入创建的配置文件

示例：

1. persion.properties

同时把两个全局的配置中关于Persion的配置都注释掉persion.name = 王弟弟

persion.age = 18

persion.weight = 125

persion.boss = false

persion.birth = 2018/5/5

persion.maps.k1 = v1

persion.maps.k2 = v2

persion.dog.name = xiaogou

persion.dog.age = 15

2. Persion

package com.wrq.boot.bean;

@Component

@PropertySource(value = {"classpath:persion.properties"})

@ConfigurationProperties(prefix = "persion")

public class Persion {

private String name;

private int age;

private double weight;

private boolean boss;

private Date birth;

private Map<String,Object> maps;

private List<Object> list;

private Dog dog;

此处，这个bean的getter、setter和tostring方法已经省略，千万不能忽略！

}

这样运行测试类，控制台就可以打印persion.properties中的数据。

通过下面的注解，把类路径下的persion.properties加载进来。并且把persion开头的数

据进行绑定。

@PropertySource(value = {"classpath:persion.properties"})@ConfifigurationProperties(prefifix = "persion")

@ImportResource

@ImportResource：导入Spring的配置文件，让配置文件生效。

示例：

1. com.wrq.boot.service

package com.wrq.boot.service;

/**

* Created by wangqian on 2019/1/12.

*/

public class HelloService {

}

2. resources目录手动建立bean.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="helloService" class="com.wrq.boot.service.HelloService">

</bean>

</beans>

3. 测试类

package com.wrq.boot;

@RunWith(SpringRunner.class)

@SpringBootTest

public class BootApplicationTests {

@Autowired

ApplicationContext ioc;@Test

public void testConfig() {

boolean b = ioc.containsBean("helloService");

System.out.print(b);

}

}

试图通过添加一个Spring的配置文件bean.xml来把HelloService注入进去。

运行测试类结果：false

结果表明IoC容器中并不包含HelloService，即：配置文件bean.xml没有生效

解决方式

方式一：主程序中进行配置@ImportResouece注解

package com.wrq.boot;

@ImportResource(locations = {"classpath:bean.xml"}) // 通过此配置是

bean.xml生效

@SpringBootApplication

public class BootApplication {

public static void main(String[] args) {

//应用启动起来

SpringApplication.run(BootApplication.class, args);

}

}

方法二：通过配置类实现，这种方式也是Spring Boot推荐的

1. com.wrq.boot.confifigpackage com.wrq.boot.config;

/**

* Created by wangqian on 2019/1/12.

*/

@Configuration

public class MyConfig {

// 将方法的返回值添加到容器之中,并且容器中这个组件的id就是方法名

@Bean

public HelloService helloService(){

System.out.print("通过@Bean给容器添加组件了..");

return new HelloService();

}

}

@Confifiguration标注这是一个配置类

通过@Bean注解，将方法的返回值添加到容器之中,并且容器中这个组件的id就是方

法名

2. 把主程序类中@ImportResource()配置注释掉

3. 测试成功，添加了HelloService()组件

3. 配置文件占位符

随机数

RandomValuePropertySource：配置文件中可以使用随机数

${random.value}

${random.int}

${random.long}

${random.uuid}

${random.int(10)}

${random.int[1024,65536]}

属性配置占位符可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）

${app.name:默认值}来指定找不到属性时的默认值

persion.name = 王弟弟${random.uuid}

persion.age = ${random.int}

persion.dog.name = ${persion.name}_dog

4. Profifile 多环境支持

Profifile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式

快速切换环境

1. 多Profifile的方式

格式：application-{profifile}.properties/yml

application-dev.properties

application-prod.properties

默认采用application.properties配置文件，如果使用别的，需要激活：

1. application.properties中配置：

# 激活application-dev.properties配置文件

spring.profiles.active=dev

2. application-dev.properties:

server.port=8082

3. 运行BootApplication主程序:

2019-01-12 20:46:09.345 INFO 14404 --- [main]

s.b.c.e.t. : Tomcat started on port(s):

8082 (http)

2. 多文档块的方式

除了上方多Profifile的方式来切换环境，也可以通过YAML多文档块的方式。示例:

application.yml:

server:

port: 8081

spring:

profiles:

active: dev

---

spring:

profiles: dev

server:

port: 8083

---

spring:

profiles: prod

server:

port: 8084

3. 激活指定Profifile

1. application.properties中配置：

# 激活application-dev.properties配置文件

spring.profiles.active=dev

2. application.yml中配置

server:

port: 8081

spring:

profiles:

active: dev

---

spring:

profiles: dev

server:

port: 80833. 启动配置-参数

在IDE中，类似于配置tomcat的地方，按下方配置：

Program arguments:--spring.profiles.active=dev

4. 启动配置-虚拟机

在IDE中，类似于配置tomcat的地方，按下方配置：

VM options:-Dspring-profiles-active=dev

5. 命令行使用Maven的package命令打包，移动到jar的目录。

java -jar spring-boot-project-config.jar --spring.profiles.active=dev

5. 配置文件优先级

GitHub对应项目：boot-confifig-position

优先级

Spring Boot 启动会扫描以下位置的application.properties或者 application.yml文件作

为Spring boot的默认配置文件

fifile:./confifig/ (项目根目录confifig文件夹下的配置文件)

fifile:./ (项目根目下的配置文件)

classpath:/confifig/ (resources目录confifig文件夹下的配置文件)

classpath:/ (resources目下的配置文件)

以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆

盖低优先级配置内容,形成互补配置。

默认配置

我们也可以通过配置spring.confifig.location来改变默认配置。

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

位置；指定配置文件和默认加载的这些配置文件共同起作用，形成互补配置。

1. Maven->package对项目打包2. 把待使用的配置文件放在本地文件夹中，如：D:/application.properties

3. 命令行执行命令

java -jar boot-config-position-xxxxxx.jar --

spring.config.location=D:/application.properties

这样即使项目上线了，我们也可以通过修改本地的配置文件，使用一行命令即可，极大方

便了运维人员。

6. 外部配置加载顺序

Spring Boot 支持多种外部配置方式

可以从以下位置加载配置，优先级从高到低，高优先级配置覆盖低优先级的，所以配置形

成互补配置。

1. 命令行参数

java -jar boot-config-position-xxxxxx.jar --server.port // 多个配置用空格

隔开

2. 来自java:comp/env的JNDI属性

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

4. 操作系统环境变量

5. RandomValuePropertySource配置的random.*属性值

6. jar包外部的application-{profifile}.properties或application.yml(带spring.profifile)配

置文件

7. jar包内部的application-{profifile}.properties或application.yml(带spring.profifile)配

置文件

8. jar包外部的application.properties或application.yml(不带spring.profifile)配置文件

9. jar包内部的application.properties或application.yml(不带spring.profifile)配置文件

10. @Confifiguration注解类上的@PropertySource

11. 通过SpringApplication.setDefaultProperties指定的默认属性

注意：从jar包外向jar包内寻找，优先加载profifile最后加载不带profifile，更多参考官方文

档

7. 自动配置原理GitHub对应项目：boot-confifig-autoconfifig

1. 配置文件写什么？

配置文件可配置属性查阅

2. 什么是注解，如何实现一个注解？

关于注解的机制和相关原理可以移步此篇博客

3. 配置原理解析

我们运行Spring Boot应用是从main方法启动，在主程序类上有一个

@SpringBootApplication注解。

@SpringBootApplication是一个复合注解，包括@ComponentScan，和

@SpringBootConfifiguration，@EnableAutoConfifiguration。

@SpringBootConfifiguration继承自@Confifiguration，二者功能也一致，标注当前类

是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到

srping容器中，并且实例名就是方法名。

@EnableAutoConfifiguration的作用启动自动的配置，@EnableAutoConfifiguration注

解的意思就是SpringBoot根据你添加的jar包来配置你项目的默认配置，比如根据

spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，就

会自动的帮你配置web项目中所需要的默认配置

@ComponentScan，扫描当前包及其子包下被@Component，@Controller，

@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的co

ntext:component-scan（以前使用在xml中使用的标签，用来扫描包配置的平行支

持）。

@SpringBootApplication注解分析

配置原理视频讲解

4. 自动配置类判断

在配置文件properties中设置：debug=true 来让控制台打印自动配置报告，方便的得知

那些配置类生效。

=========================

AUTO-CONFIGURATION REPORT

=========================Positive matches:

-----------------

matched:

- @ConditionalOnClass found required class

'org.springframework.web.servlet.DispatcherServlet';

@ConditionalOnMissingClass did not find unwanted class

(OnClassCondition)

- @ConditionalOnWebApplication (required) found 'session' scope

(OnWebApplicationCondition)

Negative matches:

-----------------

ActiveMQAutoConfiguration:

Did not match:

- @ConditionalOnClass did not find required classes

'javax.jms.ConnectionFactory',

'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

⑵ Spring Boot 第二弹，配置文件详解-史上最全

Spring Boot 官方提供了两种常用的配置文件格式，分别是 properties 、 YML 格式。相比于 properties 来说， YML 更加年轻，层级也是更加分明。 强烈推荐使用 YML 格式

Spring Boot项目启动会扫描以下位置的 application.properties 或者 application.yml 作为默认的配置文件.

徒手撕源码

内部类Loader的load方法

getSearchLocations()方法

asResolvedSet()

下面给出优先级从高到低的配置文件排列顺序：

以设置应用端口为例初体验Spring Boot配置文件

properties后缀结尾(application.properties)

yml/yaml后缀结尾(application.yml/application.yaml)

数字，字符串，布尔，日期

对象、Map

数组

数字，字符串，布尔，日期

对象、Map

数组

@ConfigurationProperties(prefix = "person")详解

标注在类上

标注在方法上

综上所述

@ConfigurationProperties 注解能够轻松的让配置文件跟实体类绑定在一起。

值得关注的是： @ConfigurationProperties 这个注解仅仅是支持从 Spring Boot的默认配置文件中取值，也就是 application.properties 、 application.yml 、 application.yaml ，那我们如何从自定义配置文件取值呢？？？

别着急，有解决办法，那就是再加一个注解： @PropertySource(value = "classpath:custom-profile.properties") ,下面会有对 @PropertySource 注解的介绍。请耐心往下面看。

使用@PropertySource注解

对应配置文件

创建两个配置文件 custom-profile.yml、custom-profile1.yml ，如下去引入。

我们可以通过控制变量法进行测试，具体过程我这里就不赘述了。

直接说结论吧： Spring加载顺序为从左到右顺序加载，后加载的会覆盖先加载的属性值。

另外需要注意的是 ： @PropertySource 默认加载 xxx.properties类型的配置文件，不能加载 YML格式的配置文件。如何解决呢？下面来解决这一问题

对应配置文件：

编写PropertiesController

扩展功能

application.yml 主配置文件

application-dev.yml 开发配置文件

application-prod.yml 生产配置文件

application-test.yml 测试配置文件

（1）主配置文件：配置激活选项

（2）其他配置文件：指定属于哪个环境（同yml，只不过表现形式是 key=value 的,三个配置文件分别是： application-dev.properties , application-prod.properties , application-test.properties ）

无论是使用上述多文档块的方式，还是新建 application-test.yml 文件，都可以在配置文件中指定 spring.profiles.active=test 激活指定的profile。

感谢阅读小生文章。祝大家早日富可敌国，实现财富自由。

写文不易 ,一定要点赞、评论、收藏哦 , 感谢感谢感谢!!!

⑶ SpringBoot的自定义配置

SpringBoot免除了项目中大部分的手动配置，对一些特定情况，我们可以通过修改全局配置文件以适应具体生产环境，可以说，几乎所有的配置都可以写在application.properties文件中，SpringBoot会自动加载全局配置文件，从而免除我们手动加载的烦恼。但是，如果我们自定配置文件，SpringBoot是无法识别这些配置文件的，此时就需要我们手动加载。接下来，将针对SpringBoot的自定义配置文件及其加载方式进行讲解。

对于这种加载自定义配置文件的需求，可以使用@PropertySource注解结合@Configuration注解配置类的方式来实现。@PropertySource注解用于指定自定义配置文件的具体位置和名称。同时，为了保证SpringBoot能够扫描该注解，还需要类添加@Configuartion注解将实体类作为自定义配置类。
当然，如果需要将自定义配置文件中的属性值注入到对应类的属性中，可以使用@ConfigurationProperties或者@Value注解进行属性值注入

打开SpringBoot项目的resources目录，在项目的类路径下新建一个test.properties自定义配置文件，在该配置文件中编写需要的配置属性

在com.david.pojo包下新创建一个配置类MyProperties，提供 test.properties 自定义配置文件中对应的属性，并根据@PropertySource注解的使用进行相关配置

主要是一个自定义配置类，通过相关注解引入了自定的配置文件，并完成了自定义属性值的注入。针对示例中的几个注解，具体说明如下：
1）@Confiruation注解表示当前类是一个自定义配置类，并添加为Spring容器的组件，这里也可以使用传统的@Component注解
2）@PropertySource("classpath:properties")注解指定了自定义配置文件的位置和名称，此示例表示自定义配置文件为classpath类路径下的 test.properties 文件
3）@ConfigurationProperties(prefix="test")注解将上述自定义配置文件 test.properties 中以test开头的属性值注入到该配置类属性中
4）如果配置类上使用的是@Componnet注解而非@Configuration注解，那么@EnableConfigurationProperties注解还可以省略

在SpringBoot框架中，推荐使用配置类的方式向容器中添加和配置组件
在SpringBoot框架中，通常使用@Configuration注解定义一个配置类，SpringBoot会自动扫描和识别配置类，从而替换传统Spring框架中的XML配置文件。
当定义一个配置类后，还需要在类中的方法上使用@Bean注解进行组件配置，将方法的返回对象注入到Spring容器中，并且组件名称默认使用的是方法名，当然也可以使用@Bean注解的name或value属性自定义组件的名称

在项目下新建一个

⑷ spring的配置文件怎么写

标准的Spring配置文件编写：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
default-autowire="byName" default-lazy-init="true">


<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>
jdbc:mysql://localhost/ssh?characterEncoding=utf-8
</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123</value>
</property>
</bean>


<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>com/ssh/pojo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>


<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>


<bean id="hibernateTemplate"
class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>


<bean id="userDao"
class="com.ssh..impl.UserDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>


<bean id="userService"
class="com.ssh.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>


<bean id="UserAction"
class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>

<bean id="User" class="com.ssh.pojo.User" scope="prototype"/>
</beans>

⑸ springboot自定义配置文件数量是变化的，属性相同，只是值不一样，怎样绑定到实体类

有一个思路，在主要的配置文件(比如：application.yml、bootstrap.yml)中设置好需要动态加载的配置文件。然后在启动时通过读取此配置自动去加载动态的配置文件，从而生成你需要的实体类。

大致效果，仅供参考，有更好的方案，欢迎指出：

配置文件

完整代码：
@Component
public class LoadDynamicConfigure {
@Value("${resourcesPath}")
private String resourcesPath;

@Bean
public void loadConfig() {
String[] yamlPathArray = resourcesPath.split(",");
for (String path : yamlPathArray) {
YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
//yaml.setResources(new FileSystemResource("classpath:config/user.yml"));//File路径引入
yaml.setResources(new ClassPathResource(path));//class路径引入
//转换成实体类
ConfigBean bean = (ConfigBean) JSONObject.toBean(JSONObject.fromObject(yaml.getObject()), ConfigBean.class);
//打印，查看效果
System.out.println("测试读取配置---->" + path + " --> " + JSONObject.fromObject(bean).toString());
}
}
}

导航:首页 > 文件教程 > spring自定义配置文件

spring自定义配置文件

与spring自定义配置文件相关的资料

友情链接