Spring Boot 配置優先級順序

時間  2019-11-07
標籤 spring boot 配置 優先級 順序 欄目 Spring 简体版
原文   原文鏈接

通常在一個項目中，老是會有好多個環境。好比：javascript

開發環境 -> 測試環境 -> 預發佈環境【驗證環境】 -> 生產環境html

每一個環境上的配置文件老是不同的，甚至開發環境中每一個開發者的環境可能也會有一點不一樣，配置讀取但是一個讓人有點傷腦筋的問題。java

Spring Boot提供了一種優先級配置讀取的機制來幫助咱們從這種困境中走出來。mysql

常規狀況下，咱們都知道Spring Boot的配置會從application.properties中讀取。實際上，從resource目錄下的application.properties文件讀取是Spring Boot配置鏈中的一環而已。linux

外部化的配置

在應用中管理配置並非一個容易的任務，尤爲是在應用須要部署到多個環境中時。一般會須要爲每一個環境提供一個對應的屬性文件，用來配置各自的數據庫鏈接信息、服務器信息和第三方服務帳號等。一般的應用部署會包含開發、測試和生產等若干個環境。不一樣的環境之間的配置存在覆蓋關係。測試環境中的配置會覆蓋開發環境，而生產環境中的配置會覆蓋測試環境。Spring 框架自己提供了多種的方式來管理配置屬性文件。
Spring 3.1 以前可使用 PropertyPlaceholderConfigurer【繼承PropertyPlaceholderConfigurer讀取配置文件，相關示例代碼見下】。
Spring 3.1 引入了新的環境（Environment）和概要信息（Profile）API，是一種更加靈活的處理不一樣環境和配置文件的方式。不過 Spring 這些配置管理方式的問題在於選擇太多，讓開發人員無所適從。Spring Boot 提供了一種統一的方式來管理應用的配置，容許開發人員使用屬性文件、YAML 文件、環境變量和命令行參數來定義優先級不一樣的配置值。web

Spring Boot 所提供的配置優先級順序比較複雜。按照優先級從高到低的順序，具體的列表以下所示。spring

  1. 命令行參數。
  2. 經過 System.getProperties() 獲取的 Java 系統參數。
  3. 操做系統環境變量。
  4. 從 java:comp/env 獲得的 JNDI 屬性。
  5. 經過 RandomValuePropertySource 生成的「random.*」屬性。
  6. 應用 Jar 文件之外的屬性文件。(經過spring.config.location參數)
  7. 應用 Jar 文件內部的屬性文件。
  8. 在應用配置 Java 類（包含「@Configuration」註解的 Java 類）中經過「@PropertySource」註解聲明的屬性文件。
  9. 經過「SpringApplication.setDefaultProperties」聲明的默認屬性。

Spring Boot 的這個配置優先級看似複雜，實際上是很合理的。好比命令行參數的優先級被設置爲最高。
這樣的好處是能夠在測試或生產環境中快速地修改配置參數值，而不須要從新打包和部署應用。sql

SpringApplication 類默認會把以「--」開頭的命令行參數轉化成應用中可使用的配置參數，如 「--name=Alex」 會設置配置參數 「name」 的值爲 「Alex」。若是不須要這個功能，能夠經過 「SpringApplication.setAddCommandLineProperties(false)」 禁用解析命令行參數。數據庫

RandomValuePropertySource 能夠用來生成測試所須要的各類不一樣類型的隨機值，從而免去了在代碼中生成的麻煩。RandomValuePropertySource 能夠生成數字和字符串。數字的類型包含 int 和 long，能夠限定數字的大小範圍。以「random.」做爲前綴的配置屬性名稱由 RandomValuePropertySource 來生成，如代碼清單 3 所示。tomcat

清單 3. 使用 RandomValuePropertySource 生成的配置屬性
user.id=${random.value}
user.count=${random.int}
user.max=${random.long}
user.number=${random.int(100)}
user.range=${random.int[100, 1000]}

屬性文件

屬性文件是最多見的管理配置屬性的方式。Spring Boot 提供的 SpringApplication 類會搜索並加載 application.properties 文件來獲取配置屬性值。SpringApplication 類會在下面位置搜索該文件。

  • 當前目錄的「/config」子目錄。
  • 當前目錄。
  • classpath 中的「/config」包。
  • classpath

上面的順序也表示了該位置上包含的屬性文件的優先級。優先級按照從高到低的順序排列。能夠經過「spring.config.name」配置屬性來指定不一樣的屬性文件名稱。也能夠經過「spring.config.location」來添加額外的屬性文件的搜索路徑。若是應用中包含多個 profile，能夠爲每一個 profile 定義各自的屬性文件，按照「application-{profile}」來命名。

對於配置屬性，能夠在代碼中經過「@Value」來使用，如代碼清單 4 所示。

清單 4. 經過「@Value」來使用配置屬性
@RestController
@EnableAutoConfiguration
public class Application {
 @Value("${name}")
 private String name;
 @RequestMapping("/")
 String home() {
 return String.format("Hello %s!", name);
 }
}

在代碼清單 4 中，變量 name 的值來自配置屬性中的「name」屬性。

YAML

相對於屬性文件來講，YAML 是一個更好的配置文件格式。YAML 在 Ruby on Rails 中獲得了很好的應用。SpringApplication 類也提供了對 YAML 配置文件的支持，只須要添加對 SnakeYAML 的依賴便可。代碼清單 5 給出了 application.yml 文件的示例。

清單 5. 使用 YAML 表示的配置屬性
spring:
 profiles: development
db:
 url: jdbc:hsqldb:file:testdb
 username: sa
 password:
---
spring:
 profiles: test
db:
 url: jdbc:mysql://localhost/test
 username: test
 password: test

代碼清單 5 中的 YAML 文件同時給出了 development 和 test 兩個不一樣的 profile 的配置信息，這也是 YAML 文件相對於屬性文件的優點之一。
除了使用「@Value」註解綁定配置屬性值以外，還可使用更加靈活的方式。
代碼清單 6 給出的是使用代碼清單 5 中的 YAML 文件的 Java 類。
經過「@ConfigurationProperties(prefix="db")」註解，配置屬性中以「db」爲前綴的屬性值會被自動綁定到 Java 類中同名的域上，如 url 域的值會對應屬性「db.url」的值。
只須要在應用的配置類中添加「@EnableConfigurationProperties」註解就能夠啓用該自動綁定功能。

清單 6. 使用 YAML 文件的 Java 類
@Component
@ConfigurationProperties(prefix="db")
public class DBSettings {
 private String url;
 private String username;
 private String password;
}

http://www.ibm.com/developerworks/cn/java/j-lo-spring-boot/index.html

 

 

這意味着，若是Spring Boot在優先級更高的位置找到了配置，那麼它就會無視優先級低的配置。

好比，我在application.properties目錄中，寫入本地的MySQL的配置：

db.jdbc.driver=com.mysql.jdbc.Driver
db.jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8
db.jdbc.username=username
db.jdbc.password=password

在本身項目調試的階段，項目老是會使用本地的MySQL數據庫。而一旦打包以後，在外部聲明一個test_evn.properties.

啓動Jar包的時候, 指定一個外部配置文件：

java -jar demo.jar --spring.config.location=/path/test_evn.properties

這樣一來，咱們在開發者的機器上老是使用本身的配置，而一到對應的環境，就會使用高級的位置所作的配置。

在代碼中讀取這些配置也是很是方便的，在代碼的邏輯中，實際上是無需去關心這個配置是從什麼地方來的，只用關注能獲取什麼配置就夠了。

public class ApplicationConfigure {

    @Value("${db.jdbc.driver}")
    private String jdbcDriver;
    @Value("${db.jdbc.url}")
    private String jdbcUrl;
    @Value("${db.jdbc.username}")
    private String jdbcUsername;
    @Value("${db.jdbc.password}")
    private String jdbcPassword;
    
    // mysql config class
    // ..... 
    
}

 

有時候咱們在項目啓動的時候，老是須要先啓動一些初始化的類，之前比較常見的作法是寫再static塊中，Spring Boot提供了一個CommandLineRunner接口，實現這個接口的類老是會被優先啓動，並優先執行CommandLineRunner接口中提供的run()方法。

public class ApplicationConfigure implements CommandLineRunner  {

    @Value("${db.jdbc.driver}")
    private String jdbcDriver;
    @Value("${db.jdbc.url}")
    private String jdbcUrl;
    @Value("${db.jdbc.username}")
    private String jdbcUsername;
    @Value("${db.jdbc.password}")
    private String jdbcPassword;
    
    // mysql config class
    // ..... 
    @Override
    public void run(String... strings) throws Exception {
        // 預先加載的一些方法，類，屬性。
    }
}

 

若是有多個CommandLineRunner接口實現類，那麼能夠經過註解@Order來規定全部實現類的運行順序。

經過這一系列API的幫助，Spring Boot讓環境配置變得輕鬆不少。

http://www.cnblogs.com/whthomas/p/5270917.html

http://www.ibm.com/developerworks/cn/java/j-lo-spring-boot/index.html

Tomcat
Tomcat爲Spring Boot的默認容器，下面是幾個經常使用配置：

# tomcat最大線程數，默認爲200
server.tomcat.max-threads=800
# tomcat的URI編碼
server.tomcat.uri-encoding=UTF-8
# 存放Tomcat的日誌、Dump等文件的臨時文件夾，默認爲系統的tmp文件夾（如：C:\Users\Shanhy\AppData\Local\Temp）
server.tomcat.basedir=H:/springboot-tomcat-tmp
# 打開Tomcat的Access日誌，並能夠設置日誌格式的方法：
#server.tomcat.access-log-enabled=true
#server.tomcat.access-log-pattern=
# accesslog目錄，默認在basedir/logs
#server.tomcat.accesslog.directory=
# 日誌文件目錄
logging.path=H:/springboot-tomcat-tmp
# 日誌文件名稱，默認爲spring.log
logging.file=myapp.log

Jetty 

若是你要選擇Jetty，也很是簡單，就是把pom中的tomcat依賴排除，並加入Jetty容器的依賴，以下：

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
      <exclusion>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
  </dependency>
<dependencies>

打包 

打包方法：
CMD進入項目目錄，使用 mvn clean package 命令打包，以個人項目工程爲例：

E:\spring-boot-sample>mvn clean package

能夠追加參數 -Dmaven.test.skip=true (-DskipTests)跳過測試。 

打包後的文件存放於項目下的target目錄中，如：spring-boot-sample-0.0.1-SNAPSHOT.jar
若是pom配置的是war包，則爲spring-boot-sample-0.0.1-SNAPSHOT.war

2、部署到JavaEE容器

  1. 修改啓動類，繼承 SpringBootServletInitializer 並重寫 configure 方法 
    public class SpringBootSampleApplication extends SpringBootServletInitializer{

    private static final Logger logger = LoggerFactory.getLogger(SpringBootSampleApplication.class);

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(this.getClass());
    }

}
  1. 修改pom文件中jar 爲 war
<!-- <packaging>jar</packaging> -->
<packaging>war</packaging>
  1. 修改pom，排除tomcat插件

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

<exclusions>

<exclusion>

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

<artifactId>spring-boot-starter-tomcat</artifactId>

</exclusion>

</exclusions>

</dependency>

  1. 打包部署到容器
    使用命令 mvn clean package 打包後，同通常J2EE項目同樣部署到web容器。

3、使用Profile區分環境

spring boot 能夠在 「配置文件」、「Java代碼類」、「日誌配置」 中來配置profile區分不一樣環境執行不一樣的結果

一、配置文件
使用配置文件application.yml 和 application.properties 有所區別
以application.properties 爲例，經過文件名來區分環境 application-{profile}.properties
application.properties

app.name=MyApp
server.port=8080
spring.profiles.active=dev

application-dev.properties

server.port=8081

application-stg.properties

server.port=8082

在啓動程序的時候經過添加 –spring.profiles.active={profile} 來指定具體使用的配置 

例如咱們執行 java -jar demo.jar –spring.profiles.active=dev 那麼上面3個文件中的內容將被如何應用？
Spring Boot 會先加載默認的配置文件，而後使用具體指定的profile中的配置去覆蓋默認配置。

app.name 只存在於默認配置文件 application.properties 中，由於指定環境中不存在一樣的配置，因此該值不會被覆蓋 
server.port 默認爲8080，可是咱們指定了環境後，將會被覆蓋。若是指定stg環境，server.port 則爲 8082 
spring.profiles.active 默認指定dev環境，若是咱們在運行時指定 –spring.profiles.active=stg 那麼將應用stg環境，最終 server.port 的值爲8082

二、Java類中@Profile註解
下面2個不一樣的類實現了同一個接口，@Profile註解指定了具體環境

// 接口定義
public interface SendMessage {

    // 發送短信方法定義
    public void send();

}
 

 
 
// Dev 環境實現類
@Component
@Profile("dev")
public class DevSendMessage implements SendMessage {

    @Override
    public void send() {
        System.out.println(">>>>>>>>Dev Send()<<<<<<<<");
    }

}
 

 

 
 

 
 
// Stg環境實現類
@Component
@Profile("stg")
public class StgSendMessage implements SendMessage {

    @Override
    public void send() {
        System.out.println(">>>>>>>>Stg Send()<<<<<<<<");
    }

}
 

 

 
 
// 啓動類
@SpringBootApplication
public class ProfiledemoApplication {

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

    @Autowired
    private SendMessage sendMessage;

    @PostConstruct
    public void init(){
        sendMessage.send();// 會根據profile指定的環境實例化對應的類
    }

}
 

 

三、logback-spring.xml也支持有節點來支持區分
 

 
 
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml" />
    <logger name="org.springframework.web" level="INFO"/>

    <springProfile name="default">
        <logger name="org.springboot.sample" level="TRACE" />
    </springProfile>

    <springProfile name="dev">
        <logger name="org.springboot.sample" level="DEBUG" />
    </springProfile>

    <springProfile name="staging">
        <logger name="org.springboot.sample" level="INFO" />
    </springProfile>

</configuration>
 

 

再說一遍文件名不要用logback.xml 請使用logback-spring.xml
 

4、指定外部的配置文件
 

有些系統，關於一些數據庫或其餘第三方帳戶等信息，因爲安全問題，其配置並不會提早配置在項目中暴露給開發人員。 
對於這種狀況，咱們在運行程序的時候，能夠經過參數指定一個外部配置文件。 
以 demo.jar 爲例，方法以下：
 

 
 
java -jar demo.jar --spring.config.location=/opt/config/application.properties
 

 

其中文件名隨便定義，無固定要求。
 

5、建立一個Linux 應用的sh腳本
 

下面幾個腳本僅供參考，請根據本身須要作調整 
start.sh
 

 
 
#!/bin/sh

rm -f tpid

nohup java -jar /data/app/myapp.jar --spring.profiles.active=stg > /dev/null 2>&1 &

echo $! > tpid
 

 

 
 

stop.sh
 

 
 
tpid=`cat tpid | awk '{print $1}'`

tpid=`ps -aef | grep $tpid | awk '{print $2}' |grep $tpid`
if [ ${tpid} ]; then
   kill -9 $tpid
fi
 

 

check.sh
 

 
 
tpid=`cat tpid | awk '{print $1}'`
tpid=`ps -aef | grep $tpid | awk '{print $2}' |grep $tpid`
if [ ${tpid} ]; then
    echo App is running.
else
    echo App is NOT running.
fi
 

 

kill.sh
 

 
 
#!/bin/sh
# kill -9 `ps -ef|grep 項目名稱|awk '{print $2}'`
kill -9 `ps -ef|grep demo|awk '{print $2}'`
 

 


 
 

繼承PropertyPlaceholderConfigurer.從spring容器獲取取配置文件屬性
 

 
 
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
 
 
public class CustomPropertyConfig extends  PropertyPlaceholderConfigurer{
    
    private static Map<String, Object> ctxPropertiesMap;
    
    @Override  
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,Properties props) throws BeansException {  
        super.processProperties(beanFactoryToProcess, props);  
        ctxPropertiesMap = new HashMap<String, Object>();  
        for (Object key : props.keySet()) {
            String keyStr = key.toString();
            String value = props.getProperty(keyStr);
            ctxPropertiesMap.put(keyStr, value);
        }
    }
  
    public static Object getContextProperty(String name) {
        return ctxPropertiesMap.get(name);
    }
}
 

 

 
 

 
 
<bean id="propertyConfigurer"  
        class="com.test.utils.CustomPropertyConfig">  
        <property name="locations">
            <list>
                <!-- org.springframework.beans.factory.config.PropertyPlaceholderConfigurer這裏支持多種尋址方式：classpath和file -->
                <!-- 推薦使用file的方式引入，這樣能夠將配置和代碼分離 -->
<!--                 <value>classpath:jdbc.properties</value> -->
                <value>classpath:dbconfig.properties</value>
            </list>
        </property>  
    </bean>
 

 

https://blog.csdn.net/y_index/article/details/79893765
 


實現BeanFactoryAware來達到Spring靜態方法獲取Bean對象的BeanUtil工具類
 

在spring裏自己是沒有提供這類方法的。
 

因此咱們只能經過重寫一些類來達到咱們想要的效果
在容器初始化時注入Bean工廠，並提供一些列靜態方法，用於運行期間任何地方均可以用過他來獲許對應Bean
 

 
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class BeanUtil implements  BeanFactoryAware{
     private static BeanFactory beanFactory;  
        // private static ApplicationContext context;  
      
     @Override
        public void setBeanFactory(BeanFactory factory) throws BeansException {  
            this.beanFactory = factory;  
        }  
      
        /** 
         * 根據beanName名字取得bean 
         *  
         * @param beanName 
         * @return 
         */  
        public static <T> T getBean(String beanName) {  
            if (null != beanFactory) {  
                return (T) beanFactory.getBean(beanName);  
            }  
            return null;  
        }  
      
}
 

 

https://www.hellojava.com/a/27.html


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程