springBoot配置文件加载原理探究

ゝ一纸荒年。 2022-06-06 00:10 265阅读 0赞

尽管用springBoot做开发已经有很长一段时间了，在开发时一般都是直接将application.properties或application.yml，放在开发环境的resources下的，运行起来感觉也没什么问题。

但是由于项目最终都是要通过打包，最终打包为一个jar包运行的。但如果一个项目由于环境不同需要对配置文件修改时，直接将在IDE中修改配置文件再重新打成一个JAR包很耗费时间。

最终通过搜索，得到一个理想的配置文件设置方式。可以在打好的将要运行的springBoot的jar包同级目录下放置上配置文件，或在其同级目录下新建一个config目录，将配置文件放在config目录中就可以了。试了一下，确实可以，感觉挺高级的，非常棒！

对于一向充满好奇心的我来说，对于springBoot它能这样做的原理充满了兴趣，决定通过ide的debug跟踪下源码。

软件环境：  
springBoot版本：1.5.4.RELEASE

## springBoot初始化listenner ##

从SpringApplication.run()方法开始打debug开始跟踪  
run方法会调用到这里：

/** * Static helper that can be used to run a {@link SpringApplication} from the * specified sources using default settings and user supplied arguments. * @param sources the sources to load * @param args the application arguments (usually passed from a Java main method) * @return the running {@link ApplicationContext} */
        public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
            return new SpringApplication(sources).run(args);
        }

new SpringApplication(sources)方法中有调用initialize(sources)这个初始化方法  
其initialize方法代码为：

@SuppressWarnings({ "unchecked", "rawtypes" })
        private void initialize(Object[] sources) {
            if (sources != null && sources.length > 0) {
                this.sources.addAll(Arrays.asList(sources));
            }
            this.webEnvironment = deduceWebEnvironment();
            setInitializers((Collection) getSpringFactoriesInstances(
                    ApplicationContextInitializer.class));
            setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
            this.mainApplicationClass = deduceMainApplicationClass();
        }

其中重点关注此方法：setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class))  
在这个方法中，会初始化一些监听器，主要看下这个方法  
它会调用此方法：

在此方法中会通过SpringFactoriesLoader.loadFactoryNames方法获得出一串names的集合，然后再通过createSpringFactoriesInstances方法将names实例化出来

其SpringFactoriesLoader.loadFactoryNames方法为：

/**
         * Load the fully qualified class names of factory implementations of the
         * given type from {
       @value #FACTORIES_RESOURCE_LOCATION}, using the given
         * class loader.
         * @param factoryClass the interface or abstract class representing the factory
         * @param classLoader the ClassLoader to use for loading resources; can be
         * {
       @code null} to use the default
         * @see #loadFactories
         * @throws IllegalArgumentException if an error occurs while loading factory names
         */
        public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
            String factoryClassName = factoryClass.getName();
            try {
                Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                        ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
                List<String> result = new ArrayList<String>();
                while (urls.hasMoreElements()) {
                    URL url = urls.nextElement();
                    Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                    String factoryClassNames = properties.getProperty(factoryClassName);
                    result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
                }
                return result;
            }
            catch (IOException ex) {
                throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                        "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
            }
        }

其中此条语句：

Enumeration<URL> urls=(classLoader!=null?classLoader.getResources(FACTORIES_RESOURCE_LOCATION):ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));

会通过classLoader在jar内获取出FACTORIES\_RESOURCE\_LOCATION的资源。  
其FACTORIES\_RESOURCE\_LOCATION的值可以通过源码找到这句

/** * The location to look for factories. * <p>Can be present in multiple JAR files. */
        public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

那么也就是springBoot在初始化的时候会加载所有依赖包的META-INF/spring.factories文件  
为此，为了验证都能获取出哪些具体的spring.factories配置文件，我在这个springBoot项目的测试类中写了方法

public static void main(String[] args) {
            IndexServiceApplicationTests indexServiceApplicationTests = new IndexServiceApplicationTests();
            try {
                Enumeration<URL> urls = indexServiceApplicationTests.getClass().getClassLoader().getResources("META-INF/spring.factories");
                System.out.println("urls:" + urls);
                while(urls.hasMoreElements()){
                    URL url = urls.nextElement();
                    System.out.println("urlItem:"+url);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

其输出结果为：

urls:sun.misc.CompoundEnumeration@f2a0b8e
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/cloud/spring-cloud-context/1.2.2.RELEASE/spring-cloud-context-1.2.2.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/cloud/spring-cloud-commons/1.2.2.RELEASE/spring-cloud-commons-1.2.2.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/cloud/spring-cloud-netflix-eureka-server/1.3.1.RELEASE/spring-cloud-netflix-eureka-server-1.3.1.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/cloud/spring-cloud-netflix-core/1.3.1.RELEASE/spring-cloud-netflix-core-1.3.1.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/cloud/spring-cloud-netflix-eureka-client/1.3.1.RELEASE/spring-cloud-netflix-eureka-client-1.3.1.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/boot/spring-boot-test/1.5.4.RELEASE/spring-boot-test-1.5.4.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/boot/spring-boot/1.5.4.RELEASE/spring-boot-1.5.4.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/boot/spring-boot-test-autoconfigure/1.5.4.RELEASE/spring-boot-test-autoconfigure-1.5.4.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/boot/spring-boot-autoconfigure/1.5.4.RELEASE/spring-boot-autoconfigure-1.5.4.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/spring-test/4.3.9.RELEASE/spring-test-4.3.9.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/spring-beans/4.3.9.RELEASE/spring-beans-4.3.9.RELEASE.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/commons-logging/commons-logging/1.1.1/commons-logging-1.1.1.jar!/META-INF/spring.factories
    urlItem:jar:file:/D:/program%20files/maven_repo/org/springframework/boot/spring-boot-actuator/1.5.4.RELEASE/spring-boot-actuator-1.5.4.RELEASE.jar!/META-INF/spring.factories

其中前面的**/D:/program%20files/maven\_repo**字段为我电脑本地maven仓库的路径  
关注下这条输出记录：  
**urlItem:jar:file:/D:/program%20files/maven\_repo/org/springframework/boot/spring-boot/1.5.4.RELEASE/spring-boot-1.5.4.RELEASE.jar!/META-INF/spring.factories**  
这个路径为springboot这个jar包下的spring.facotires文件  
随后，代码又执行了如下语句：

Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
    String factoryClassNames = properties.getProperty(factoryClassName);
    result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));

先把此配置文件加载为properties，再获取出变量factoryClassName属性的值。通过debug或通过入参可以获取到factoryClassName为ApplicationListener.class这个类的名称,即**org.springframework.context.ApplicationListener**  
获得了以上信息后，我们便可以打开对应的JAR包，找到对应的配置文件下的org.springframework.context.ApplicationListener键，查看都有哪些值（spring-boot-1.5.4.RELEASE.jar!/META-INF/spring.factories中的org.springframework.context.ApplicationListener的值）  
通过打开JAR包，在此配置文件中发现了如下内容

# Application Listeners
    org.springframework.context.ApplicationListener=\
    org.springframework.boot.ClearCachesApplicationListener,\
    org.springframework.boot.builder.ParentContextCloserApplicationListener,\
    org.springframework.boot.context.FileEncodingApplicationListener,\
    org.springframework.boot.context.config.AnsiOutputApplicationListener,\
    org.springframework.boot.context.config.ConfigFileApplicationListener,\
    org.springframework.boot.context.config.DelegatingApplicationListener,\
    org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener,\
    org.springframework.boot.logging.ClasspathLoggingApplicationListener,\
    org.springframework.boot.logging.LoggingApplicationListener

上面的代码result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)))就将这些listener添加进了result集合中,最终返回给了它上一级的调用方法names

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type,
                Class<?>[] parameterTypes, Object... args) {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            // Use names and ensure unique to protect against duplicates
            Set<String> names = new LinkedHashSet<String>(
                    SpringFactoriesLoader.loadFactoryNames(type, classLoader));
            List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                    classLoader, args, names);
            AnnotationAwareOrderComparator.sort(instances);
            return instances;
        }
    
        @SuppressWarnings("unchecked")
        private <T> List<T> createSpringFactoriesInstances(Class<T> type,
                Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,
                Set<String> names) {
            List<T> instances = new ArrayList<T>(names.size());
            for (String name : names) {
                try {
                    Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                    Assert.isAssignable(type, instanceClass);
                    Constructor<?> constructor = instanceClass
                            .getDeclaredConstructor(parameterTypes);
                    T instance = (T) BeanUtils.instantiateClass(constructor, args);
                    instances.add(instance);
                }
                catch (Throwable ex) {
                    throw new IllegalArgumentException(
                            "Cannot instantiate " + type + " : " + name, ex);
                }
            }
            return instances;
        }

从代码可以看出，上面的代码将获取出来的listener全通过反射进行了实例化,最终回到了初始化方法，通过setListeners设置到了SpringApplication的类中

/** * Sets the {@link ApplicationListener}s that will be applied to the SpringApplication * and registered with the {@link ApplicationContext}. * @param listeners the listeners to set */
        public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
            this.listeners = new ArrayList<ApplicationListener<?>>();
            this.listeners.addAll(listeners);
        }

## ConfigFileApplicationListener执行过程 ##

通过上面，可以得知在springApplication初始化的时候会加载ConfigFileApplicationListener这个类，那么它是在什么时候调用了这个类呢?仍然是通过源码，探究Application的run方法

/** * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * @param args the application arguments (usually passed from a Java main method) * @return a running {@link ApplicationContext} */
        public ConfigurableApplicationContext run(String... args) {
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
            ConfigurableApplicationContext context = null;
            FailureAnalyzers analyzers = null;
            configureHeadlessProperty();
            SpringApplicationRunListeners listeners = getRunListeners(args);
            listeners.starting();
            try {
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                        args);
                ConfigurableEnvironment environment = prepareEnvironment(listeners,
                        applicationArguments);
                Banner printedBanner = printBanner(environment);
                context = createApplicationContext();
                analyzers = new FailureAnalyzers(context);
                prepareContext(context, environment, listeners, applicationArguments,
                        printedBanner);
                refreshContext(context);
                afterRefresh(context, applicationArguments);
                listeners.finished(context, null);
                stopWatch.stop();
                if (this.logStartupInfo) {
                    new StartupInfoLogger(this.mainApplicationClass)
                            .logStarted(getApplicationLog(), stopWatch);
                }
                return context;
            }
            catch (Throwable ex) {
                handleRunFailure(context, listeners, analyzers, ex);
                throw new IllegalStateException(ex);
            }
        }

其中有如下两行代码：

SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting();

starting方法的代码为：

public void starting() {
            for (SpringApplicationRunListener listener : this.listeners) {
                listener.starting();
            }
        }

通过代码可知stating方法就是通过遍历listeners，来依次触发listener的starting方法。最终会执行到这里：

public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
            ResolvableType type = eventType != null ? eventType : this.resolveDefaultEventType(event);
            Iterator var4 = this.getApplicationListeners(event, type).iterator();
    
            while(var4.hasNext()) {
                final ApplicationListener<?> listener = (ApplicationListener)var4.next();
                Executor executor = this.getTaskExecutor();
                if (executor != null) {
                    executor.execute(new Runnable() {
                        public void run() {
                            SimpleApplicationEventMulticaster.this.invokeListener(listener, event);
                        }
                    });
                } else {
                    this.invokeListener(listener, event);
                }
            }
    
        }

上面的this.getApplicationListeners(event, type)会获得由上文初始化的那10多个集合，然后再通过迭代器进行遍历listener。每遍历到一个listener，就从线程器中开启一个线程，去执行这个listener

protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
            ErrorHandler errorHandler = this.getErrorHandler();
            if (errorHandler != null) {
                try {
                    listener.onApplicationEvent(event);
                } catch (Throwable var7) {
                    errorHandler.handleError(var7);
                }
            } else {
                try {
                    listener.onApplicationEvent(event);
                } catch (ClassCastException var8) {
                    String msg = var8.getMessage();
                    if (msg != null && !msg.startsWith(event.getClass().getName())) {
                        throw var8;
                    }
    
                    Log logger = LogFactory.getLog(this.getClass());
                    if (logger.isDebugEnabled()) {
                        logger.debug("Non-matching event type for listener: " + listener, var8);
                    }
                }
            }
    
        }
    }

最终都会触发listener的onApplicationEvent方法。  
这里只跟踪下ConfigFileApplicationListener这个监听器。  
当触发到ConfigFileApplicationListener的onApplicationEvent时，会执行如下的代码

public void onApplicationEvent(ApplicationEvent event) {
            if (event instanceof ApplicationEnvironmentPreparedEvent) {
                onApplicationEnvironmentPreparedEvent(
                        (ApplicationEnvironmentPreparedEvent) event);
            }
            if (event instanceof ApplicationPreparedEvent) {
                onApplicationPreparedEvent(event);
            }
        }

由debu跟踪，会发现初始化时运行的是onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event)这个方法  
随后进入：

private void onApplicationEnvironmentPreparedEvent(
                ApplicationEnvironmentPreparedEvent event) {
            List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
            postProcessors.add(this);
            AnnotationAwareOrderComparator.sort(postProcessors);
            for (EnvironmentPostProcessor postProcessor : postProcessors) {
                postProcessor.postProcessEnvironment(event.getEnvironment(),
                        event.getSpringApplication());
            }
        }

postProcessor.postProcessEnvironment(event.getEnvironment(),  
event.getSpringApplication()方法为：

@Override
        public void postProcessEnvironment(ConfigurableEnvironment environment,
                SpringApplication application) {
            addPropertySources(environment, application.getResourceLoader());
            configureIgnoreBeanInfo(environment);
            bindToSpringApplication(environment, application);
        }

在addPropertySources方法中，发现了如下关键代码：

/** * Add config file property sources to the specified environment. * @param environment the environment to add source to * @param resourceLoader the resource loader * @see #addPostProcessors(ConfigurableApplicationContext) */
        protected void addPropertySources(ConfigurableEnvironment environment,
                ResourceLoader resourceLoader) {
            RandomValuePropertySource.addToEnvironment(environment);
            new Loader(environment, resourceLoader).load();
        }

后面的new Loader(environment,resourceLoader).load()方法代码为：

public void load() {
                this.propertiesLoader = new PropertySourcesLoader();
                this.activatedProfiles = false;
                this.profiles = Collections.asLifoQueue(new LinkedList<Profile>());
                this.processedProfiles = new LinkedList<Profile>();
    
                // Pre-existing active profiles set via Environment.setActiveProfiles()
                // are additional profiles and config files are allowed to add more if
                // they want to, so don't call addActiveProfiles() here.
                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);
                        }
                    }
                }
    
                // The default profile for these purposes is represented as null. We add it
                // last so that it is first out of the queue (active profiles will then
                // override any settings in the defaults when the list is reversed later).
                this.profiles.add(null);
    
                while (!this.profiles.isEmpty()) {
                    Profile profile = this.profiles.poll();
                    for (String location : getSearchLocations()) {
                        if (!location.endsWith("/")) {
                            // location is a filename already, so don't search for more
                            // filenames
                            load(location, null, profile);
                        }
                        else {
                            for (String name : getSearchNames()) {
                                load(location, name, profile);
                            }
                        }
                    }
                    this.processedProfiles.add(profile);
                }
    
                addConfigurationProperties(this.propertiesLoader.getPropertySources());
            }

上面首先初始化一个profiles队列,其队列为一个lifo队列(lastInFirstOut后进先出)，代码为：

this.profiles = Collections.asLifoQueue(new LinkedList<Profile>());

随后判断下当前环境中是否有设profile，没有的话，就使用默认的profile,在profiles中加入一个名为default的profile.随后又在profiles中加入了一个null，对于为什么要加入一个null，代码里也有相应的注释说明。

// The default profile for these purposes is represented as null. We add it
    // last so that it is first out of the queue (active profiles will then
    // override any settings in the defaults when the list is reversed later).
    this.profiles.add(null);

大致意思是说放一个null值在profiles队列的末尾，由于队列是lifo类型的，所以null值就会最先出队，先将默认配置给初始化。当其他激活的profile出队的时候，就会重载默认的配置。  
而后关注这个方法中的这段代码：

while (!this.profiles.isEmpty()) {
                    Profile profile = this.profiles.poll();
                    for (String location : getSearchLocations()) {
                        if (!location.endsWith("/")) {
                            // location is a filename already, so don't search for more
                            // filenames
                            load(location, null, profile);
                        }
                        else {
                            for (String name : getSearchNames()) {
                                load(location, name, profile);
                            }
                        }
                    }
                    this.processedProfiles.add(profile);
                }

在这里就是配置文件体现加载顺序的主要代码  
String location : getSearchLocations()  
在getSearchLocations代码中,在没有设置其他配置文件的情况下，就会在配置文件的路径中加入如下地址

locations.addAll(
    asResolvedSet(ConfigFileApplicationListener.this.searchLocations,
                                DEFAULT_SEARCH_LOCATIONS));

及DEFAULT\_SEARCH\_LOCATIONS的值，而其值在此类的头部也可以找到它的定义：

// Note the order is from least to most specific (last one wins)
        private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";

这里写的先后顺序是classpath:/,classpath:/config/,file:./,file:./config/，但上面有注释说明，这个顺序是通过由后到前的顺序来进行选择的。  
通过asResolvedSet这个方法，也可以得证：

private Set<String> asResolvedSet(String value, String fallback) {
                List<String> list = Arrays.asList(StringUtils.trimArrayElements(
                        StringUtils.commaDelimitedListToStringArray(value != null
                                ? this.environment.resolvePlaceholders(value) : fallback)));
                Collections.reverse(list);
                return new LinkedHashSet<String>(list);
            }

**Collections.reverse(list);**