springboot run方法源码（二）-第四步环境准备

最新推荐文章于 2024-11-18 07:30:00 发布
原创 最新推荐文章于 2024-11-18 07:30:00 发布 · 319 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

深入解析SpringBoot启动过程中的环境准备步骤，包括参数解析、Profile激活及配置文件加载机制。

第四步 环境准备（与profile和application文件相关）

第四步主要对下面两行代码进行讲解：

//4. 创建DefaultApplicationArguments（该类含有args），然后调用prepareEnvironment()
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
1. DefaultApplicationArguments

首先是创建DefaultApplicationArguments，构造函数如下：

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

这里的args是命令行中传入的参数。重点实际上是第二行的Source类，接下来会对这个类进行详细介绍。

private static class Source extends SimpleCommandLinePropertySource {
	Source(String[] args) {
			super(args);
		}
}

可以看到，Source类的构造函数调用的是父类，因此看SimpleCommandLinePropertySource类的构造方法。

public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {
    public SimpleCommandLinePropertySource(String... args) {
        super((new SimpleCommandLineArgsParser()).parse(args));
    }
    ...
}

在对parse()进行讲解之前，需要先介绍CommandLineArgs类：

class CommandLineArgs {

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

可以看到，CommandLineArgs类含有一个名为optionArgs的HashMap和一个名为nonOptionArgs的list。
接下来看parse方法：

	public CommandLineArgs parse(String... args) {
		CommandLineArgs commandLineArgs = new CommandLineArgs();
		for (String arg : args) {
			//1. 参数中有"--"的，加到optionArgs中
			if (arg.startsWith("--")) {
				String optionText = arg.substring(2, arg.length());
				String optionName;
				String optionValue = null;
				if (optionText.contains("=")) {
					optionName = optionText.substring(0, optionText.indexOf("="));
					optionValue = optionText.substring(optionText.indexOf("=")+1, optionText.length());
				}
				else {
					optionName = optionText;
				}
				if (optionName.isEmpty() || (optionValue != null && optionValue.isEmpty())) {
					throw new IllegalArgumentException("Invalid argument syntax: " + arg);
				}
				commandLineArgs.addOptionArg(optionName, optionValue);
			}
			//2. 不含有“--”的加到nonOptionArgs中
			else {
				commandLineArgs.addNonOptionArg(arg);
			}
		}
		return commandLineArgs;
	}

上面的代码可以看到，如果arg中有"–"，则加到CommandLineArgs类的optionArgs中，没有的话加入到nonOptionArgs中。
假设我们在命令行传入参数“- -server.port=8081”，此时optionName=server.port，optionValue=8081。

2. prepareEnvironment
预备知识：

在阅读prepareEnvironment前，需要对environment以及PropertySource有清楚的认识，可以阅读我的另一篇博客：
spring 之 PropertySource和Environment：https://blog.youkuaiyun.com/bintoYu/article/details/104310068
在这里提炼一下博客的重要知识：

  1. PropertySource是spring体系用于存放key-value的property属性的基本单位，贯穿整个springboot的启动与初始化。
  2. 同时，需要知道这么一个概念：environment类中含有一个属性propertySources。
    这个类实际上是List<PropertySource<?>> propertySourceList，会存储所有的Property    ，后面会一直重复用到environment的propertySources属性：
	private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);
正式开始：

在applicationArguments被new出来后，接下来进入第二部分

ConfigurableEnvironment environment = prepareEnvironment(listeners,					applicationArguments);

	private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// 1. 获取或者创建Environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		// 2. 配置环境的信息
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		//3. 通知所有的观察者，环境已经配置好了
		listeners.environmentPrepared(environment);
		if (!this.webEnvironment) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertToStandardEnvironmentIfNecessary(environment);
		}
		return environment;
	}

首先是getOrCreateEnvironment()，该方法根据具体环境选择创建StandardServletEnvironment或StandardEnvironment：

	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		if (this.webEnvironment) {
			return new StandardServletEnvironment();
		}
		return new StandardEnvironment();
	}

因为我们一般都会使用web环境，所以这里讲StandardServletEnvironment，先讲它的父类的父类AbstractEnvironment。

public AbstractEnvironment() {
	private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);
	...
	customizePropertySources(this.propertySources);
	...
}

因为AbstractEnvironment的构造方法调用了customizePropertySources()方法，所以构造StandardServletEnvironment类时也会调用customizePropertySources()，下面是StandardServletEnvironment的代码：

public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {

    public StandardServletEnvironment() {
    }

	//构造该类时会调用customizePropertySources()
    protected void customizePropertySources(MutablePropertySources propertySources) {
    	//配置servletConfigInitParams
        propertySources.addLast(new StubPropertySource("servletConfigInitParams"));
        //配置servletContextInitParams
        propertySources.addLast(new StubPropertySource("servletContextInitParams"));
        //配置JNDI，这里会用到SpringProperties类，略
        if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
            propertySources.addLast(new JndiPropertySource("jndiProperties"));
        }

        super.customizePropertySources(propertySources);
    }

}

接着会调用父类StandardServletEnvironment的customizePropertySources()：

public class StandardEnvironment extends AbstractEnvironment {
	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(new MapPropertySource("systemProperties", getSystemProperties()));
		propertySources.addLast(new SystemEnvironmentPropertySource("systemEnvironment", getSystemEnvironment()));
	}
}

因此，新建StandardServletEnvironment相当于往内置的propertySources中添加4或5个property。
其中本文需要关注的是里面的“systemProperties”，从下图中可以看到，systemProperties中的source里，含有spring.profiles.active->dev的属性，也就是本文要找的profile。

接着我仔细对SystemProperties的获取方法进行查看：

	@Override
	@SuppressWarnings({"unchecked", "rawtypes"})
	public Map<String, Object> getSystemProperties() {
		try {
			return (Map) System.getProperties();
		}
		catch (AccessControlException ex) {
			...略
		}
	}

可以看到，SystemProperties是调用的System.getProperties()方法进行设置，因此个人猜测，当用户在application.properties中配置"spring.profiles.active"属性时，会自动加入到JAVA系统属性中（具体方式我没有找到）。

接着，开始调用configureEnvironment()配置环境的信息

	protected void configureEnvironment(ConfigurableEnvironment environment,
			String[] args) {
		//配置PropertySources，就是往propertySources追加再追加几个Property，不是很重要，略
		configurePropertySources(environment, args);
		//将profile配置到environment中
		configureProfiles(environment, args);
	}
	
	protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
		//1. 使用PropertySourcesPropertyResolver遍历内部所有的propertySources（上文已经添加过），
		//寻找key为"spring.profiles.active"的propertySources，并设置到activeProfiles
		environment.getActiveProfiles(); 
		//2. 创建profiles，添加profile到profiles中，并设置到environment里
		Set<String> profiles = new LinkedHashSet<String>(this.additionalProfiles);
		profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
		environment.setActiveProfiles(profiles.toArray(new String[profiles.size()]));
	}

首先，先调用getActiveProfiles()方法：

Class AbstractEnvironment：
	@Override
	public String[] getActiveProfiles() {
		return StringUtils.toStringArray(doGetActiveProfiles());
	}
	
	protected Set<String> doGetActiveProfiles() {
		synchronized (this.activeProfiles) {
			if (this.activeProfiles.isEmpty()) {
				//寻找key为"spring.profiles.active"的propertySources，
				String profiles = getProperty("spring.profiles.active");
				if (StringUtils.hasText(profiles)) {
					//设置profiles到activeProfiles中，并返回
					setActiveProfiles(StringUtils.commaDelimitedListToStringArray(
							StringUtils.trimAllWhitespace(profiles)));
				}
			}
			return this.activeProfiles;
		}
	}

先看getProperty()

	@Override
	public String getProperty(String key) {
		return this.propertyResolver.getProperty(key);
	}
	
public class PropertySourcesPropertyResolver{
	@Override
	public String getProperty(String key) {
		return getProperty(key, String.class, true);
	}

	protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
		if (this.propertySources != null) {
			//使用PropertySourcesPropertyResolver遍历内部所有的propertySources（上文已经添加过），
			//寻找key为"spring.profiles.active"的propertySources，
			//而SystemProperties中含有spring.profiles.active极其对应value:dev，因此可以找到。
			for (PropertySource<?> propertySource : this.propertySources) {
				if (logger.isTraceEnabled()) {
					logger.trace("Searching for key '" + key + "' in PropertySource '" +
							propertySource.getName() + "'");
				}
				Object value = propertySource.getProperty(key);
				if (value != null) {
					if (resolveNestedPlaceholders && value instanceof String) {
						value = resolveNestedPlaceholders((String) value);
					}
					logKeyFound(key, propertySource, value);
					return convertValueIfNecessary(value, targetValueType);
				}
			}
		}

		return null;
	}
}
3. 通知所有的观察者

将profile配置到environment后，就会通知所有的观察者，环境已经配置好了。

//3. 通知所有的观察者，环境已经配置好了
listeners.environmentPrepared(environment);

	public void environmentPrepared(ConfigurableEnvironment environment) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.environmentPrepared(environment);
		}
	}
	
	@Override
	public void environmentPrepared(ConfigurableEnvironment environment) {
		//使用multicastEvent方法通知ApplicationEnvironmentPreparedEvent对应的listeners，最终会调用listeners的onApplicationEvent(event)方法
		this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
				this.application, this.args, environment));
	}

通知监听者会调用multicastEvent()方法，该方法在第三大步的时候已经具体介绍过，这里不重复介绍。而该方法的功能是：通知ApplicationEnvironmentPreparedEvent对应的listeners，listeners最终会调用onApplicationEvent(event)方法。
这里面的listeners中，有一个很重要的listner：ConfigFileApplicationListener（如下图），因此接下来将对该类进行详细讲解。

4. ConfigFileApplicationListener
public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
	...
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		//此时还处于环境准备阶段，因此会进入这个分支
		if (event instanceof ApplicationEnvironmentPreparedEvent) {
			onApplicationEnvironmentPreparedEvent(
					(ApplicationEnvironmentPreparedEvent) event);
		}
		if (event instanceof ApplicationPreparedEvent) {
			onApplicationPreparedEvent(event);
		}
	}

	private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
		//1. 获得几个EnvironmentPostProcessor
		List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
		//2. 将ConfigFileApplicationListener自身也加入到其中
		postProcessors.add(this);
		//3. 排序
		AnnotationAwareOrderComparator.sort(postProcessors);
		//4. 每个处理器都会调用postProcessEnvironment()方法。
		for (EnvironmentPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessEnvironment(event.getEnvironment(),
					event.getSpringApplication());
		}
	}
	...
}

2、3、4都不需要详细介绍，只需要介绍第1步获取几个环境后置处理器：

	List<EnvironmentPostProcessor> loadPostProcessors() {
		//loadFactories()最早就提到过，用于解析spring.properties文件并获取对应类
		return SpringFactoriesLoader.loadFactories(EnvironmentPostProcessor.class,
				getClass().getClassLoader());
	}

spring.properties片段：

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor

可以看到，这里会获得两个环境后置处理器，但这两个类并不重要，所以接下来只介绍ConfigFileApplicationListener自身的postProcessEnvironment()方法。

	@Override
	public void postProcessEnvironment(ConfigurableEnvironment environment,
			SpringApplication application) {
		//1. 很重要，用于解析配置文件（例如application.properties）并添加到environment中
		addPropertySources(environment, application.getResourceLoader());
		//2. 不重要，略
		configureIgnoreBeanInfo(environment);
		//3.将environment的属性绑定到SpringApplication中，因篇幅关系，不进行详细介绍。
		bindToSpringApplication(environment, application);
	}

	protected void addPropertySources(ConfigurableEnvironment environment,
			ResourceLoader resourceLoader) {
		//往environment的propertySources中添加random的property，不重要
		RandomValuePropertySource.addToEnvironment(environment);
		new Loader(environment, resourceLoader).load();
	}

接着进入Loader类的load方法：

内置类Loader.class（非常重要！涉及到application.properties的解析）：
public void load() {
			this.propertiesLoader = new PropertySourcesLoader();
			this.activatedProfiles = false;
			this.profiles = Collections.asLifoQueue(new LinkedList<Profile>());
			this.processedProfiles = new LinkedList<Profile>();

			//1. 具体功能不需要关注，只需要知道这一步之后，this.profiles含有两个属性：null和dev(因为我前面设置的是dev)
			Set<Profile> initialActiveProfiles = initializeActiveProfiles();
			this.profiles.addAll(getUnprocessedActiveProfiles(initialActiveProfiles));
			//这个分支不会进入，略
			if (this.profiles.isEmpty()) {
				for (String defaultProfileName : this.environment.getDefaultProfiles()) {
					Profile defaultProfile = new Profile(defaultProfileName, true);
					if (!this.profiles.contains(defaultProfile)) {
						this.profiles.add(defaultProfile);
					}
				}
			}


			this.profiles.add(null);

			while (!this.profiles.isEmpty()) {
				Profile profile = this.profiles.poll();
					//2. 遍历"classpath:/,classpath:/config/,file:./,file:./config/"; 这几个位置
				for (String location : getSearchLocations()) {
					//这个分支不会走
					if (!location.endsWith("/")) {
						load(location, null, profile);
					}
					else {
						//3.  getSearchNames()在没有配置的情况下，默认会得到"application"
						for (String name : getSearchNames()) {
							//4.解析
							load(location, name, profile);
						}
					}
				}
				this.processedProfiles.add(profile);
			}
			//5. 将this.propertiesLoader中的propertySources取出来，并存到environment.propertySources中
			addConfigurationProperties(this.propertiesLoader.getPropertySources());
		}

在上面的load()方法中，profiles分别包含了null和dev，而location有"classpath:/",“classpath:/config/”,“file:./”,"file:./config/"四种情况，接下来就是对name-profile和location两两组合调用load(location,name, profile);方法，同时,默认情况下name=“application”。
注：

  1. 因为profiles中的顺序是先null再dev，所以会先调用application.properties再调用application-dev.properties
  2. 上面四个路径下都存在application.properties时，后面会覆盖前面的，因此优先级实际上是反着来的，即：
    – file:./config/
    – file:./
    – classpath:/config/
    – classpath:/
	private PropertySourcesLoader propertiesLoader;
		
	private void load(String location, String name, Profile profile) {
		//1. group = （profile=null）或者（profile=dev）
		String group = "profile=" + (profile == null ? "" : profile);
		//这个分支不会走
		if (!StringUtils.hasText(name)) {
			loadIntoGroup(group, location, profile);
		}
		else {
			// 2. 获得扩展名，下面会细说，一共有"properties","xml","yml"和“yaml”四种后缀
			for (String ext : this.propertiesLoader.getAllFileExtensions()) {
				if (profile != null) {
					// Try the profile-specific file
					loadIntoGroup(group, location + name + "-" + profile + "." + ext,null);
					for (Profile processedProfile : this.processedProfiles) {
						if (processedProfile != null) {
							loadIntoGroup(group, location + name + "-"
									+ processedProfile + "." + ext, profile);
						}
					}
					//4.这里就是解析application-dev.properties的出处！！！！
					loadIntoGroup(group, location + name + "-" + profile + "." + ext,profile);
				}
				//3. 解析profile为空的时候(例如application.properties！！！！！)
				loadIntoGroup(group, location + name + "." + ext, profile);
				}
			}
		}

可以看到，上面的load方法中，主要有两部分，一个getAllFileExtensions()获得扩展名，另一个是loadIntoGroup(…)进行解析。
先对扩展名进行讲解：
class PropertySourcesLoader：

	public Set<String> getAllFileExtensions() {
		Set<String> fileExtensions = new LinkedHashSet<String>();
		//从loaders从取出PropertySourceLoader，再取出里面的扩展名
		for (PropertySourceLoader loader : this.loaders) {
			fileExtensions.addAll(Arrays.asList(loader.getFileExtensions()));
		}
		return fileExtensions;
	}

this.loaders含有下图的两个PropertySourceLoader，其中PropertiesPropertySourceLoader含有后缀名 { “properties”, “xml” }，
而YamlPropertySourceLoader含有后缀名{“yml”,“yaml”}

接着讲loadIntoGroup()方法：

	private PropertySource<?> loadIntoGroup(String identifier, String location,Profile profile) {
		try {
			return doLoadIntoGroup(identifier, location, profile);
		}
		...
	}

	private PropertySource<?> doLoadIntoGroup(String identifier, String location,
				Profile profile) throws IOException {
			//1. 将location中的文件封装成Resource类，注：这里的resourceLoader是DefaultResourceLoader
			Resource resource = this.resourceLoader.getResource(location);
			PropertySource<?> propertySource = null;
			StringBuilder msg = new StringBuilder();
			if (resource != null && resource.exists()) {
				String name = "applicationConfig: [" + location + "]";
				String group = "applicationConfig: [" + identifier + "]";
				//2. 关键代码：将resource解析为property
				propertySource = this.propertiesLoader.load(resource, group, name,
				...忽略部分代码
			return propertySource;
		}

首先第一步getResource()方法会将location所在的所有文件转化成Resource 接口，Resource接口是spring用来满足各种底层的资源访问需求的接口。本文不对其进行展开叙述，感兴趣的同学可以阅读：Spring Resource接口进行资源访问

而l第二步this.propertiesLoader.load(…)方法非常重要，该方法会将Resource接口解析成PropertySource类，同时添加到this.propertySources中。

	public PropertySource<?> load(Resource resource, String group, String name,
			String profile) throws IOException {
		if (isFile(resource)) {
			String sourceName = generatePropertySourceName(name, profile);
			for (PropertySourceLoader loader : this.loaders) {
				if (canLoadFileExtension(loader, resource)) {
					//1.遍历所有PropertySourceLoader然后调用loader解析
					PropertySource<?> specific = loader.load(sourceName, resource,
							profile);
					//2. 将解析好的结果添加到this.propertySources中
					addPropertySource(group, specific, profile);
					return specific;
				}
			}
		}
		return null;
	}

对于PropertySourceLoader，我们以.properties的解析器PropertiesPropertySourceLoader为例进行讲解：

public class PropertiesPropertySourceLoader implements PropertySourceLoader {

	@Override
	public String[] getFileExtensions() {
		return new String[] { "properties", "xml" };
	}

	@Override
	public PropertySource<?> load(String name, Resource resource, String profile)
			throws IOException {
		if (profile == null) {
			Properties properties = PropertiesLoaderUtils.loadProperties(resource);
			if (!properties.isEmpty()) {
				return new PropertiesPropertySource(name, properties);
			}
		}
		return null;
	}

}

可以看到，load()方法实际上调用PropertiesLoaderUtils.loadProperties(resource);

	public static Properties loadProperties(Resource resource) throws IOException {
		Properties props = new Properties();
		fillProperties(props, resource);
		return props;
	}
	
	public static void fillProperties(Properties props, Resource resource) throws IOException {
		InputStream is = resource.getInputStream();
		try {
			String filename = resource.getFilename();
			if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) {
				props.loadFromXML(is);
			}
			else {
				props.load(is);
			}
		}
		finally {
			is.close();
		}
	}

Properties是java.util的一个通用类，用于解析properties或xml文件。在这里便不具体介绍了。
这样，application.properties文件就被解析成Properties类，然后再将Properties类封装到PropertiesPropertySource类中。
而yml和yaml的解析器YamlPropertySourceLoader对文件的解析也大同小异，它按照文件特定的格式一步一步解析成key和value，然后存放到Map<String, Object> source中，最后将map封装到PropertiesPropertySource类中

这样，解析过程就结束了，最后还要将解析好的结果存放到environment中

		//5. 将this.propertiesLoader中的propertySources取出来，并存到environment.propertySources中
		addConfigurationProperties(this.propertiesLoader.getPropertySources());

该方法一直往下走，会到下面的代码中：

		private void addConfigurationProperties(
				ConfigurationPropertySources configurationSources) {
			//1.获取environment.propertySources
			MutablePropertySources existingSources = this.environment
					.getPropertySources();
			//2.存放
			if (existingSources.contains(DEFAULT_PROPERTIES)) {
				existingSources.addBefore(DEFAULT_PROPERTIES, configurationSources);
			}
			else {
				existingSources.addLast(configurationSources);
			}
		}

这样，Loader类的load()方法就走完了，现在总结一下该方法的流程：
在这里插入图片描述

最后还有bindToSpringApplication(environment, application);将environment的属性绑定到SpringApplication中，因篇幅关系，不进行详细介绍。

最后配置文件大致以这种形式存放到environment中：

this.environment
		.propertySources
			.propertySourceList[5]    ->ConfigurationPropertySources {name='applicationConfigurationProperties'}
				.source[0]			  ->PropertySources {name='applicationConfig: [profile=dev]'}
					.source[0]		  ->PropertySource
						.source		  ->Property：存放配置文件的key和value
				.source[1]			  ->PropertySources {name='applicationConfig: [profile=]'}
					.source[0]		  ->PropertySource
						.source		  ->Property：存放配置文件的key和value

在这里插入图片描述

运行源码分析：初始化ApplicationArguments
m0_63437643的博客
02-24 566
初始化ApplicationArguments 监 听 器 启 动 之 后 ， 紧接着便是执行ApplicationArguments对象的初始化 ，Application-Arguments 是用于提供访问运行 SpringApplication 时的参数。 ApplicationArguments 的 初 始 化 过 程 非 常 简 单 ， 只 是 调 用 了 它 的 实 现 类 Default-ApplicationArguments 并传入 main 方法中的 args 参数。 Appl.
死磕源码系列【springboot应用参数ApplicationArguments详解】
OceanSky的专栏
10-13 2545
ApplicationArguments接口提供对用于运行org.springframework.boot.SpringApplication的参数访问，此接口只有一个实现类DefaultApplicationArguments。 如下示例(获取应用程序的args参数)： @SpringBootApplication public class QuartzBootStrap { public static void main(String[] args) { SpringAppl.
深入SpringBoot源码（四）初识Environment
现阶段围绕Java展开
04-15 3418
new DefaultApplicationArguments
springboot加载命令行参数ApplicationArguments
理想万岁万万岁的博客
04-12 1944
使用springboot开发的同学们，都一定会从配置文件中读取配置。比如我们常常会在上传文件的功能中，把文件的保存路径写在配置文件中，然后在代码中通过@Value()注解从配置文件读取对应的配置，如下所示：在配置文件中定义文件路径在代码中获取保存路径// 文件路径/data/files public void upload(File file) {// 将文件保存到fileLocation中。} }这种读取配置的方式非常方便，但是有一个让人抓狂的缺点在多人协作开发的情况下，同事A在配置文件中修改。
【Spring Boot 源码学习】深入 ApplicationArguments 接口及其默认实现
Huazie
05-10 1421
本篇博文 Huazie 同大家一起深入分析 ApplicationArguments 接口及其默认实现，相信这些可以进一步加深大家对于 Spring Boot 启动运行阶段中命令参数获取和使用的理解。
SpringBoot运行流程源码分析------阶段二（run方法核心流程）
qq_41934990的博客
08-07 735
在上面的代码中，实例化监听器需要有一个默认的构造方法，且构造方法的参数为Class
SpringBoot运行流程源码分析------阶段三（Spring Boot外化配置源码解析）
qq_41934990的博客
10-24 906
首先看一下ApplicationArguments接口的具体方法定义及功能介绍。//返回原始未处理的参数（通过application传入的） String [ ] getSourceArgs();//返回所有参数的集合，如参数为：--foo=bar --debug,则返回【"foo","debug"】 Set < String > getOptionNames();//选项参数中是否包含指定名称的参数 boolean containsOption(String name);
SpringBoot集成Swagger-Bootstrap-UI
Java
01-12 3171
SpringBoot集成Swagger-Bootstrap-UI
SpringBoot源码解析1------SpringBoot自动判断项目是否是Web项目
qinsezaiyu0519的博客
06-10 1918
一、运行环境 SpringBoot版本： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.0.RELEASE</version> <relativePath/>
SpringBoot运行流程源码分析：run方法流程及监听器
m0_63437643的博客
02-24 621
SpringBoot运行流程源码分析 上一章中我们分析了 SpringApplication 类实例化的源代码，在此过程中完成了基本配置文件的加载和实例化。当 SpringApplication 对象被创建之后， 通过调用其 run 方法来进行SpringBoot 的启动和运行，至此正式开启了 SpringApplication 的生命周期。 本章介绍的内容同样是 Spring Boot 运行的核心流程之一，我们将会围绕 SpringApplicationRunListeners、ApplicationA
Springboot启动流程(三):environment
wishl_gmy的博客
01-21 1571
Springboot启动流程(三) 之前我们研究了springboot启动流程中的listener的运行流程,接下来就该是各种环境的出事话包括environment和context这两个非常重要的spring环境 首先还是run方法的代码: run方法代码如下: public ConfigurableApplicationContext run(String... args) {     // l...
窥探-spring boot应用参数ApplciationArguments
HQ DevJ的专栏
08-11 438
窥探-spring boot应用参数ApplciationArguments简单使用探索ApplciationArgumentsDefaultApplicationArguments实现类CommandLineArgs类 在进行springboot开发的时候，我们启动的时候会使用run方法,代码如下： public static void main(String ... args){ SpringApplication springApplication = new SpringApplicati
SpringBoot（九）启动流程分析之命令行参数args的封装解析
yhahaha_的博客
03-29 4061
SpringBoot版本：2.1.1 ==》启动流程分析汇总 接上篇博客Spring Boot 2.1.1（八）启动流程分析之ApplicationStartingEvent事件的发布监听流程 目录 流程分析 1、DefaultApplicationArguments构造方法 2、参数解析 3、测试验证 流程分析 发布ApplicationStartingEvent后就是封...
SpringBoot源码解析(四)：解析应用参数args
最新发布
从基础到源码解析的学习记录
11-18 4196
前文深入解析了SpringBoot启动的开始阶段，包括获取和启动应用启动监听器、事件与广播机制，以及如何通过匹配监听器实现启动过程各阶段的自定义逻辑。接下来，我们将探讨SpringBoot启动类main函数中的参数args的作用及其解析过程。SpringBoot版本2.7.18SpringApplication的run方法的执行逻辑如下，本文将详细介绍第3小节：解析应用参数// SpringApplication类方法// 记录应用启动的开始时间。
springboot启动源码解析（四）：初始化默认应用参数、准备启动环境
jzh的博客
02-17 3143
此章节主要对springboot启动过程中，发生的【初始化应用参数】、【准备启动环境】、【配置需要忽略的Bean】、【打印Banner】进行源码解析，对应的代码如图1所示： 图1： // 初始化应用参数 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // 准备启动环境 ConfigurableEnvironment environment = prepareEnvironment(l
SpringBoot外化配置源码解析：外化配置简介、参数处理
m0_63437643的博客
02-23 370
SpringBoot外化配置源码解析 在前面章节我们讲解了 Spring Boot 的运作核心原理及启动过程中进行的一系列核心操作。 从本章开始，我们将针对在实践过程中应用的不同知识点的源代码进行解读和分析，内容上可能会与之前章节有所重叠，但这些重叠的内容更有助于我们在实践和应用中形成前后呼应，加深记忆学习效果。 本章将重点讲解 Spring Boot 外化配置文件相关内容，核心包括:外化配置文件、命令行参数、Profile 实现机制及 整个加载处理业务逻辑。 外化配置简介 Spring
springboot2.1.7启动分析（二）SpringApplication run
sinat_33472737的博客
01-18 445
SpringApplicationRunListeners listeners = getRunListeners(args); private SpringApplicationRunListeners getRunListeners(String[] args) { Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class }; return new SpringApp..
SpringBoot2源码分析5-environment环境初始化
weixin_43159039的博客
08-26 9519
环境初始化 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments); configureIgnoreBeanInfo(environment); 第一行就是存SpringApplica
【SpringBoot 一】SpringApplication启动类的Args详解
热门推荐
石臻说AI(szzdzhp001) 【原名 石臻臻的杂货铺】
08-18 2万+
Args 作用 传递参数的一种方式; 例如启动的时候 java -jar --spring.profiles.active=prod 或者更改自己的自定义配置信息 ;使用方式是 --key=value 它的信息优先于项目里面的配置; 我们现在大部分项目都是用SpringBoot进行开发的,一般启动类的格式是 SpringApplication.run(SpringBootDemoPropertiesApplication.class, args); 但是好像平常一直也没有用到args; 也没有穿过参数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值