SpringBoot的自动装载

Springboot的自动装载

SpringBoot开箱即用的特点，很大程度上归功于ImportSelector。接下来我们看下springBoot是如何在spring的基础上做扩展的。
在SpringBoot中最重要的一个注解SpringBootApplication

@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 {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

在EnableAutoConfiguration中通过Import引入了SpringBoot定义的
AutoConfigurationImportSelector
这个类内容比较多，我们只需看下最主要的逻辑代码即可

public class AutoConfigurationImportSelector
 implements DeferredImportSelector, BeanClassLoaderAware, 
ResourceLoaderAware,
 BeanFactoryAware, EnvironmentAware, Ordered {
 @Override
 public String[] selectImports(AnnotationMetadata annotationMetadata) {
 if (!isEnabled(annotationMetadata)) {
 return NO_IMPORTS;
 }
 AutoConfigurationMetadata autoConfigurationMetadata =
AutoConfigurationMetadataLoader
 .loadMetadata(this.beanClassLoader);
 //主要逻辑在getAutoConfigurationEntry这个方法
 AutoConfigurationEntry autoConfigurationEntry =
getAutoConfigurationEntry(
 autoConfigurationMetadata, annotationMetadata);
 return
StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
 }
 protected AutoConfigurationEntry getAutoConfigurationEntry(
 AutoConfigurationMetadata autoConfigurationMetadata,
 AnnotationMetadata annotationMetadata) {
 if (!isEnabled(annotationMetadata)) {
 return EMPTY_ENTRY;
 }
 AnnotationAttributes attributes = getAttributes(annotationMetadata);
 //通过getCandidateConfigurations方法获取所有需要加载的bean
 List<String> configurations =
getCandidateConfigurations(annotationMetadata,
 attributes);
 //去重处理
 configurations = removeDuplicates(configurations);
 //获取不需要加载的bean,这里我们可以通过spring.autoconfigure.exclude人为配置
 Set<String> exclusions = getExclusions(annotationMetadata, attributes);
 checkExcludedClasses(configurations, exclusions);
 configurations.removeAll(exclusions);
 configurations = filter(configurations, autoConfigurationMetadata);
 //发送事件,通知所有的AutoConfigurationImportListener进行监听
 fireAutoConfigurationImportEvents(configurations, exclusions);
 return new AutoConfigurationEntry(configurations, exclusions);
 }
 //这里是获取bean渠道的地方,重点看SpringFactoriesLoader#loadFactoryNames
 protected List<String> getCandidateConfigurations(AnnotationMetadata
metadata,
 AnnotationAttributes attributes) {
 //这里的getSpringFactoriesLoaderFactoryClass()最终返回
EnableAutoConfiguration.class
 List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
 getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
 Assert.notEmpty(configurations,
 "No auto configuration classes found in METAINF/spring.factories. If you "
 + "are using a custom packaging, make sure that file is 
correct.");
 return configurations;
 }
}

从上面的逻辑可以看出,最终获取bean的渠道在SpringFactoriesLoader.loadFactoryNames

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "METAINF/spring.factories";
    private static final Log logger =
LogFactory.getLog(SpringFactoriesLoader.class);
    private static final Map<ClassLoader, MultiValueMap<String, String>> cache =
new ConcurrentReferenceHashMap();
    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable
ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        //通过factoryClassName获取相应的bean全称
 //上面传入的factoryClass是EnableAutoConfiguration.class
        return
(List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, 
Collections.emptyList());
   }
    private static Map<String, List<String>> loadSpringFactories(@Nullable
ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
       } else {
            try {
                //获取工程中所有META-INF/spring.factories文件,将其中的键值组合成Map
                Enumeration<URL> urls = classLoader != null ?
classLoader.getResources("META-INF/spring.factories") : 
ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                      UrlResource resource = new UrlResource(url);
                    Properties properties =
PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName =
((String)entry.getKey()).trim();
                        String[] var9 =
StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;
                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                       }
                   }
               }
                cache.put(classLoader, result);
                return result;
           } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories 
from location [META-INF/spring.factories]", var13);
           }
       }
   }
    private static <T> T instantiateFactory(String instanceClassName, Class<T>
factoryClass, ClassLoader classLoader) {
        try {
            Class<?> instanceClass = ClassUtils.forName(instanceClassName, 
classLoader);
            if (!factoryClass.isAssignableFrom(instanceClass)) {
                throw new IllegalArgumentException("Class [" + instanceClassName
+ "] is not assignable to [" + factoryClass.getName() + "]");
           } else {
                return ReflectionUtils.accessibleConstructor(instanceClass, new
Class[0]).newInstance();
           }
       } catch (Throwable var4) {
            throw new IllegalArgumentException("Unable to instantiate factory 
class: " + factoryClass.getName(), var4);
       }
   }
}

每个jar都可以定义自己的META-INF/spring.factories ,jar被加载的同时 spring.factories里面定义的bean就可以自动被加载

举一个小小的例子

• 定义bean

@Data
public class User {
    private String username;
    private Integer age;
}

• 定义配置类

public class UserConfigtion {

    @Bean
    public User getUser(){
        User user = new User();
        user.setAge(11);
        user.setUsername("tjk");
        return user;
    }
}

• 定义UserImportSelector

public class UserImportSelector  implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //获取配置类的名称
        return new String[]{UserConfigtion.class.getName()};
    }
}

• 定义EnableUserBean注解

@Retention(RetentionPolicy.RUNTIME)//规定什么时候运行
@Documented
@Target(ElementType.TYPE)//注解什么时候起作用
@Import(UserImportSelector.class)
public @interface EnableUserBean {
}

• 测试

@EnableUserBean
public class TestApplication {
    public static void main(String[] args) {
        //获取SPringle容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestApplication.class);
        User user = applicationContext.getBean(User.class);
        System.out.println(user);

    }
}

• 结果
  
  由此可见，对象并没有使用Spring的对象对象创建注解声明（@Controller，@Service，@Repostiroty），而是使用编程的方式动态的载入bean。