springboot加載命令行參數ApplicationArguments的實現

Posted on by

一、介紹

使用springboot開發的同學們，都一定會從配置文件application.yml中讀取配置。比如我們常常會在上傳文件的功能中，把文件的保存路徑寫在配置文件中，然後在代碼中通過@Value()註解從配置文件讀取對應的配置，如下所示：

在配置文件中定義文件路徑

file:
  location: /data/files

在代碼中獲取保存路徑

@Component
public class upload {
    @Value("${file.location}")
    private String fileLocation; // 文件路徑/data/files
    
    public void upload(File file) {
        // 將文件保存到fileLocation中。
    }
}

這種讀取配置的方式非常方便，但是有一個讓人抓狂的缺點：

在多人協作開發的情況下，同事A在配置文件中修改file.location的值為E:\\後將代碼提交到git倉庫，這時同事B把最新代碼拉下來後由於他的電腦中不存在E盤導致該功能出現bug，很多同學不嫌麻煩，每次拉下最新代碼後都會把這種配置重新修改以適合自己電腦的要求。

幸運的是，springboot在讀取配置參數方面為我們提供瞭多種方式，並且不同方式之間存在優先級差異，如命令行配置的優先級大於配置文件的優先級。如下圖為springboot官方的描述

從上圖可知，命令行配置是在非單元測試環境下優先級最高的。

在我們通過java -jar命令啟動項目時，添加額外的參數，就可以解決上面提及的多人協作開發的問題瞭。

二、通過應用程序參數獲取配置

當我們使用IDEA啟動springboot項目時，可以對項目的啟動設置命令行參數，命令行參數的格式為--name=value 或 --name，如下所示

1. 通過bean獲取應用程序參數

啟動項目後，我們從IOC容器中獲取命令行參數對應的beanspringApplicationArguments，再從該bean中就可以獲取到我們在命令行中配置的參數瞭。

springboot悄悄替我們向IOC容器中註冊一個ApplicationArguments類型的bean，beanName為springApplicationArguments，該bean中保存著我們設置的應用程序參數。

@SpringBootApplication
public class ArgumentApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(ArgumentApplication.class, args);

        // 獲取應用程序參數
        ApplicationArguments applicationArguments =(ApplicationArguments)applicationContext
            																	.getBean("springApplicationArguments");
        // 獲取命令行中name的配置
        List<String> name = applicationArguments.getOptionValues("name");
        System.out.println(name);
    }
}

輸出如下所示

當然，你也可以通過@Autowired的方式在類裡註入ApplicationArguments實例來獲取其中的配置。

2. 通過@Value註解獲取

當然我們更常用的方式是通過@Value註解來獲取，如下所示

新建一個ComponentA，並用@Component註解標註為springBean，然後為其定義@Value標註的成員變量name

@Component
public class ComponentA {

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

    public ComponentA() {
    }

    public String getName() {
        return name;
    }
}

項目啟動後，從IOC容器中獲取ComponentA，並調用getName()方法來驗證name的值

@SpringBootApplication
public class ArgumentApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(ArgumentApplication.class, args);

        // 從配置文件中獲取
        ComponentA componentA = (ComponentA) applicationContext.getBean("componentA");
        System.out.println(componentA.getName());
    }
}

輸出，結果符合預期

三、源碼解讀 – 封裝應用程序參數

springboot通過啟動類的main()方法接收命令行中以--定義的應用程序參數，將參數按照不同類型以Map<String, List<String>>和List<String>保存並封裝到CommandLineArgs對象中，然後以name="commandLineArgs"，source=CommandLineArgs對象將其封裝到Source中，而Source為ApplicationArguments內部屬性，springboot將ApplicationArguments註入IOC容器。

從上面的例子中我們發現，springboot把我們配置的命令行參數封裝到ApplicationArguments瞭，而ApplicationArguments又被springboot註冊到IOC容器中，其對應的beanName為"springApplicationArguments"，下面我們通過分析源碼來逐步解開它是如何操作的。

首先，大傢在寫springboot啟動類時，有沒有註意到其中main()方法的參數String[] args，如下所示

@SpringBootApplication
public class ArgumentApplication {

    public static void main(String[] args) {
        SpringApplication.run(ArgumentApplication.class, args);
    }
}

但這個參數想必有很多同學不知道它是幹嘛用的，它的作用就是用來接收啟動命令中設置的--name=key參數，比如java -jarApplication.jar --name=key ，我們可以通過斷點進行驗證

在源碼run()方法中我們追蹤args這個參數的調用鏈如下：

public ConfigurableApplicationContext run(String... args) {
    // ...
    SpringApplicationRunListeners listeners = getRunListeners(args);
	// ...
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // ...
}

從源碼可以看出，參數args可以被用來獲取運行監聽器 和 構造應用參數，因此我們把註意力放在構造應用參數上來。

1. DefaultApplicationArguments

看一下該類的結構，從它的構造方法我們得知，該類是把我們傳入的--應用程序參數封裝成一個Source對象，同時也保存一份原始的args參數，當我們需要獲取參數時，都是調用Source對象提供的方法獲取的，因此Source這個類尤其關鍵，我們需要弄清楚它是如何分析應用程序參數並將其封裝到Source中的。

public class DefaultApplicationArguments implements ApplicationArguments {

	private final Source source;
	private final String[] args;

	public DefaultApplicationArguments(String... args) {
		Assert.notNull(args, "Args must not be null");
		this.source = new Source(args);
		this.args = args;
	}
	// ...
	private static class Source extends SimpleCommandLinePropertySource {

		Source(String[] args) {
			super(args);
		}
        // ...
	}
}

2. Source類

Source類是DefaultApplicationArguments的內部類，上面已經展示其具體實現的源碼，它的構造函數就是把接收的應用程序參數傳遞給父類的構造函數。

下面我們看一下他的UML圖

由於Source的構造函數直接把參數args交給其父類的構造函數，而Source本身沒有多餘的處理，因此我們直接進入其父類SimpleCommandLinePropertySource。

3. SimpleCommandLinePropertySource

public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {

	public SimpleCommandLinePropertySource(String... args) {
		super(new SimpleCommandLineArgsParser().parse(args));
	}

	public SimpleCommandLinePropertySource(String name, String[] args) {
		super(name, new SimpleCommandLineArgsParser().parse(args));
	}
}

在這個類中，又是直接調用父類的構造方法，且沒有自身的實現。但不同的，這裡將我們設置的應用程序進行轉換成CommandLineArgs對象交給父類構造函數。

它是怎麼分析我們傳入的應用程序參數的，又將其轉換成什麼樣的結構呢？

4. SimpleCommandLineArgsParser

該類隻有一個靜態方法parse()，從命名也可以看出，該類的功能就是對命令行參數提供簡單的轉換器。

class SimpleCommandLineArgsParser {

	public CommandLineArgs parse(String... args) {
		CommandLineArgs commandLineArgs = new CommandLineArgs();
		for (String arg : args) {
            // 以 -- 開頭的應用程序參數
			if (arg.startsWith("--")) {
				String optionText = arg.substring(2);
				String optionName;
				String optionValue = null;
				int indexOfEqualsSign = optionText.indexOf('=');
				if (indexOfEqualsSign > -1) {
                    // --key=value這種形式的參數
					optionName = optionText.substring(0, indexOfEqualsSign);
					optionValue = optionText.substring(indexOfEqualsSign + 1);
				}
				else {
                    // --key這種形式的參數
					optionName = optionText;
				}
				if (optionName.isEmpty()) {
					throw new IllegalArgumentException("Invalid argument syntax: " + arg);
				}
				commandLineArgs.addOptionArg(optionName, optionValue);
			}
			else {
                // 不以 -- 開頭的應用程序參數
				commandLineArgs.addNonOptionArg(arg);
			}
		}
		return commandLineArgs;
	}
}

從源碼得知，應用程序參數的轉換過程非常簡單，就是根據-- 和 =進行字符串裁剪，然後將這些參數封裝到CommandLineArgs裡。而在CommandLineArgs中用不同的字段來保存不同類型的應用程序參數。如下

class CommandLineArgs {
	// 保存 --key=value  和 --key這兩種類型的應用程序參數
	private final Map<String, List<String>> optionArgs = new HashMap<>();
    // 保存 key 這一種類型的應用程序參數
	private final List<String> nonOptionArgs = new ArrayList<>();
}

回到上一節SimpleCommandLinePropertySource，它的構造函數就是將應用程序參數轉換為CommandLineArgs然後交給父類構造函數，那下面我們看其父類CommandLinePropertySource。

5. CommandLinePropertySource

在CommandLinePropertySource中，我們主要看其構造函數。

public abstract class CommandLinePropertySource<T> extends EnumerablePropertySource<T> {

	public static final String COMMAND_LINE_PROPERTY_SOURCE_NAME = "commandLineArgs";

	public CommandLinePropertySource(T source) {
		super(COMMAND_LINE_PROPERTY_SOURCE_NAME, source);
	}
}

很顯然，又是直接調用父類的構造函數，而且向其父類構造函數傳入的是"commandLineArgs"字符串 和 CommandLineArgs對象。那我們繼續，進入父類EnumerablePropertySource，然後又將這兩個參數繼續傳遞給父類PropertySource

public abstract class EnumerablePropertySource<T> extends PropertySource<T> {
    
	public EnumerablePropertySource(String name, T source) {
		super(name, source);
	}
}

6. PropertySource

通過前面一系列對父類構造函數的調用，最終將name初始化為"commandLineArgs"字符串 ，將source初始化為 CommandLineArgs對象。

public abstract class PropertySource<T> {

	protected final String name;

	protected final T source;
    
	public PropertySource(String name, T source) {
		Assert.hasText(name, "Property source name must contain at least one character");
		Assert.notNull(source, "Property source must not be null");
		this.name = name;
		this.source = source;
	}
}

四、源碼解讀 – 為什麼可以通過@Value註解獲取參數配置

在前面我們將應用程序參數封裝到ApplicationArguments對象中後，springboot又將這些應用程序參數添加到environment對象中，並且對已存在的配置進行覆蓋，因此與配置文件中定義的參數類似，都可以通過@Value註解獲取。

在下面的源碼中，主要表達的是應用程序參數在各個方法調用中的傳遞，最關鍵的部分我們要看configurePropertySources()方法。該方法將應用程序參數配置到運行環境environment。

public ConfigurableApplicationContext run(String... args) {
    // ...
	ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
	ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
	// ...
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // Create and configure the environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    configureEnvironment(environment, applicationArguments.getSourceArgs());
}

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // ...
    configurePropertySources(environment, args);
    // ...
}

// 將應用程序設置到environment對象中，與配置文件中的參數處於同一environment對象中，因此可以通過@Value註解獲取參數配置
protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
    MutablePropertySources sources = environment.getPropertySources();
    DefaultPropertiesPropertySource.ifNotEmpty(this.defaultProperties, sources::addLast);
    if (this.addCommandLineProperties && args.length > 0) {
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        if (sources.contains(name)) {
            // 環境中已存在相同的配置，則進行覆蓋
            PropertySource<?> source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(
                new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
            composite.addPropertySource(source);
            sources.replace(name, composite);
        }
        else {
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}

五、源碼解讀 – 將應用程序參數註冊到IOC容器

在前面的章節，我們通過源碼分析得出結論，springboot將應用程序參數封裝到ApplicationArguments和運行環境Environment中。接下來我們看它是如何註冊到IOC容器的。

public ConfigurableApplicationContext run(String... args) {
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    // ...
    prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
	// ...
}

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
    // ...
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    // ...
}

springboot將應用程序參數ApplicationArguments直接通過beanFactory.registerSingleton()方法手動地註冊到IOC容器中，beanName為springApplicationArguments。

六、總結

springboot將我們配置的命令行參數封裝到ApplicationArguments，並使用"springApplicationArguments"作為beanName將其註冊到IOC容器。

設置應用程序參數時，符合要求的設置為：--key=value、--key 以及 key。可以通過@Value註解直接獲取應用程序參數。可以通過@Autowired依賴註入一個ApplicationArguments實例來讀取應用程序參數。
 

到此這篇關於springboot加載命令行參數ApplicationArguments的實現的文章就介紹到這瞭,更多相關springboot加載命令行參數內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：