1 main方法入参args的作用

本节的标题关键字是PropertySource，为什么是它，我们来看下代码

public ConfigurableApplicationContext run(String... args) {
		long startTime = System.nanoTime();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
			}
			listeners.started(context, timeTakenToStartup);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
		try {
			Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
			listeners.ready(context, timeTakenToReady);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

首先，在run方法中，使用方法入参args构造了一个DefaultApplicationArguments，在DefaultApplicationArguments的构造方法中，又使用args构造出一个Source，

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

Source是个内部类，实际上没有自定义实现逻辑，完全继承于SimpleCommandLinePropertySource，继续向上寻找父类，最终继承的是PropertySource。

再看使用了DefaultApplicationArguments对象的代码，第一处是在prepareEnvironment准备运行时环境时，代码路径为run -> prepareEnvironment -> configureEnvironment

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
   if (this.addConversionService) {
      environment.setConversionService(new ApplicationConversionService());
   }
   configurePropertySources(environment, args);
   configureProfiles(environment, args);
}

其中configureProfiles没有具体实现，可以忽略。在configurePropertySources中，

protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
   MutablePropertySources sources = environment.getPropertySources();
   if (!CollectionUtils.isEmpty(this.defaultProperties)) {
      DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
   }
   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));
      }
   }
}

使用args构造了SimpleCommandLinePropertySource，并放入environment的propertySources中。

第二处引用是在prepareContext中，跟进方法可以看到只是被注册成了一个bean放入beanFactory，代码比较简单，这里不再单独贴出。

第三处引用是在afterRefresh中，该方法没有具体实现，可以忽略。

第四处引用是在callRunners中，跟随代码进入run -> callRunners -> callRunner，发现args只是被用作回调runner的方法入参，暂时也不必深究。

因此总结一下上述，args的主要作用有，一是被构造成了一个DefaultApplicationArguments，然后注册为bean，且DefaultApplicationArguments主要是代理了SimpleCommandLinePropertySource的功能；二是用于配置Environment，作为Environment的propertySources之一。

所以接下来，我们应该要了解一下PropertySource是什么。

2 PropertySource

/**
 * Abstract base class representing a source of name/value property pairs. The underlying
 * {@linkplain #getSource() source object} may be of any type {@code T} that encapsulates
 * properties. Examples include {@link java.util.Properties} objects, {@link java.util.Map}
 * objects, {@code ServletContext} and {@code ServletConfig} objects (for access to init
 * parameters). Explore the {@code PropertySource} type hierarchy to see provided
 * implementations.
 *
 * <p>{@code PropertySource} objects are not typically used in isolation, but rather
 * through a {@link PropertySources} object, which aggregates property sources and in
 * conjunction with a {@link PropertyResolver} implementation that can perform
 * precedence-based searches across the set of {@code PropertySources}.
 *
 * <p>{@code PropertySource} identity is determined not based on the content of
 * encapsulated properties, but rather based on the {@link #getName() name} of the
 * {@code PropertySource} alone. This is useful for manipulating {@code PropertySource}
 * objects when in collection contexts. See operations in {@link MutablePropertySources}
 * as well as the {@link #named(String)} and {@link #toString()} methods for details.
 *
 * <p>Note that when working with @{@link
 * org.springframework.context.annotation.Configuration Configuration} classes that
 * the @{@link org.springframework.context.annotation.PropertySource PropertySource}
 * annotation provides a convenient and declarative way of adding property sources to the
 * enclosing {@code Environment}.
 *
 * @author Chris Beams
 * @since 3.1
 * @param <T> the source type
 * @see PropertySources
 * @see PropertyResolver
 * @see PropertySourcesPropertyResolver
 * @see MutablePropertySources
 * @see org.springframework.context.annotation.PropertySource
 */
public abstract class PropertySource<T> {

	protected final Log logger = LogFactory.getLog(getClass());

	protected final String name;

	protected final T source;

翻译一下：

• 它的source是name/value属性对的值来源，也就是说source保存了属性值，source的类型可以是各种具体实现。

• • 比如我们来找一下PropertySource的实现类：SimpleCommandLinePropertySource使用CommandLineArgs来存储属性值，MapPropertySource使用Map来存储属性值

• • • public class SimpleCommandLinePropertySource extends CommandLinePropertySource
    • public class MapPropertySource extends EnumerablePropertySource<Map<String, Object>>

• PropertySource对象通常不单独使用，一般是通过PropertySources聚合多个PropertySource，这些PropertySource可以有个优先级的关系

• • 比如AbstractEnvironment的propertySources是一个MutablePropertySources，MutablePropertySources中包含了propertySourceList，可以对其addFirst或addLast，propertySourceList中元素的顺序实际就代表着优先级

public void addFirst(PropertySource<?> propertySource) {
   synchronized (this.propertySourceList) {
      removeIfPresent(propertySource);
      this.propertySourceList.add(0, propertySource);
   }
}

/**
 * Add the given property source object with the lowest precedence.
 */
public void addLast(PropertySource<?> propertySource) {
   synchronized (this.propertySourceList) {
      removeIfPresent(propertySource);
      this.propertySourceList.add(propertySource);
   }
}

• 两个PropertySource对象的比较，不应该基于它的属性内容判断，而是应该基于它的name名称判断。可以参考MutablePropertySources#named方法

• • 定位到MutablePropertySources#named的代码，我们可以看到MutablePropertySources中实现了一个内部类ComparisonPropertySource用于集合比较，ComparisonPropertySource只有一个name属性

• 最后一句注释讲的是在配置类上使用@PropertySource注解，可以导入配置文件（非application.properties的properties文件需要使用@PropertySource添加进来）

接下来再以SimpleCommandLinePropertySource为例，具体看下PropertySource的用法。

2.1 SimpleCommandLinePropertySource

SimpleCommandLinePropertySource继承了CommandLinePropertySource，因此使用的是CommandLineArgs来保存值

public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {

再看CommandLineArgs类，内部实际保存了两种存储结构，一是optionArgs，保存形如“--foo=bar”的键值对，二是nonOptionArgs保存纯粹的value。

/**
 * A simple representation of command line arguments, broken into "option arguments" and
 * "non-option arguments".
 *
 * @author Chris Beams
 * @since 3.1
 * @see SimpleCommandLineArgsParser
 */
class CommandLineArgs {

   private final Map<String, List<String>> optionArgs = new HashMap<>();
   private final List<String> nonOptionArgs = new ArrayList<>();

再回到SimpleCommandLinePropertySource类，发现了CommandLineArgs的解析器SimpleCommandLineArgsParser，parse方法将args解析为CommandLineArgs

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

class SimpleCommandLineArgsParser {

   /**
    * Parse the given {@code String} array based on the rules described {@linkplain
    * SimpleCommandLineArgsParser above}, returning a fully-populated
    * {@link CommandLineArgs} object.
    * @param args command line arguments, typically from a {@code main()} method
    */
   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) {
               optionName = optionText.substring(0, indexOfEqualsSign);
               optionValue = optionText.substring(indexOfEqualsSign + 1);
            }
            else {
               optionName = optionText;
            }
            if (optionName.isEmpty()) {
               throw new IllegalArgumentException("Invalid argument syntax: " + arg);
            }
            commandLineArgs.addOptionArg(optionName, optionValue);
         }
         else {
            commandLineArgs.addNonOptionArg(arg);
         }
      }
      return commandLineArgs;
   }

}

2.2 使用示例

• application.properties中新增一行配置test.key1=${key1}

• 程序启动配置Program arguments为--key1=value1

• 最后通过Environment尝试获取test.key1的值

Environment environment = context.getBean(Environment.class);
System.out.println("test.key1: " + environment.getProperty("test.key1"));

• 运行结果中成功获取到了配置的值