SpringBoot如何解析应用参数args_Java

前言

前文深入解析了springboot启动的开始阶段，包括获取和启动应用启动监听器、事件与广播机制，以及如何通过匹配监听器实现启动过程各阶段的自定义逻辑。接下来，我们将探讨springboot启动类main函数中的参数args的作用及其解析过程。

springboot版本2.7.18springapplication的run方法的执行逻辑如下，本文将详细介绍第3小节：解析应用参数

// 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;
}

一、入口

将main方法的参数args封装成一个对象defaultapplicationarguments，以便方便地解析和访问启动参数

// 3.解析应用参数
applicationarguments applicationarguments = new defaultapplicationarguments(args);

二、默认应用程序参数defaultapplicationarguments

1、功能概述

defaultapplicationarguments是springboot中的一个类，用于处理启动时传入的参数。它实现了applicationarguments接口，并提供了一些便捷的方法来访问传入的命令行参数和选项参数。

// 3.解析应用参数
applicationarguments applicationarguments = new defaultapplicationarguments(args);

解析命令行参数：将 main 方法中的 args 参数解析成选项参数和非选项参数，方便应用在启动时读取外部传入的配置
访问选项参数：支持以--key=value格式的选项参数，通过方法getoptionnames()和getoptionvalues(string name)获取特定的选项及其值
访问非选项参数：对于不以--开头的参数，可以通过getnonoptionargs()获取它们的列表

2、使用示例

假设我们在命令行中运行应用，传递了一些参数

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

在代码中，我们可以使用defaultapplicationarguments来解析这些参数

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"]
}

3、接口applicationarguments

applicationarguments是defaultapplicationarguments类的父接口

// 提供对用于运行应用的参数的访问。
public interface applicationarguments {
	// 返回传递给应用程序的原始未处理参数
	string[] getsourceargs();
	// 返回所有选项参数的名称
	set<string> getoptionnames();
	// 返回解析的选项参数集合中是否包含具有给定名称的选项
	boolean containsoption(string name);
	// 返回与给定名称的选项参数关联的值集合
	list<string> getoptionvalues(string name);
	// 返回解析的非选项参数集合
	list<string> getnonoptionargs();
}

getoptionnames()：返回所有选项参数的名称
- 例如：参数是"--foo=bar --debug"，则返回["foo", "debug"]
getoptionvalues(string name)：返回与给定名称的选项参数关联的值集合
- 如果选项存在但没有值（例如："--foo"），返回一个空集合
- 如果选项存在且有单一值（例如："--foo=bar"），返回一个包含一个元素的集合["bar"]
- 如果选项存在且有多个值（例如："--foo=bar --foo=baz"），返回包含每个值的集合["bar", "baz"]
- 如果选项不存在，返回null
getnonoptionargs()：返回解析的非选项参数集合

4、实现类defaultapplicationarguments

代码很简单，对外暴露使用defaultapplicationarguments，内部实现都在source中

// 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);
		}
	}
}

三、source

source是defaultapplicationarguments解析参数内部的真正实现类，类图如下，逐一分析。

1、属性源propertysource

propertysource是spring框架中的一个核心抽象类，用于表示属性（键值对）的来源。通过将各种配置来源（如系统属性、环境变量、配置文件等）封装为propertysource对象，spring可以提供统一的接口来读取和管理这些配置数据。

属性源名称：每个propertysource实例都具有唯一的名称，用于区分不同的属性源
属性源对象：propertysource<t>是一个泛型类，其中t代表具体的属性源类型
getproperty(string name)：用于在属性源对象中检索具体的属性，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);
	...
}

2、枚举属性源enumerablepropertysource

enumerablepropertysource继承自propertysource，主要用于定义getpropertynames()方法，可以获取属性源对象中所有属性键的名称。

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();
}

3、命令行属性源commandlinepropertysource

commandlinepropertysource是spring框架中用于处理命令行参数的propertysource实现。它可以将应用程序启动时传入的命令行参数解析成键值对，便于在应用配置中使用。

命令行属性源名称默认为commandlineargs
getoptionvalues(string name)：通过命令行属性源（即选项参数键值对）的键获取对应的值
getnonoptionargs()：通过命令行属性源（即键默认为nonoptionargs的非选项参数键值对）获取对于的值
例：java -jar your-app.jar --server.port=8081 --spring.profiles.active=prod arg1 arg2
- 选项参数会有多个键值对，key1为server.port，key2为spring.profiles.active
- 非选项参数永远只有一个键值对，所有key都是nonoptionargs

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();
}

4、简单命令行属性源simplecommandlinepropertysource

simplecommandlinepropertysource是spring框架中的一个类，继承自commandlinepropertysource，用于解析和处理命令行参数。它设计为简单易用，通过接收一个字符串数组（即命令行参数 args），将参数分为"选项参数"和"非选项参数"两类。

命令行属性源对象类型为commandlineargs，通过new simplecommandlineargsparser().parse(args)获取

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();
	}
}

四、解析参数原理

在上一节中，我们了解了应用程序参数args被解析后的结构和存储方式。接下来，我们回到文章开头，详细解析参数是如何被逐步解析出来的。

// 3.解析应用参数
applicationarguments applicationarguments = new defaultapplicationarguments(args);

根据new defaultapplicationarguments(args)寻找解析arg的位置

解析完arg调用父类commandlinepropertysource的构造方法

1、解析方法

simplecommandlineargsparser通过遍历传入的命令行参数数组，根据参数的格式，将参数解析并分为选项参数和非选项参数。

选项参数解析规则
- 选项参数必须以--前缀开头，例如 --name=john 或 --debug
- 如果包含等号 =，= 左边的部分是选项名称，右边的部分是选项值
- 如果没有等号，则视为不带值的选项
- 如果获取不到选项名称（例如传入 --=value或–），抛出异常，表示参数格式无效
非选项参数解析规则
- 所有不以--开头的参数被视为非选项参数

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; // 返回解析结果
	}
}

属性源对象类型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);
	}
}

2、解析参数的存储和访问

解析方法很简单，所有内容都在simplecommandlineargsparser的parse方法中完成。相比之下，存储和访问方式更为复杂。

存储位置位于属性源对象propertysource中。从代码可知，args表示命令行参数，因此属性源名称为命令行属性源默认名称commandlineargs，属性源对象为解析args后的键值对。

访问查询方式的底层实现就是操作commandlineargs中的optionargs(选项参数)和nonoptionargs(非选项参数)两个集合，但此过程经过多次跳转，最终依次通过 defaultapplicationarguments -> defaultapplicationarguments#source -> simplecommandlinepropertysource -> commandlineargs获取，其中commandlineargs就是是命令行属性源对象。这种设计主要是为了提供更灵活、安全的访问方式，避免直接暴露内部数据结构带来的潜在风险。

3、实际应用

之前在springboot基础(二)：配置文件详解文章中有介绍过配置文件设置临时属性，这次回过头再来看，就很清晰明了了。

总结

在springboot启动时，启动类main函数中的args参数被解析为两类
- 选项参数（如 --server.port=8080）
- 非选项参数（如 arg1、arg2）
对外暴露应用参数对象applicationarguments提供查询方法
- getoptionvalues(string name)方法可以获取选项参数
- getnonoptionargs() 方法则用于获取非选项参数
- 这些参数在启动过程的后续阶段可供使用

到此这篇关于springboot源码解析(之如何解析应用参数args的文章就介绍到这了,更多相关springboot解析应用参数args内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

SpringBoot如何解析应用参数args

2024年11月20日 • Java •我要评论

前言