springboot配置详解

springboot如何从配置文件中读取配置。

springboot默认的全局配置文件在application.properties或application.yml（推荐使用）。此文件默认可以放在classpath路径，或者放在classpath:/config，springboot应用都是默认读取到的。

加入依赖：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
</dependencies>

一个小入门demo：

在application.properties中定义了一属性

local.ip=192.168.1.111

启动类

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        System.out.println(context.getEnvironment().getProperty("local.ip"));
        context.close();
    }
}

运行程序：

192.168.1.111

我们发现 context.getEnvironment()源码：

/**
   * Return the {@code Environment} for this application context in configurable 
   * form, allowing for further customization.
   * @since 3.1
   */
@Override
ConfigurableEnvironment getEnvironment();

而 ConfigurableEnvironment一定是继承Environment，关于 ConfigurableEnvironment和 Environment我们不过多解释。

使用 Environment类或者@ Value 注解获取配置

定义一个 UserConfig，并纳入spring容器中管理

@Component
public class UserConfig {

    @Autowired
    private Environment environment;

    @Value("${local.name}")
    private String localName;

    @Value("${local.port}")
    private int port;

    public void show(){
        System.out.println(environment.getProperty("local.ip"));
        //重载方法，使得读取到的数据是Integer类型的
        System.out.println(environment.getProperty("local.port",Integer.class));
        System.out.println(localName);
        System.out.println(port);

        //在配置文件中引用引用已有的变量
        System.out.println(environment.getProperty("local.url"));
    }
}

配置文件：

local.ip=192.168.1.111
local.name=zhihao.miao
local.port=9090

local.url=http://${local.ip}:${local.port}

启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        UserConfig userConfig = context.getBean(UserConfig.class);
        userConfig.show();
        context.close();
    }
}

打印结果：

192.168.1.111
9090
zhihao.miao
9090
http://192.168.1.111:9090

给属性增加默认值
定义一个普通的类 UserConfig2，纳入到spring容器中管理

@Component
public class UserConfig2 {

    @Value("${tomcat.port:10000}")
    private int port;

    @Autowired
    private Environment environment;

    public void show(){
        System.out.println(port);
        System.out.println(environment.getProperty("tomcat.port",Integer.class,10000));
    }
}

启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        UserConfig2 userConfig = context.getBean(UserConfig2.class);
        userConfig.show();
        context.close();
    }
}

打印结果：

10000
10000

如果在配置文件中设置了此属性则会覆盖该属性， application.proterties配置如下:

tomcat.port=10001

则打印结果如下：

10001
10001

还有一种配置默认值，使用

SpringApplication.setDefaultProperties(Map<String, Object> defaultProperties)
SpringApplication.setDefaultProperties(Properties defaultProperties)

二个方法，也可以设置:

package com.zhihao.miao;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@SpringBootApplication
public class Application {

    @Value("${server.host:localhost}")
    private String serverHost;

    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(Application.class);
        Map<String,Object> defaultProperties = new HashMap<>();
        defaultProperties.put("server.host","192.168.1.111");
        defaultProperties.put("server.ip","8080");
        application.setDefaultProperties(defaultProperties);
//        Properties defaultProperties2 = new Properties();
//        defaultProperties2.put("server.ip","8080");
//        application.setDefaultProperties(defaultProperties2);
        ConfigurableApplicationContext context =application.run(args);
        System.out.println(context.getBean(Application.class).serverHost);
        System.out.println(context.getEnvironment().getProperty("server.host"));
        System.out.println(context.getEnvironment().getProperty("server.ip"));
        context.close();
    }
}

可以覆盖了@Value注解配置的默认值，如果在application.properties中配置

server.host=129.11.1.111
server.ip=9090

那么配置文件配置的属性值就会覆盖上面的默认配置。

总结：
setDefaultProperties设置的优先级最高，如果在配置文件中设置，那么当然就是配置文件中的默认值优先级最高。

使用@ConfigurationProperties注解加载配置文件

在application.properties文件中加入配置：

ds.url=jdbc:mysql:///springboot
ds.driverClassName=com.mysql.jdbc.Driver
ds.username=root
ds.password=123456

定义一个普通的类 DataSourceConfig，并将其纳入到spring容器中管理：

@Component
@ConfigurationProperties(prefix = "ds")
public class DataSourceConfig {

    private String url;

    private String driverClassName;

    private String username;

    private String password;

    public String getUrl() {
        return url;
    }

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

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    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 void show(){
        System.out.println("ds.url===="+url);
        System.out.println("ds.driverClassName==="+driverClassName);
        System.out.println("ds.username====="+username);
        System.out.println("ds.password====="+password);
    }
}

注意：使用 @ConfigurationProperties，那么配置的属性必须要加get**,set **方法。

启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        DataSourceConfig dataSourceConfig = context.getBean(DataSourceConfig.class);
        dataSourceConfig.show();
        context.close();
    }
}

打印结果：

ds.url====jdbc:mysql:///springboot
ds.driverClassName===com.mysql.jdbc.Driver
ds.username=====root
ds.password=====123456

加载外部文件的方式

上面说过，springboot应用默认读取的是classpath下的 application.properties，比如说我在application.properties之外定义了一个user.properties和一个jdbc.properties，需求是应用也要读到这些配置。

user.properties配置如下：

jdbc.username=root
jdbc.password=123456

jdbc.properties配置如下：

jdbc.url=jdbc:mysql://springboot
dricverClassName=com.mysql.jdbc.Driver

定义一个类 FileConfig，使用@PropertySource注解或者 @PropertySources注解

package com.zhihao.miao.bean;

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

@Configuration
//@PropertySource({"classpath:jdbc.properties","classpath:user.properties"})
@PropertySources({@PropertySource("classpath:jdbc.properties"),@PropertySource("classpath:user.properties")})
public class FileConfig {
}

@PropertySource注解和@PropertySources注解的区别，@PropertySources的源码如下，

/**
 * Container annotation that aggregates several {@link PropertySource} annotations.
 *
 * <p>Can be used natively, declaring several nested {@link PropertySource} annotations.
 * Can also be used in conjunction with Java 8's support for <em>repeatable annotations</em>,
 * where {@link PropertySource} can simply be declared several times on the same
 * {@linkplain ElementType#TYPE type}, implicitly generating this container annotation.
 *
 * @author Phillip Webb
 * @since 4.0
 * @see PropertySource
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PropertySources {

    PropertySource[] value();

}

@PropertySources注解容器式注解，将@PropertySource注解复合在一起使用。

配置类：

package com.zhihao.miao.bean;


import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class JdbcConfig {

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

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

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

    @Value("${dricverClassName}")
    private String dricverClassName;

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

}

启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        JdbcConfig jdbcConfig = context.getBean(JdbcConfig.class);
        jdbcConfig.show();
        context.close();
    }
}

打印结果：

username=====root
password=====123456
jdbcUrl=====jdbc:mysql://springboot
dricverClassName===com.mysql.jdbc.Driver

注入集合或数组属性

先在application.properties中定义配置：

ds.hosts[0]=192.168.1.100
ds.hosts[1]=192.168.1.111
ds.hosts[2]=192.168.1.112

ds.ports[0]=8080
ds.ports[1]=8081
ds.ports[2]=8082

然后定义一个普通的类TomcatProperties，并纳入到spring容器中管理

package com.zhihao.miao.bean;

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

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

@Component
@ConfigurationProperties("ds")
public class TomcatProperties {

    private List<String> hosts = new ArrayList<>();

    private String[] ports;

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

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

    public String[] getPorts() {
        return ports;
    }

    public void setPorts(String[] ports) {
        this.ports = ports;
    }

    public void show(){
        System.out.println("host====="+this.hosts);
        System.out.println("ports======"+this.ports[0]+","+this.ports[1]+","+this.ports[2]);
    }
}

注：还是需要get***，set***方法。

启动类

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        TomcatProperties tomcatProperties = context.getBean(TomcatProperties.class);
        tomcatProperties.show();
        context.close();
    }
}

打印结果：

host=====[192.168.1.100, 192.168.1.111, 192.168.1.112]
ports======8080,8081,8082