获取配置文件中的属性

spring boot的工程启动的时候，内部文件默认是加载classpath路径或者classpath:/config目录下的application.properties文件的。当然也可以指定加载其它的配置文件，如何获取配置文件中的属性呢？实例如下：

【1】、获取默认classpath下的application.properties配置文件中的属性

application.properties中的内容为：

local.ip=127.0.0.1

一、获取classpath下的application.properties文件中属性

1、直接通过配置文件的环境变量获取
启动类：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
    /*通过getEnvironment函数默认获取到的文件即为application.properties，然后用getProperty函数从文件中获取键的属性*/
    System.out.println(app.getEnvironment().getProperty("local.ip"));
}

或者创建一个类，用来获取配置属性，例如

package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

/*注意：由于@SpringBootApplication中有一个注解@ComponentScan自动扫描启动类所在的包，而PropertiesConfig正好在启动包下，如果
 * 该类不与启动类在同一包下，需要该类加载到spring boot的启动源中*/
@Component
public class PropertiesConfig {

    @Autowired
    private Environment env;

    public void show(){     
    System.out.println(env.getProperty("local.ip"));
    }
}

启动类中的方法为：

        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
        app.getBean(PropertiesConfig.class).show();

当运行启动类的时候，输出如下：

127.0.0.1

2、用@Value注解来获取
新建一个配置类，专门用来获取application.properties文件中的属性。

package com.example.demo;
import 
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

/*注意：由于@SpringBootApplication中有一个注解@ComponentScan自动扫描启动类所在的包，而PropertiesConfig正好在启动包下，如果
 * 该类不与启动类在同一包下，需要该类加载到spring boot的启动源中*/
@Component
public class PropertiesConfig {

    /*通过@Value注解会默认把application.properties中的local.ip键对应的属性自动赋给localIp属性*/
    @Value("${local.ip}")
    private String localIp;

    public void show(){
        System.out.println("localIp=" + localIp);
    }
}

启动类为：

        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
        app.getBean(PropertiesConfig.class).show();

当运行启动类的时候，输出如下：

127.0.0.1

【2】、获取自定义的properties配置文件属性

当在工程目录下自定义了配置文件，例如在/src/main/resources/下的/fileConfig的目录下创建一个jdbc.properties文件，或者在服务器中非工程目录下D:\tmp创建一个jdbc1.properties配置文件。如果启动spring boot工程的时候，系统默认是没有加载该配置文件的，因此在系统环境中获取不到该配置文件，若想获取到该配置文件中的属性，可以通过下面两种方式进行获取：在启动的参数中指定启动自定义配置文件；在配置类上指定要加载的自定义配置文件。

自定义jdbc.properties配置文件：

jdbc.username=lzj
jdbc.password=123456

自定义jdbc1.properties配置文件：

jdbc.username1=lzj
jdbc.password1=123456
jdbc.url=jdbc:mysql://localhost:3306/databasename

一、在启动spring boot的参数中进行指定
run as -> run configurations -> arguments
在program arguments框中填入下列参数：

--spring.config.location=classpath:/fileConfig/jdbc.properties, file:D:/tmp/jdbc1.properties

如果配置文件直接在classpath或者classpath下的config目录下，例如app.properties，也可以直接如下配置：

--spring.config.name=app

如按上面配置后，spring boot启动的时候会自动加载指定的文件，下面获取自定义文件中的属性就和获取默认classpath下的application.properties配置文件中的属性的方法完全一致，请参考上面获取方式。

二、在配置类上指定要加载的自定义配置文件
1、例如还是要获取classpath下的/fileConfig/jdbc.properties和D:/tmp/jdbc1.properties的自定义配置文件属性，现在不需要在启动的参数中进行指定了，定义一个配置类，在配置类中进行指定加载的自定义配置文件。
配置类ConfigTest ：

package com.example.demo;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;

@Configuration
@PropertySource("classpath:/fileConfig/jdbc.properties")
@PropertySource("file:D:/tmp/jdbc1.properties")
/*或者按如下配置：
@PropertySources({@PropertySource("classpath:/fileConfig/jdbc.properties"), @PropertySource("file:D:/tmp/jdbc.properties")})*/
public class ConfigTest {

}

配置完要加载的配置文件后，下面就是要获取自定义的配置文件中的属性了。
创建获取classpath:/fileConfig/jdbc.properties的bean类JdbcTest：

package com.example.demo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class JdbcTest {

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    public void show(){
        System.out.println("username=" + username);
        System.out.println("password=" + password);
    }
}

创建获取D:/tmp/jdbc1.properties的bean的类JdbcFile ：

package com.example.demo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class JdbcFile {

    @Value("${jdbc.username1}")
    private String username;

    @Value("${jdbc.password1}")
    private String password;

    @Value("${jdbc.url}")
    private String url;

    public void show(){
        System.out.println("username=" + username);
        System.out.println("password=" + password);
        System.out.println("url=" + url);
    }
}

启动类如下：

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
    app.getBean(JdbcTest.class).show();
    app.getBean(JdbcFile.class).show();
    }
}

输出结果为：

username=lzj
password=123456
username=zhangsan
password=654321
url=jdbc:mysql://localhost:3306/databasename

2、上面一种方式通过配置类加载自定义配置文件后，然后通过@value注解从配置类中获取键值。下面一种方式也是先通过配置类加载自定义的配置文件，但是通过@ConfigurationProperties注解自动把配置文件中的键对应的值注入到相应的属性中。例如：
配置类ConfigTest 同上：

package com.example.demo;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;

@Configuration
@PropertySource("classpath:/fileConfig/jdbc.properties")
@PropertySource("file:D:/tmp/jdbc1.properties")
/*或者按如下配置：
@PropertySources({@PropertySource("classpath:/fileConfig/jdbc.properties"), @PropertySource("file:D:/tmp/jdbc.properties")})*/
public class ConfigTest {

}

下面创建一个类SourceProperties，用来获取自定义配置文件中的键值，类中的属性一定要和自定义配置文件中的键的名字保持一致，否则不能把配置文件中键对应的值注入到类对象的属性中。在上面的配置类中加载了classpath:/fileConfig/jdbc.properties和file:D:/tmp/jdbc1.properties两个自定义的配置文件，在SourceProperties类中只需要定义两个配置文件中包含的键为类对象的属性，然后通过set方法把配置文件中键对应的值注入到类对象的属性中就可以了。

package com.example.demo;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
/*prefix可以指定配置文件中键的前缀。例如配置文件中有一个键为jdbc.username，配置了prefix="jdbc"后，在下面的属性中只需要定义username就可以了。在值注入的时候，就会自动把配置文件中的jdbc.username对应的值自动注入到username属性中*/
@ConfigurationProperties(prefix="jdbc")
public class SourceProperties {

    /*username对应jdbc.properties文件中的jdbc.username键*/
    private String username;
    /*username1对应jdbc1.properties文件中的jdbc.username1键*/
    private String username1;
    /*password对应jdbc.properties文件中的jdbc.password键*/
    private String password;
    /*password1对应jdbc1.properties文件中的jdbc.password1键*/
    private String password1;
    /*url对应jdbc1.properties文件中的jdbc.url键*/
    private String url;

    /*一定要给需要注入的属性设置get方法，否则值注入不进来*/
    public void setUsername(String username) {
        this.username = username;
    }

    public void setUsername1(String username1) {
        this.username1 = username1;
    }

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

    public void setPassword1(String password1) {
        this.password1 = password1;
    }

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

    public void show(){
        System.out.println("---username=" + username);
        System.out.println("---username1=" + username1);
        System.out.println("---password=" + password);
        System.out.println("---password=" + password1);
        System.out.println("---url=" + url);
    }

}

启动类为：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
    app.getBean(SourceProperties.class).show();
    }
}

运行启动类，输出结果为：

---username=lzj
---username1=zhangsan
---password=123456
---password=654321
---url=jdbc:mysql://localhost:3306/databasename

可见完全取到了自定义配置文件中的键值。

【3】、另外，配置文件中还可以定义变量，可以为配置文件中没有定义的键赋一个默认的值

1、在配置文件中定义变量
下面以spring boot默认加载的application.properties为例，在该配置文件中配置如下，先定义了一个name的键值对，然后又定义了一个local.name的键值对，但local.name中的键值对引用了name的键值对。

name=lzj
local.name=hello ${name}

启动类为：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
    System.out.println(app.getEnvironment().getProperty("name"));
        System.out.println(app.getEnvironment().getProperty("local.name"));
    }
}

运行启动类，输出结果为：

lzj
hello lzj

可见，获得了配置文件中键对应的值。

2、为配置文件中没有定义的键默认赋一个值。
还是以spring boot默认加载的application.properties为例，其配置内容为：

local.ip=127.0.0.1

配置文件中只配置了local.ip，没有配置local.port，下面我们从配置文件中获取local.port，如果不存在的话，就默认赋一个值。创建一个PropertiesConfig 类，用来获取键值。

package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

/*注意：由于@SpringBootApplication中有一个注解@ComponentScan自动扫描启动类所在的包，而PropertiesConfig正好在启动包下，如果
 * 该类不与启动类在同一包下，需要该类加载到spring boot的启动源中*/
@Component
public class PropertiesConfig {

    /*从配置文件取local.port对应的值，如果不存在，就默认赋一个8888的值。*/
    @Value("${local.port:8888}")
    private Integer localPort;

    public void show(){
    System.out.println("local.port=" + localPort);
    }
}

启动类为：

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ConfigurableApplicationContext app = SpringApplication.run(App.class, args);
        app.getBean(PropertiesConfig.class).show();
    }
}

运行启动类，输出：

local.port=8888