曹工談Spring Boot：Spring boot中怎麼進行外部化配置，一不留神摔一跤；一路debug，原來是我太年輕了

時間  2020-05-21
標籤 spring boot 怎麼 進行 外部 配置 不留神 一路 debug 原來 年輕 欄目 Spring 简体版
原文   原文鏈接

spring boot中怎麼進行外部化配置，一不留神摔一跤；一路debug，原來是我太年輕了

背景

咱們公司這邊，目前都是spring boot項目，沒有引入spring cloud config，也就是說，配置文件，仍是放在resources下面的，爲了區分多環境，是採用了profile這種方式，大體以下：html

上面這裏，就定義了3個profile，實際還不止這點，對應了3個環境。java

每次啓動的時候，只須要（省略無關 jvm 參數）：web

java -Dspring.profiles.active=dev -jar xxx.jar

這樣來指定要使用的profile便可。redis

而後每次發測試版本，咱們這邊就得加1個profile，因此致使咱們工做量也是巨大，由於咱們這邊環境比較多，地址總變。後來，通過開發和測試那邊的協調，變成了咱們只管jar包，無論測試環境的維護。每次發版本，只發個jar包過去，配置文件裏的地址，由測試同窗本身配置。spring

大體變成了以下的樣子：shell

-rw-r--r--. 1 root root 111978406 May 19 13:24 xxx.jar
drwxr-xr-x. 2 root root       120 May 20 13:25 config

[root@localhost cad]# ll config/
total 16
-rw-r--r--. 1 root root  498 May 20 13:31 application.properties
-rw-r--r--. 1 root root  601 May 20 13:31 application.yml

即，在jar包旁邊，放上一個config目錄，而後在config目錄裏，放咱們的配置文件，至於配置文件裏的各類配置，好比數據庫ip、redis等等，就由測試同窗本身配置了，這樣呢，咱們的工做量，大大減少。數據庫

看起來很棒了，然而，前一陣，測試同窗發現一個問題，即，只能在和config同級目錄下，執行java -jar，這種狀況下，config裏面的配置才生效，換個目錄執行，config裏面的配置就不生效了。centos

[root@localhost cad]# ll   // 這裏啓動jar包，ok，沒問題；換個目錄執行，不行！
total 109356
-rw-r--r--. 1 root root 111978406 May 19 13:24 xxx.jar
drwxr-xr-x. 2 root root       120 May 20 13:25 config

還有這種事？咱們看看到底怎麼回事。緩存

官方文檔

參考：https://docs.spring.io/spring-boot/docs/2.1.14.RELEASE/reference/html/boot-features-external-config.htmlspringboot

24.3 Application Property Files

SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:

  1. A /config subdirectory of the current directory
  2. The current directory
  3. A classpath /config package
  4. The classpath root

這裏說，SpringApplication加載application.properties配置文件,從以下位置：

  1. 當前目錄的config子目錄下
  2. 當前目錄
  3. classpath下的config包
  4. classpath的根路徑

咱們這裏，就是利用了第一點。可是，這個當前目錄下的config目錄，不是很清楚。當前目錄，怎麼纔算當前目錄，我在jar包同級目錄算當前目錄；換個目錄用絕對路徑，啓動jar包，就不算當前目錄了嗎？

再往下翻一下看看。

Config locations are searched in reverse order. By default, the configured locations are classpath:/,classpath:/config/,file:./,file:./config/. The resulting search order is the following:

  1. file:./config/
  2. file:./
  3. classpath:/config/
  4. classpath:/

配置地址被以相反的順序搜索，默認狀況下，地址包括了：classpath:/,classpath:/config/,file:./,file:./config/，所以，被搜索的順序以下：

  1. file:./config/
  2. file:./
  3. classpath:/config/
  4. classpath:/

這裏的第一項，file: ./config，應該就是咱們目前的那種狀況。

而後文檔裏，沒提到個人問題，多是過低級。。只能從源碼找答案了。

源碼分析

經過關鍵字查找，大體定位源碼

咱們直接用前面的關鍵字，搜索一波（記得把maven裏設置爲下載源碼）

果真看到了一處地方：

org.springframework.boot.context.config.ConfigFileApplicationListener#DEFAULT_SEARCH_LOCATIONS

private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";

查找這個變量被引用的地方：

org.springframework.boot.context.config.ConfigFileApplicationListener.Loader#getSearchLocations()		
	private Set<String> getSearchLocations() {
			if (this.environment.containsProperty(CONFIG_LOCATION_PROPERTY)) {
				return getSearchLocations(CONFIG_LOCATION_PROPERTY);
			}
			Set<String> locations = getSearchLocations(CONFIG_ADDITIONAL_LOCATION_PROPERTY);
  			// 1
			locations.addAll(
					asResolvedSet(ConfigFileApplicationListener.this.searchLocations, DEFAULT_SEARCH_LOCATIONS));
			return locations;
		}

這裏1處，就用到了前面的DEFAULT_SEARCH_LOCATIONS。

接着看看，上面這個函數被調用的地方：

private void load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
          	// 1
			getSearchLocations().forEach((location) -> {
				boolean isFolder = location.endsWith("/");
				Set<String> names = isFolder ? getSearchNames() : NO_SEARCH_NAMES;
                // 2
				names.forEach((name) -> load(location, name, profile, filterFactory, consumer));
			});
		}

這裏的1處，就是前面的獲取config location；這裏1處，獲取到了集合後，對其進行foreach處理。

2處，這裏即會調用一個load函數，看名字就是加載，差很少能夠猜到，是加載咱們的那幾個目錄：

private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";

好了，能夠在這裏打個斷點，看看到底怎麼加載，由於前面的file:./config/是一個相對路徑，咱們要看看，怎麼被解析爲絕對路徑的。

斷點debug，探求謎底

斷點咱們打在了load方法，運行項目，而後斷點果真停在了咱們想要的地方：

這個圖就很少解釋了，直接看圈出來的地方，咱們接着要看下面的函數：

private void loadForFileExtension(PropertySourceLoader loader, String prefix, String fileExtension,
				Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
			DocumentFilter defaultFilter = filterFactory.getDocumentFilter(null);
			DocumentFilter profileFilter = filterFactory.getDocumentFilter(profile);
			if (profile != null) {
                // 1
				...
			}
			//2 Also try the profile-specific section (if any) of the normal file
			load(loader, prefix + fileExtension, profile, profileFilter, consumer);
		}
  • 1處，省略了profile相關內容，咱們本次啓動，沒指定profile
  • 2處，繼續load

load處代碼：

private void load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter, DocumentConsumer consumer) {
  				// 1
				Resource resource = this.resourceLoader.getResource(location);
  				// 2
				if (resource == null || !resource.exists()) {
					if (this.logger.isTraceEnabled()) {
						StringBuilder description = getDescription("Skipped missing config ", location, resource, profile);
						this.logger.trace(description);
					}
					return;
				}
              ...
            }
  • 1處，將location轉換爲Resource，這裏傳入的location爲：file:./config/application.properties
  • 2處，判斷resource是否存在

resourceLoader怎麼getResource

這裏的resourceLoader，爲 org.springframework.core.io.DefaultResourceLoader。這個類，直接實現了org.springframework.core.io.ResourceLoader接口。

這個類，位於spring-core.jar中，基本是核心類了。

其註釋寫道：

* Default implementation of the {@link ResourceLoader} interface.
* Used by {@link ResourceEditor}, and serves as base class for
* {@link org.springframework.context.support.AbstractApplicationContext}.
* Can also be used standalone.
*
* <p>Will return a {@link UrlResource} if the location value is a URL,
* and a {@link ClassPathResource} if it is a non-URL path or a
* "classpath:" pseudo-URL.

大致翻譯：

ResourceLoader接口的默認實現，被ResourceEditor使用，同時，是AbstractApplicationContext的基類。

也能被單獨使用。

當傳入的value，是一個URL，則封裝爲一個UrlResource並返回；

當傳入的是一個非URL，或者是一個相似於"classpath："這樣的，則返回一個ClassPathResource

對其的介紹到此打住。繼續前面的代碼：

@Override
	public Resource getResource(String location) {
		Assert.notNull(location, "Location must not be null");

		...
		
        // 1
		if (location.startsWith("/")) {
			return getResourceByPath(location);
		} // 2
		else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
			return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
		}
		else {
			try {
				// 3 Try to parse the location as a URL...
				URL url = new URL(location);
				return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
			}
			catch (MalformedURLException ex) {
				// No URL -> resolve as resource path.
				return getResourceByPath(location);
			}
		}
	}
  • 1，判斷是否以 /開頭
  • 2，判斷是否以classpath開頭
  • 3，做爲參數，看看能不能 被解析爲一個URL

而後3處這裏，URL，是 jdk 的核心類，裏面 debug 進去挺深的，直接執行完這一句以後，咱們看看url這個參數的值：

總的來講，這裏就是：你給一個字符串，URL按照它的格式，來解析爲各個字段：好比，協議，host，port，query等等。可是，不表明這個URL就是能夠訪問的，若是是file，不表明這個文件就存在。這裏只是按照URL的格式去解析而已。

咱們繼續下一句：

URL url = new URL(location);
// 1
return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));

這裏1處，判斷是否爲file，若是是，則會new一個FileUrlResource。

該類的類結構以下：

前面調用了new ,咱們看看：

public FileUrlResource(URL url) {
		super(url);
	}

調用了父類：

/**
	 * Original URI, if available; used for URI and File access.
	 */
	@Nullable
	private final URI uri;

	/**
	 * Original URL, used for actual access.
	 */
	private final URL url;

	/**
	 * Cleaned URL (with normalized path), used for comparisons.
	 */
	private final URL cleanedUrl;

	public UrlResource(URL url) {
		this.url = url;
		this.cleanedUrl = getCleanedUrl(this.url, url.toString());
		this.uri = null;
	}

總的來講，就是利用你傳入的URL，進行clean，而後保存到了cleanedUrl。

咱們這裏，通過clean後，

  • clean後，cleanedUrl的值爲：file:config/application.properties
  • 原始的：file:./config/application.properties

差異不大，主要是去掉了開頭的./。

至此，咱們的FileUrlResource就構造結束了，至此，咱們完成了下面這行的解析。

Resource resource = this.resourceLoader.getResource(location);

判斷resource是否存在

前面咱們看到，FileUrlResource，繼承了org.springframework.core.io.AbstractFileResolvingResource接口。

而咱們這裏調用：

resource.exists()

就會進入其父類的exists方法

org.springframework.core.io.AbstractFileResolvingResource#exists
	public boolean exists() {
		try {
		    // 1
			URL url = getURL();
			if (ResourceUtils.isFileURL(url)) {
				//2 Proceed with file system resolution
				return getFile().exists();
			}
            ...
        }
  • 1，獲取url
  • 2，獲取file
  • 3，判斷是否存在。

其中2處，繼續：

@Override
	public File getFile() throws IOException {
        // 1
		File file = this.file;
		if (file != null) {
			return file;
		}
        // 2
		file = super.getFile();
        // 3
		this.file = file;
		return file;
	}
  • 1，查詢本地是否緩存
  • 2，沒緩存，則調用super類的getFile去獲取
  • 3，緩存。

繼續進入2處，

org.springframework.core.io.UrlResource#getFile	
	public File getFile() throws IOException {
        // 1
		if (this.uri != null) {
			return super.getFile(this.uri);
		}
		else {
		    // 2
			return super.getFile();
		}
	}
  • 1,咱們這裏uri是null，會進入2處
  • 2，調用父類。
org.springframework.core.io.AbstractFileResolvingResource#getFile()	
	@Override
	public File getFile() throws IOException {
        // 1
		URL url = getURL();
        // 2
		return ResourceUtils.getFile(url, getDescription());
	}
  • 1處，獲取url
  • 2處，獲取file。

繼續進入2處：

org.springframework.util.ResourceUtils#getFile(java.net.URL, java.lang.String)	
	public static File getFile(URL resourceUrl, String description) throws FileNotFoundException 	{
		try {
            // 1
			return new File(toURI(resourceUrl).getSchemeSpecificPart());
		}
		catch (URISyntaxException ex) {
			// Fallback for URLs that are not valid URIs (should hardly ever happen).
			return new File(resourceUrl.getFile());
		}
	}

這裏，傳入的resourceURL，類型爲URL, 在idea中顯示爲：

file:./config/application.properties

toURI,你們能夠大體看下，

org.springframework.util.ResourceUtils#toURI(java.net.URL)	
	public static URI toURI(URL url) throws URISyntaxException {
		return toURI(url.toString());
	}
public static URI toURI(String location) throws URISyntaxException {
  		return new URI(StringUtils.replace(location, " ", "%20"));
	}

上面幹了啥，就是把路徑裏的" "換成了"%20"。而後new了一個URI。

URI、URL的差異簡述

這兩個東西，太學術了，簡單理解，就是URI，指代的東西更多，包含的範圍更廣，URI表示中國的話，URL可能只能表示臺灣省。（我他麼一顆紅心）

總的來講，uri 不必定能夠訪問，url基本是能夠的。

參考：https://www.jianshu.com/p/81dfc203ab4a

最終是如何new file，判斷file是否存在的

通過前面的步驟後，

return new File(toURI(resourceUrl).getSchemeSpecificPart());

咱們獲取了一個URI，而後調用其getSchemeSpecificPart，最終拿到一個String，其值爲：

./config/application.properties

而後傳入了 File，用於構造一個file。

而後接着調用

java.io.File#exists
    public boolean exists() {
    	// 1
        return ((fs.getBooleanAttributes(this) & FileSystem.BA_EXISTS) != 0);
    }

而後這裏，1處調用了一個native方法：

java.io.WinNTFileSystem#getBooleanAttributes

public native int getBooleanAttributes(File f);

都到native方法了，無法繼續了。

可是，最終呢，咱們知道，如今的問題，變成了：

File file = new file("./config/application.properties");
file.exists();

new file，傳入相對路徑，這個相對路徑，到底相對於哪裏

通過我一番探索，最終寫了下面這個測試類，注意，該類使用默認包：

public class Test {


    public static void main(String[] args) throws IOException{
        // 1
        File file = new File("a.txt");
        // 2
        if (file.exists()) {
            System.out.println("file exists.path:" + file.getAbsolutePath());
        } else {
            // 3
            boolean newFile = file.createNewFile();
            if (newFile) {
                System.out.println("create new file");
            } else {
                System.out.println("create failed. file exists.path:" + file.getAbsolutePath());
            }
        }
    }

}
  • 1，new file，使用了相對路徑，即當前路徑，模擬以前咱們的問題
  • 2，判斷是否存在
  • 3，若是不存在，建立文件。

idea中執行

我目前的idea中，project路徑爲：

F:\workproject_codes\xxxx

第一次執行，結果：

create new file

說明文件不存在，進行了文件建立。而後我用everything搜索了下該文件，發現：

就在個人project路徑下。

而後我在想，爲啥會建立到這個地方去？

而後我加了一段代碼：

Properties properties = System.getProperties();
for (Map.Entry<Object, Object> entry : properties.entrySet()) {
  System.out.println(entry.getKey() + ", " + entry.getValue());
}

發現打印出來的properties中，有一個屬性：

user.dir, F:\workproject_codes\saltillo

說明這個地址，就是user.dir搞出來的。

在idea中，user.dir，就是project的路徑。

直接和class同級目錄下，java執行class

直接執行那個class文件，我放到了centos下的/home/test目錄下：

[root@localhost test]# ll
-rw-r--r--. 1 root root 2013 May 20 13:40 Test.class

[root@localhost test]# java Test

這種狀況下，建立的file，就是這個目錄下。

並且，看了下user.dir,就是當前目錄：

[root@localhost test]# java Test|grep user.dir
user.dir, /home/test

和class不在同級目錄下，java執行class

切換到上層目錄，即home下：

[root@localhost home]# pwd
/home

[root@localhost home]#  java -cp test/ Test |grep user.dir
user.dir, /home

...會在本目錄下生產a.txt，刪除後再次執行：
[root@localhost home]#  java -cp test/ Test |grep create
create new file result

看上面，此時的user.dir，就變成了/home目錄。

同時，建立了新的文件a.txt，就在當前home目錄下。

打成spring boot jar後，在centos運行，結果如何

在spring boot jar包裏的main，註釋了原來的啓動代碼，我加了這段代碼：

@SpringBootApplication
@EnableTransactionManagement
@EnableAspectJAutoProxy(exposeProxy = true)
@EnableFeignClients
//@Slf4j
@Controller
@EnableScheduling
public class xxx {
    private static Logger log= null;
    static {
       

    public static void main(String[] args) throws IOException {
        Properties properties = System.getProperties();
        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            System.out.println(entry.getKey() + ", " + entry.getValue());
        }
        File file = new File("a.txt");
        if (file.exists()) {
            System.out.println("file exists.path:" + file.getAbsolutePath());
        } else {
            boolean newFile = file.createNewFile();
            if (newFile) {
                System.out.println("create new file");
            } else {
                System.out.println("create failed. file exists.path:" + file.getAbsolutePath());
            }
        }

//        new SpringApplicationBuilder(xxx.class).web(WebApplicationType.SERVLET).run(args);

    }
    
}

在/root/tt下運行，用java -jar xxx.jar運行後，

user.dir, /root/tt
...
create new file

而後，果真，在/root/tt下，就建了一個a.txt文件。

[root@localhost tt]# ll
total 109412
-rw-r--r--. 1 root root         0 May 20 16:41 a.txt
-rw-r--r--. 1 root root 112035602 May 20 16:40 xxx.jar
[root@localhost tt]# pwd
/root/tt

user.dir是個什麼東西

爲此，我專門把那個class，拷貝到了root目錄下，執行：

[root@localhost ~]# java Test |grep user.dir
user.dir, /root

這，看起來，在哪裏運行java，user.dir就是哪兒啊，相似於pwd了。

你們若是直接去網上搜user.dir，基本都是很混亂，各說各的，你們按照上面這樣實踐下就知道了。

總結

咱們已經找到了問題緣由了，總的來講，就是spring boot外部化配置時，

file:./config/

這個路徑，相對路徑，相對的是user.dir。

而user.dir怎麼來，就是你在哪一個目錄下執行java，哪一個目錄就是user.dir。

題目中這個問題怎麼解決，能夠直接在java -jar xxx.jar中，加一個參數：

java -jar -Dspring.config.location=D:\config\config.properties springbootrestdemo-0.0.1-SNAPSHOT.jar

可參考：
http://www.javashuo.com/article/p-alvuwpag-dm.html

我這邊的操做系統，pc是win7，centos是：

[root@localhost tt]# cat /etc/centos-release
CentOS Linux release 7.6.1810 (Core)

謝謝你們。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程