A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Spring Boot相对于Spring的一大改变或者优势来说就是“约定大于配置”的思想,不像Spring一样所有的配置都需要我们自己去实现,Spring Boot集成了许多默认的配置。拿Spring MVC来举例,原来Spring时代是通过写两个XML配置文件来实现的,一个web.xml,另一个applicationContext.xml。这些文件内容复杂,且大部分情况下不需要改变,在各个项目中的迁移也只是复制粘贴里面的代码而已,这无疑增加了使用成本。而在Spring Boot中,只需要引入相关spring-boot-starter-web依赖即可,其他的配置都不需要。即使有需要其他配置的地方,统一在application.properties配置文件中进行配置即可,该文件写法是类似于json的键值对的格式,不像XML格式那样的重量级。

那么既然不需要相关配置,Spring Boot是如何实现自动装配类的呢?如何在项目启动的时候将需要加载的类都注入到Spring的IoC容器中?本文将探究这个问题。

通常在Spring Boot的启动类上会加上@SpringBootApplication的注解,如下所示:

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
其注解主要是由三个子注解构成的,分别是@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
                @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
                @Filter(type = FilterType.CUSTOM,
                                classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    //...
}
这样我们可以直接使用@SpringBootApplication注解而不再需要使用以上三个注解来标识启动类了。其中@EnableAutoConfiguration是开启自动装配的功能,该注解的代码如下所示:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    //...
}
由上所示,@EnableAutoConfiguration注解需要引入AutoConfigurationImportSelector这个类或者其子类,如果没有找到,则自动装配失败。

而在上述启动时会调用SpringApplication的run方法。该方法会最终调用如下所示的重载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;
                Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
                configureHeadlessProperty();
                SpringApplicationRunListeners listeners = getRunListeners(args);
                listeners.starting();
                try {
                        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                                        args);
                        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                                        applicationArguments);
                        configureIgnoreBeanInfo(environment);
                        Banner printedBanner = printBanner(environment);
                        context = createApplicationContext();
                        exceptionReporters = getSpringFactoriesInstances(
                                        SpringBootExceptionReporter.class,
                                        new Class[] { ConfigurableApplicationContext.class }, context);
                        prepareContext(context, environment, listeners, applicationArguments,
                                        printedBanner);
                        refreshContext(context);
                        afterRefresh(context, applicationArguments);
                        stopWatch.stop();
                        if (this.logStartupInfo) {
                                new StartupInfoLogger(this.mainApplicationClass)
                                                .logStarted(getApplicationLog(), stopWatch);
                        }
                        listeners.started(context);
                        callRunners(context, applicationArguments);
                }
                catch (Throwable ex) {
                        handleRunFailure(context, ex, exceptionReporters, listeners);
                        throw new IllegalStateException(ex);
                }

                try {
                        listeners.running(context);
                }
                catch (Throwable ex) {
                        handleRunFailure(context, ex, exceptionReporters, null);
                        throw new IllegalStateException(ex);
                }
                return context;
        }
以上方法会创建/刷新ApplicationContext、初始化Environment、listeners等一系列操作。在第23行代码中,其会调用getSpringFactoriesInstances方法,同时会将SpringBootExceptionReporter.class这个参数传入进去:

        private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
                        Class<?>[] parameterTypes, Object... args) {
                ClassLoader classLoader = getClassLoader();
                // Use names and ensure unique to protect against duplicates
                Set<String> names = new LinkedHashSet<>(
                                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
                List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                                classLoader, args, names);
                AnnotationAwareOrderComparator.sort(instances);
                return instances;
        }
在该方法中会调用SpringFactoriesLoader的loadFactoryNames方法。SpringFactoriesLoader类的作用是利用工厂的加载机制来读取装配资源的类,其部分源码如下所示:

public final class SpringFactoriesLoader {

        /**
         * 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";

        //...

        private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();

        //...

        /**
         * 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
         * @throws IllegalArgumentException if an error occurs while loading factory names
         * @see #loadFactories
         */
        public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
                String factoryClassName = factoryClass.getName();
                return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
        }

        private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
                MultiValueMap<String, String> result = cache.get(classLoader);
                if (result != null) {
                        return result;
                }

                try {
                        Enumeration<URL> urls = (classLoader != null ?
                                        classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                                        ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
                        result = new LinkedMultiValueMap<>();
                        while (urls.hasMoreElements()) {
                                URL url = urls.nextElement();
                                UrlResource resource = new UrlResource(url);
                                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                                        String factoryClassName = ((String) entry.getKey()).trim();
                                        for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                                                result.add(factoryClassName, factoryName.trim());
                                        }
                                }
                        }
                        cache.put(classLoader, result);
                        return result;
                }
                catch (IOException ex) {
                        throw new IllegalArgumentException("Unable to load factories from location [" +
                                        FACTORIES_RESOURCE_LOCATION + "]", ex);
                }
        }

        //...

}
其中可以看到FACTORIES_RESOURCE_LOCATION这个常量,它就是读取配置资源的文件地址,也就是说会从spring.factories文件中读取所有需要注入的类出来,每一个jar包下基本上都会有一个spring.factories配置文件。而上面源码中第25行的loadFactoryNames方法会调用第30行的loadSpringFactories方法,该方法的作用是读取加载进来的所有jar包下的spring.factories配置文件中的内容,将其放到一个本地缓存cache中。缓存的意义在于第一次调用该方法时会读取spring.factories文件并将读取中的结果放到缓存中,之后再调用该方法时就不再读取文件,而直接返回缓存中的内容就行了。

在spring-boot-autoconfigure的jar包下META-INF目录中的spring.factories文件的部分内容如下:

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\

//...
由上可以看到,其文件格式由键值对组成,每一行末尾的反斜杠表示换行,其他jar包下spring.factories文件的内容也都会有所不同。

而在上面说过的SpringFactoriesLoader类的loadFactoryNames方法中会通过ClassLoader来读取spring.factories文件中的内容。通过run方法中传入的SpringBootExceptionReporter.class这个参数,找到文件中键是SpringBootExceptionReporter所对应的值的集合,通过反射机制来实例化相关的类再返回即可。如前面所说,这里是第一次调用SpringFactoriesLoader类的工厂加载机制的地方,后续再调用的话会直接走缓存中的内容。

再回到最开始SpringApplication类中的run方法中的代码中,之前说的都是基于其中的getSpringFactoriesInstances方法的延展,在该方法执行完毕后,在第28行会调用refreshContext方法,在其中会调用AutoConfigurationImportSelector类的getAutoConfigurationEntry方法,该方法就是自动装配类的方法入口,而AutoConfigurationImportSelector类前面也说过,是@EnableAutoConfiguration这个注解必须要引入的类。在getAutoConfigurationEntry方法中会调用getCandidateConfigurations方法,这两个方法的源码如下:

        /**
         * Return the {@link AutoConfigurationEntry} based on the {@link AnnotationMetadata}
         * of the importing {@link Configuration @Configuration} class.
         * @param autoConfigurationMetadata the auto-configuration metadata
         * @param annotationMetadata the annotation metadata of the configuration class
         * @return the auto-configurations that should be imported
         */
        protected AutoConfigurationEntry getAutoConfigurationEntry(
                        AutoConfigurationMetadata autoConfigurationMetadata,
                        AnnotationMetadata annotationMetadata) {
                if (!isEnabled(annotationMetadata)) {
                        return EMPTY_ENTRY;
                }
                AnnotationAttributes attributes = getAttributes(annotationMetadata);
                List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                attributes);
                configurations = removeDuplicates(configurations);
                Set<String> exclusions = getExclusions(annotationMetadata, attributes);
                checkExcludedClasses(configurations, exclusions);
                configurations.removeAll(exclusions);
                configurations = filter(configurations, autoConfigurationMetadata);
                fireAutoConfigurationImportEvents(configurations, exclusions);
                return new AutoConfigurationEntry(configurations, exclusions);
        }

        /**
         * Return the auto-configuration class names that should be considered. By default
         * this method will load candidates using {@link SpringFactoriesLoader} with
         * {@link #getSpringFactoriesLoaderFactoryClass()}.
         * @param metadata the source metadata
         * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
         * attributes}
         * @return a list of candidate configurations
         */
        protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
                        AnnotationAttributes attributes) {
                List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
                Assert.notEmpty(configurations,
                                "No auto configuration classes found in META-INF/spring.factories. If you "
                                                + "are using a custom packaging, make sure that file is correct.");
                return configurations;
        }

        /**
         * Return the class used by {@link SpringFactoriesLoader} to load configuration
         * candidates.
         * @return the factory class
         */
        protected Class<?> getSpringFactoriesLoaderFactoryClass() {
                return EnableAutoConfiguration.class;
        }
getCandidateConfigurations方法中也会像上面说过的getSpringFactoriesInstances方法一样,调用SpringFactoriesLoader的loadFactoryNames方法来获取配置文件中的内容,只不过这次传入的参数是getSpringFactoriesLoaderFactoryClass(),即EnableAutoConfiguration.class。也就是说会将需要自动装配的类都拿到,通过EnableAutoConfiguration所对应的值的类名的集合。但这次并不会读取spring.factories配置文件,而是会从缓存中读取,因为之前已经调用过loadSpringFactories方法了。读取出的内容依然会使用反射来实例化,将实例化的结果返回回去并最终完成自动装配的全过程。这些自动装配的类会通过一些@ConditionalOnClass、@ConditionalOnMissingClass、@Import之类的注解来加载它们需要的资源。

以上就是Spring Boot完成自动装配的大致核心流程,总结起来就是利用了SpringFactoriesLoader这个类来实现的工厂加载机制,读取jar包下的META-INF目录下的spring.factories配置文件中的内容,然后将需要的类名反射实例化即可。

需要自动装配的类在以前的Spring时代都是需要我们自己写的,但现在Spring Boot的自动装配机制帮我们实现了,只需要引入相关的依赖即可。例如Redis的依赖就是spring-boot-starter-data-redis,引用它就可以了,同时在application.properties配置文件中做些简单的配置即可,就可以直接用起来了,不再需要自己写连接客户端、连接池之类的代码。在上面的spring.factories配置文件的示例中也出现了像RedisAutoConfiguration这样的Redis的自动配置类。


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马