SpringBoot如何解析应用参数args

// SpringApplication类方法
public ConfigurableApplicationContext run(String... args) {
    // 记录应用启动的开始时间
    long startTime = System.nanoTime();
    // 1.创建引导上下文，用于管理应用启动时的依赖和资源
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    // 配置无头模式属性，以支持在无图形环境下运行
    // 将系统属性 java.awt.headless 设置为 true
    configureHeadlessProperty();
    // 2.获取Spring应用启动监听器，用于在应用启动的各个阶段执行自定义逻辑
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 启动开始方法（发布开始事件、通知应用监听器ApplicationListener）
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        // 3.解析应用参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 4.准备应用环境，包括读取配置文件和设置环境变量
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        // 配置是否忽略 BeanInfo，以加快启动速度
        configureIgnoreBeanInfo(environment);
        // 5.打印启动Banner
        Banner printedBanner = printBanner(environment);
        // 6.创建应用程序上下文
        context = createApplicationContext();
        // 设置应用启动的上下文，用于监控和管理启动过程
        context.setApplicationStartup(this.applicationStartup);
        // 7.准备应用上下文，包括加载配置、添加 Bean 等
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 8.刷新上下文，完成 Bean 的加载和依赖注入
        refreshContext(context);
        // 9.刷新后的一些操作，如事件发布等
        afterRefresh(context, applicationArguments);
        // 计算启动应用程序的时间，并记录日志
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        // 10.通知监听器应用启动完成
        listeners.started(context, timeTakenToStartup);
        // 11.调用应用程序中的 `CommandLineRunner` 或 `ApplicationRunner`，以便执行自定义的启动逻辑
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 12.处理启动过程中发生的异常，并通知监听器
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        // 13.计算应用启动完成至准备就绪的时间，并通知监听器
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 处理准备就绪过程中发生的异常
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    // 返回已启动并准备就绪的应用上下文
    return context;
}

// 3.解析应用参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

// 3.解析应用参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

java -jar myapp.jar --server.port=8080 arg1 arg2

public static void main(String[] args) {
    DefaultApplicationArguments appArgs = new DefaultApplicationArguments(args);
    // 获取所有选项参数名称
    System.out.println("选项参数：" + appArgs.getOptionNames());  // 输出: ["server.port"]
    // 获取指定选项的值（所有以 `--` 开头的选项参数名称）
    System.out.println("server.port 值：" + appArgs.getOptionValues("server.port"));  // 输出: ["8080"]
    // 获取非选项参数（所有不以 `--` 开头的参数，通常用于传递无标记的参数值）
    System.out.println("非选项参数：" + appArgs.getNonOptionArgs());  // 输出: ["arg1", "arg2"]
}

// 提供对用于运行应用的参数的访问。
public interface ApplicationArguments {
	// 返回传递给应用程序的原始未处理参数
	String[] getSourceArgs();
	// 返回所有选项参数的名称
	Set<String> getOptionNames();
	// 返回解析的选项参数集合中是否包含具有给定名称的选项
	boolean containsOption(String name);
	// 返回与给定名称的选项参数关联的值集合
	List<String> getOptionValues(String name);
	// 返回解析的非选项参数集合
	List<String> getNonOptionArgs();
}

// ApplicationArguments的默认实现类，用于解析应用程序启动时传入的参数。
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"); // 确保传入参数不为 null
		this.source = new Source(args); // 使用内部类 Source 解析参数
		this.args = args; // 保存原始参数
	}
	// 获取原始未处理的参数数组
	@Override
	public String[] getSourceArgs() {
		return this.args;
	}
	// 获取所有选项参数的名称集合
	@Override
	public Set<String> getOptionNames() {
		String[] names = this.source.getPropertyNames();
		// 该集合不能被修改（即添加、删除元素等操作会抛出 UnsupportedOperationException 异常）
		return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(names)));
	}
	// 检查是否包含指定名称的选项参数
	@Override
	public boolean containsOption(String name) {
		return this.source.containsProperty(name);
	}
	// 获取指定名称的选项参数的值集合
	@Override
	public List<String> getOptionValues(String name) {
		List<String> values = this.source.getOptionValues(name);
		return (values != null) ? Collections.unmodifiableList(values) : null;
	}
	// 获取所有非选项参数（不以 "--" 开头的参数）
	@Override
	public List<String> getNonOptionArgs() {
		return this.source.getNonOptionArgs();
	}
	// 内部类，用于处理和解析命令行参数
	// 继承自 SimpleCommandLinePropertySource，可以获取选项参数和非选项参数
	private static class Source extends SimpleCommandLinePropertySource {
		// 使用参数数组初始化 Source
		Source(String[] args) {
			super(args);
		}
		// 获取所有非选项参数。
		@Override
		public List<String> getNonOptionArgs() {
			return super.getNonOptionArgs();
		}
		// 获取指定名称的选项参数的值列表
		@Override
		public List<String> getOptionValues(String name) {
			return super.getOptionValues(name);
		}
	}
}

public abstract class PropertySource<T> {
	protected final Log logger = LogFactory.getLog(getClass());
	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;
	}
	// 使用给定的名称和一个新的Object对象作为底层源创建属性源
	public PropertySource(String name) {
		this(name, (T) new Object());
	}
	// 返回属性源名称
	public String getName() {
		return this.name;
	}
	// 返回属性源的底层源对象。
	public T getSource() {
		return this.source;
	}
	// 判断属性源是否包含给定名称的属性（子类可以实现更高效的算法）
	// containsProperty和getProperty参数的name与上面定义的属性源名称的name不是一回事
	public boolean containsProperty(String name) {
		return (getProperty(name) != null);
	}
	// 返回与给定名称关联的属性值，如果找不到则返回null，子类实现
	@Nullable
	public abstract Object getProperty(String name);
	...
}

public abstract class EnumerablePropertySource<T> extends PropertySource<T> {
	// 使用给定的名称和源对象创建属性源（调用父类PropertySource的构造方法）
	public EnumerablePropertySource(String name, T source) {
		super(name, source);
	}
	// 也是调用父类构造
	protected EnumerablePropertySource(String name) {
		super(name);
	}
	// 判断属性源是否包含具有给定名称的属性（重新了PropertySource的此方法）
	@Override
	public boolean containsProperty(String name) {
		return ObjectUtils.containsElement(getPropertyNames(), name);
	}
	// 返回所有属性的名称
	public abstract String[] getPropertyNames();
}

public abstract class CommandLinePropertySource<T> extends EnumerablePropertySource<T> {
	// CommandLinePropertySource实例的默认名称
	public static final String COMMAND_LINE_PROPERTY_SOURCE_NAME = "commandLineArgs";
	// 表示非选项参数的属性键的默认名称
	public static final String DEFAULT_NON_OPTION_ARGS_PROPERTY_NAME = "nonOptionArgs";
	private String nonOptionArgsPropertyName = DEFAULT_NON_OPTION_ARGS_PROPERTY_NAME;
	// 创建一个新的命令行属性源，使用默认名称
	public CommandLinePropertySource(T source) {
		super(COMMAND_LINE_PROPERTY_SOURCE_NAME, source);
	}
	// 创建一个新的命令行属性源，具有给定名称
	public CommandLinePropertySource(String name, T source) {
		super(name, source);
	}
	// 可以通过set方法设置非选项参数的键的名称
	public void setNonOptionArgsPropertyName(String nonOptionArgsPropertyName) {
		this.nonOptionArgsPropertyName = nonOptionArgsPropertyName;
	}
	// 首先检查指定的名称是否是特殊的“非选项参数”属性，
	// 如果是，则委托给抽象方法#getNonOptionArgs()
	// 否则，委托并返回抽象方法#containsOption(String)
	@Override
	public final boolean containsProperty(String name) {
		if (this.nonOptionArgsPropertyName.equals(name)) {
			return !getNonOptionArgs().isEmpty();
		}
		return this.containsOption(name);
	}
	// 首先检查指定的名称是否是特殊的“非选项参数”属性，
	// 如果是，则委托给抽象方法#getNonOptionArgs()，返回用逗号隔开字符串
	// 否则，委托并返回抽象方法#getOptionValues(name)，返回用逗号隔开字符串
	@Override
	@Nullable
	public final String getProperty(String name) {
		if (this.nonOptionArgsPropertyName.equals(name)) {
			Collection<String> nonOptionArguments = getNonOptionArgs();
			if (nonOptionArguments.isEmpty()) {
				return null;
			}
			else {
				return StringUtils.collectionToCommaDelimitedString(nonOptionArguments);
			}
		}
		Collection<String> optionValues = getOptionValues(name);
		if (optionValues == null) {
			return null;
		}
		else {
			return StringUtils.collectionToCommaDelimitedString(optionValues);
		}
	}
	// 返回从命令行解析的选项参数集合中是否包含具有给定名称的选项
	protected abstract boolean containsOption(String name);
	// 返回与给定名称的选项参数关联的值集合
	@Nullable
	protected abstract List<String> getOptionValues(String name);
	// 返回从命令行解析的非选项参数集合，永不为null
	protected abstract List<String> getNonOptionArgs();
}

public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {
	// 构造函数：创建一个使用默认名称commandLineArgs的SimpleCommandLinePropertySource实例的命令行属性源
	public SimpleCommandLinePropertySource(String... args) {
		super(new SimpleCommandLineArgsParser().parse(args));
	}
	// 创建指定名称命令行属性源
	public SimpleCommandLinePropertySource(String name, String[] args) {
		super(name, new SimpleCommandLineArgsParser().parse(args));
	}
	// 获取所有选项参数的名称
	@Override
	public String[] getPropertyNames() {
		return StringUtils.toStringArray(this.source.getOptionNames());
	}
	// 检查是否包含指定名称的选项
	@Override
	protected boolean containsOption(String name) {
		return this.source.containsOption(name);
	}
	// 获取指定选项名称的值列表
	@Override
	@Nullable
	protected List<String> getOptionValues(String name) {
		return this.source.getOptionValues(name);
	}
	// 获取所有非选项参数的列表
	@Override
	protected List<String> getNonOptionArgs() {
		return this.source.getNonOptionArgs();
	}
}

// 3.解析应用参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

class SimpleCommandLineArgsParser {
	public CommandLineArgs parse(String... args) {
		// 创建 CommandLineArgs 实例，用于存储解析结果
		CommandLineArgs commandLineArgs = new CommandLineArgs(); 
		for (String arg : args) { // 遍历每个命令行参数
			if (arg.startsWith("--")) { // 如果参数以 "--" 开头，则视为选项参数
				String optionText = arg.substring(2); // 去掉 "--" 前缀
				String optionName; // 选项名称
				String optionValue = null; // 选项值，默认为 null
				int indexOfEqualsSign = optionText.indexOf('='); // 查找等号的位置
				if (indexOfEqualsSign > -1) { // 如果找到了等号
					optionName = optionText.substring(0, indexOfEqualsSign); // 等号前的部分为选项名称
					optionValue = optionText.substring(indexOfEqualsSign + 1); // 等号后的部分为选项值
				}
				else {
					optionName = optionText; // 如果没有等号，整个文本为选项名称，值为 null
				}
				// 如果选项名称为空，抛出异常，例如，只输入了 "--=" 或 "--"
				if (optionName.isEmpty()) { 
					throw new IllegalArgumentException("Invalid argument syntax: " + arg);
				}
				// 将解析出的选项名称和值添加到 CommandLineArgs 对象中
				commandLineArgs.addOptionArg(optionName, optionValue); 
			}
			else {
				// 如果参数不是选项参数，直接作为非选项参数添加到 CommandLineArgs 对象中
				commandLineArgs.addNonOptionArg(arg); 
			}
		}
		return commandLineArgs; // 返回解析结果
	}
}

// 命令行参数的简单表示形式，分为“带选项参数”和“无选项参数”。
class CommandLineArgs {
	// 存储带选项的参数，每个选项可以有一个或多个值
	private final Map<String, List<String>> optionArgs = new HashMap<>();
	// 存储无选项的参数
	private final List<String> nonOptionArgs = new ArrayList<>();
	// 为指定的选项名称添加一个选项参数，并将给定的值添加到与此选项关联的值列表中（可能有零个或多个）
	public void addOptionArg(String optionName, @Nullable String optionValue) {
		if (!this.optionArgs.containsKey(optionName)) {
			this.optionArgs.put(optionName, new ArrayList<>());
		}
		if (optionValue != null) {
			this.optionArgs.get(optionName).add(optionValue);
		}
	}
	// 返回命令行中所有带选项的参数名称集合
	public Set<String> getOptionNames() {
		return Collections.unmodifiableSet(this.optionArgs.keySet());
	}
	// 判断命令行中是否包含指定名称的选项。
	public boolean containsOption(String optionName) {
		return this.optionArgs.containsKey(optionName);
	}
	// 返回与给定选项关联的值列表。
	// 表示null表示该选项不存在；空列表表示该选项没有关联值。
	@Nullable
	public List<String> getOptionValues(String optionName) {
		return this.optionArgs.get(optionName);
	}
	// 将给定的值添加到无选项参数列表中
	public void addNonOptionArg(String value) {
		this.nonOptionArgs.add(value);
	}
	// 返回命令行中指定的无选项参数列表
	public List<String> getNonOptionArgs() {
		return Collections.unmodifiableList(this.nonOptionArgs);
	}
}