SpringBoot配置文件

核心配置文件

Spring-Boot 核心配置文件的默认位置是在classpath 根目录或classpath/config目录下，文件名为 application.properties或application.yml ，如果两个文件同时存在，则都会被加载。
其中，application.properties采用键值对 [ property-name= property-vale] 格式进行配置，如下所示。

server.port=9080

application.yml采用缩进格式（勿使用 Tab 键缩进）进行配置，如下所示。

server:
  port: 9080

如果你不想使用 Spring-Boot 默认的核心配置文件，可以通过修改启动参数来进行指定，有以下两种情况：
1.新配置文件在classpath 根目录或classpath/config目录下，通过在程序启动参数Program arguments中添加 --spring.config.name=[新配置文件名] 进行指定，只需要指定新配置文件的名称，无需指定扩展名。

--spring.config.name=jdbc <!-- 核心配置文件名可以是 jdbc.properties 或 jdbc.yml ，两者均可 -->

2.新配置文件不在 classpath根目录或classpath/config目录下，通过在程序启动参数Program arguments 中添加 --spring.config.location=[新配置文件全路径] 进行指定，此时的新配置文件可以从classpath 或本地的文件系统中指定，全路径需包含扩展名。

<!-- 从 classpath 中读取配置文件 -->
--spring.config.location=classpath:conf/application.yml
<!-- 从本地文件系统中读取配置文件 -->
--spring.config.location=file:/d:/src/app.properties
<!-- 可以同时指定多个配置文件，多个文件之间使用 “,”进行分隔 -->
--spring.config.location=classpath:conf/application.yml,file:/d:/src/jdbc.properties

如何读取配置

在 Spring-Boot 中读取配置文件非常容易，常用的有以下两种方式：
1.通过@Value注解获取配置
2.通过 Environment对象获取配置
接下来，我们以读取 application.properties 配置文件为例，配置文件的内容如下。

server.ip=192.168.80.47
server.port=9080
server.name=pengjunlee
# Use ${property-name} As Placeholder
server.welcome=Hello ${server.name}
#server.password=

读取配置的示例代码如下。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class PropertyTestOne {

	@Autowired
	private Environment env;
	
	// 读取字符串
	@Value("${server.ip}")
	private String ip;
	
	// 读取整型
	@Value("${server.port}")
	private Integer port;
	
	@Value("${server.name}")
	private String name;
	
	@Value("${server.welcome}")
	private String welcome;
	
	// 属性不存在时(不包括值为空)，设置默认值
	@Value("${server.password:123456}")
	private String password;

	public void show() {

		System.out.println("----------通过 @Value 注解获取配置------------");
		System.out.println("server.ip= "+ip);
		System.out.println("server.port= "+port);
		System.out.println("server.name= "+name);
		System.out.println("server.welcome= "+welcome);
		System.out.println("server.password= "+password);
		System.out.println("----------通过 Environment 对象获取配置------------");
		System.out.println("server.ip= "+env.getProperty("server.ip"));
		System.out.println("server.port= "+env.getProperty("server.port", Integer.class));
		System.out.println("server.name= "+env.getProperty("server.name"));
		System.out.println("server.welcome= "+env.getProperty("server.welcome"));
		System.out.println("server.password= "+env.getProperty("server.password","123456"));
		
	}
}

应用启动类代码如下。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MyApplication {

	public static void main(String[] args) {
		
		ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
		// 通过 context.getEnvironment().getProperty() 获取配置
		System.out.println(context.getEnvironment().getProperty("server.ip"));
		context.getBean(PropertyTestOne.class).show();
		context.close();
	}
}

启动程序，打印结果如下：

192.168.80.47
----------通过 @Value 注解获取配置------------
server.ip= 192.168.80.47
server.port= 9080
server.name= pengjunlee
server.welcome= Hello pengjunlee
server.password= 123456
----------通过 Environment 对象获取配置------------
server.ip= 192.168.80.47
server.port= 9080
server.name= pengjunlee
server.welcome= Hello pengjunlee
server.password= 123456

提示：除了通过以上两种方式为配置赋默认值以外，还可以通过 SpringApplication.setDefaultProperties() 方法为配置赋默认值。

	SpringApplication springApplication = new SpringApplication(MyApplication.class);
	Map<String, Object> map = new HashMap<String, Object>();
	springApplication.setDefaultProperties(map);

加载指定配置文件

除了可以使用Spring-Boot  的核心配置文件之外，我们还可以利用@PropertySource 和@PropertySources两个注解实现让程序加载classpath和本地文件系统中任意指定的一个或者多个配置文件。

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;

@Configuration
//@PropertySource("classpath:email/email.properties")
//@PropertySource("file:/d:/src/jdbc.properties")
@PropertySources({@PropertySource("classpath:email/email.properties"),@PropertySource("file:/d:/src/jdbc.properties")})
public class PropertyFileConfig {

}

另外，我们也可以利用 @ConfigurationProperties注解从指定的配置文件中获取带有指定前缀的配置并赋值给JavaBean 对象中同名的属性，若未指定配置文件位置，则会从已经加载的所有配置文件中查找并获取配置。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix="jdbc",locations="classpath:mysql/jdbc.properties")
public class JdbcProperties {

	private String driver;
	
	private String url;
	
	private String username;
	
	private String password;
	
	//private List<String> hosts=new ArrayList<String>();
	
	private String[] hosts;
	
	public void show(){
		System.out.println("jdbc.driver= "+driver);
		System.out.println("jdbc.url= "+url);
		System.out.println("jdbc.username= "+username);
		System.out.println("jdbc.password= "+password);
		System.out.println("jdbc.host="+Arrays.asList(hosts));
	}

	public String getDriver() {
		return driver;
	}

	public void setDriver(String driver) {
		this.driver = driver;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String[] getHosts() {
		return hosts;
	}

	public void setHosts(String[] hosts) {
		this.hosts = hosts;
	}

	/*public List<String> getHosts() {
		return hosts;
	}

	public void setHosts(List<String> hosts) {
		this.hosts = hosts;
	}*/
	
	
}

注意：使用此种方式获取配置，需要在 JavaBean 中为配置相应的属性生成 get() 和 set() 方法。

动态加载配置

在很多情况下，我们经常会需要为不同的环境启用不同的配置文件，例如：开发环境下就使用 application-dev.properties 中的配置；测试环境下就使用application-test.properties 中的配置；生产环境下就使用application-prod.properties 中的配置，在 Spring-Boot中实现这一功能需要借助Profile 机制来完成。
在 Spring-Boot 中使用 Profile 来动态地加载配置文件，有以下几种实现途径：
1. 在程序启动类中，调用 SpringApplication.setAdditionalProfiles() 方法激活指定的 Profile。

		SpringApplication application=new SpringApplication(MyApplication.class);
		// 指定需要激活的 profile
		application.setAdditionalProfiles("default","test");
		ConfigurableApplicationContext context = application.run(args);

2. 在程序启动参数 Program arguments 中添加 --spring.profiles.active=[profile1,profile2...profileN ] 激活指定的Profile。

--spring.profiles.active=default,test

3. 在核心配置文件 application.properties 中添加 spring.profiles.active=[ profile1,profile2...profileN]激活指定的Profile。

spring.profiles.active=default,test

在 Profile 的帮助下，我们还可以利用@Profile()注解来实现容器中Bean 的动态创建，只在相应的Profile 被激活时才创建Bean。

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;

@SpringBootConfiguration
@Profile("test")
public class ProfileConfig {

	@Bean
	//@Profile("test")
	public Runnable createRunnable1(){
		System.out.println("--------test------");
		return ()->{};
	}
	
}

配置扩展接口

为了能够更好的对配置文件进行扩展，Spring-Boot还额外提供了一个EnvironmentPostProcessor接口，其内部只包含一个postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app)方法，通过实现该接口，我们可以在方法中实现很多丰富的功能，例如：根据条件加载本地或远程的配置文件、对已加载的属性进行管理，等等。
以使用该接口加载一个本地的 local.properties 配置文件为例，需要以下两个步骤：
1. 编写接口的实现类。

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Properties;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.stereotype.Component;

@Component
public class MyEnvironmentPostProcessor implements EnvironmentPostProcessor {

	@Override
	public void postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app) {
		try{
			InputStream in=new FileInputStream("d:/src/local.properties");
			Properties properties=new Properties();
			properties.load(in);
			
			PropertiesPropertySource pps=new PropertiesPropertySource("local",properties);
			env.getPropertySources().addLast(pps);
		}
		catch(Exception e)
		{
			
		}
	}

}

2. 将编写好的接口实现类注册到 classpath/META-INF 目录下的 spring.factories文件中。

org.springframework.boot.env.EnvironmentPostProcessor=com.pengjunlee.MyEnvironmentPostProcessor

本文项目源码已上传至CSDN，资源地址：https://download.csdn.net/download/pengjunlee/10301077