Spring底层架构源码解析（三）

ApplicationContext

AnnotationConfigApplicationContext

ClassPathXmlApplicationContext

类型转换

[MetadataReader、ClassMetadata、 AnnotationMetadata](#MetadataReader、ClassMetadata、 AnnotationMetadata)

ExcludeFilter，IncludeFilter

有关spring的前置知识，可以观看我的上一篇文章spring底层架构源码解析（二）

ApplicationContext

接上一篇文章，再将到BeanFactory后不得不提到ApplicationContext了,ApplicationContext其实是继承了BeanFactory的，但是ApplicationContext提供了比BeanFactory更多的功能，其中ApplicationContext两个比较重要的实现类：

1. AnnotationConfigApplicationContext

2. ClassPathXmlApplicationContext

AnnotationConfigApplicationContext

在idea的继承图如下，可以发现AnnotationConfigApplicationContext实现了很多的接口

ConfigurableApplicationContext：继承了ApplicationContext接口，增加了，添加事件监听器、添加BeanFactoryPostProcessor、设置Environment，获取 ConfigurableListableBeanFactory等功能

AbstractApplicationContext：实现了ConfigurableApplicationContext接口

3.GenericApplicationContext：继承了AbstractApplicationContext，实现了 BeanDefinitionRegistry接口，拥有了所有ApplicationContext的功能，并且可以注册 BeanDefinition，注意这个类中有一个属性(DefaultListableBeanFactory beanFactory)

AnnotationConfigRegistry：可以单独注册某个为类为BeanDefinition（可以处理该类上的 **@Configuration注解**，已经可以处理**@Bean注解**），同时可以扫描

AnnotationConfigApplicationContext：继承了GenericApplicationContext，实现了 AnnotationConfigRegistry接口，拥有了以上所有的功能

ClassPathXmlApplicationContext

同样，在idea的继承图如下，可以发现ClassPathXmlApplicationContext实现了很多的接口

类型转换

在spring的源码中有许多类型转换的工具类，例如：PropertyEditor，ConversionService，TypeConverter等，他们可以将我们写的String转换为spring需要加载的类对象

PropertyEditor

java 复制代码

public class StringToUserPropertyEditor extends PropertyEditorSupport implements 
PropertyEditor { 
  @Override 
  public void setAsText(String text) throws IllegalArgumentException { 
    User user = new User(); 
    user.setName(text); 
    this.setValue(user); 
  } 
}

如何向Spring中注册PropertyEditor：

java 复制代码

@Bean 
public CustomEditorConfigurer customEditorConfigurer() { 
  CustomEditorConfigurer customEditorConfigurer = new CustomEditorConfigurer(); 
  Map<Class<?>, Class<? extends PropertyEditor>> propertyEditorMap = new HashMap<>(); 
     
    // 表示StringToUserPropertyEditor可以将String转化成User类型，在Spring源码中，如果发现当前
对象是String，而需要的类型是User，就会使用该PropertyEditor来做类型转化 
  propertyEditorMap.put(User.class, StringToUserPropertyEditor.class); 
  customEditorConfigurer.setCustomEditors(propertyEditorMap); 
  return customEditorConfigurer; 
}

ConversionService

ConversionService是比PropertyEditor更为强大的类型转换类

java 复制代码

public class StringToUserConverter implements ConditionalGenericConverter { 
  @Override 
  public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { 
    return sourceType.getType().equals(String.class) && 
targetType.getType().equals(User.class); 
  } 
  @Override 
  public Set<ConvertiblePair> getConvertibleTypes() { 
    return Collections.singleton(new ConvertiblePair(String.class, User.class)); 
  } 
  @Override 
  public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor 
targetType) { 
    User user = new User(); 
    user.setName((String)source); 
    return user; 
  } 
}

如何向Spring中注册ConversionService：

java 复制代码

@Bean 
public ConversionServiceFactoryBean conversionService() { 
  ConversionServiceFactoryBean conversionServiceFactoryBean = new 
ConversionServiceFactoryBean(); 
  conversionServiceFactoryBean.setConverters(Collections.singleton(new 
StringToUserConverter())); 
  return conversionServiceFactoryBean; 
}

BeanPostProcessor

BeanPostProcess表示Bena的后置处理器，我们可以定义一个或多个BeanPostProcessor，比如通过以下代码定义一个BeanPostProcessor：

java 复制代码

@Component 
public class LcyyBeanPostProcessor implements BeanPostProcessor { 
  @Override 
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws 
BeansException { 
    if ("userService".equals(beanName)) { 
      System.out.println("Bean的初始化前"); 
    } 
    return bean; 
  } 
  @Override 
  public Object postProcessAfterInitialization(Object bean, String beanName) throws 
BeansException { 
    if ("userService".equals(beanName)) { 
      System.out.println("Bean的初始化后"); 
    } 
    return bean; 
  } 
}

一个BeanPostProcessor可以在任意一个Bean的初始化之前以及初始化之后去额外的做一些用户自定义的逻辑，当然，我们可以通过判断beanName来进行针对性处理（针对某个Bean，或某部分 Bean）。因此可以通过定义BeanPostProcessor来干涉Spring创建Bean的过程。

FactoryBean

FactoryBean 其实是一个比较特殊的Bean，可以通过BeanPostPorcessor来干涉Spring创建Bean的过程，但是如果我们想一个 Bean完完全全由我们来创造，也是可以的，比如通FactoryBean

java 复制代码

@Component 
public class LcyyFactoryBean implements FactoryBean { 
  @Override 
  public Object getObject() throws Exception { 
    UserService userService = new UserService(); 
    return userService; 
  } 
  @Override 
  public Class<?> getObjectType() { 
    return UserService.class; 
  } 
}

通过上面这段代码，我们自己创造了一个UserService对象，并且它将成为Bean。但是通过这种方式创造出来的UserService的Bean，只会经过初始化后，其他Spring的生命周期步骤是不会经过的，比如依赖注入。

MetadataReader、ClassMetadata、 AnnotationMetadata

在Spring中需要去解析类的信息，比如类名、类中的方法、类上的注解，这些都可以称之为类的元数据，所以Spring中对类的元数据做了抽象，并提供了一些工具类。MetadataReader表示类的元数据读取器，默认实现类为SimpleMetadataReader

java 复制代码

public class Test { 
  public static void main(String[] args) throws IOException { 
    SimpleMetadataReaderFactory simpleMetadataReaderFactory = new 
SimpleMetadataReaderFactory(); 
     
        // 构造一个MetadataReader 
        MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader("com.lcyy.service.UserService"); 
     
        // 得到一个ClassMetadata，并获取了类名 
        ClassMetadata classMetadata = metadataReader.getClassMetadata(); 
   
        System.out.println(classMetadata.getClassName()); 
         
        // 获取一个AnnotationMetadata，并获取类上的注解信息 
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); 
    for (String annotationType : annotationMetadata.getAnnotationTypes()) { 
      System.out.println(annotationType); 
    } 
  } 
}

ExcludeFilter，IncludeFilter

这两个Filter是Spring扫描过程中用来过滤的。ExcludeFilter表示排除过滤器，IncludeFilter表示包含过滤器。比如以下配置，表示扫描com.lcyy这个包下面的所有类，但是排除UserService类，也就是就算它上面有@Component注解也不会成为Bean。

java 复制代码

@ComponentScan(value = "com.lcyy", 
    excludeFilters = {@ComponentScan.Filter( 
              type = FilterType.ASSIGNABLE_TYPE,  
              classes = UserService.class)}.) 
public class AppConfig { 
}

再比如以下配置，就算UserService类上没有@Component注解，它也会被扫描成为一个Bean。

java 复制代码

@ComponentScan(value = "com.lcyy", 
    includeFilters = {@ComponentScan.Filter( 
              type = FilterType.ASSIGNABLE_TYPE,  
              classes = UserService.class)}) 
public class AppConfig { 
}

FilterType分为：

ANNOTATION：表示是否包含某个注解

ASSIGNABLE_TYPE：表示是否是某个类

ASPECTJ：表示否是符合某个Aspectj表达式

REGEX：表示是否符合某个正则表达式

CUSTOM：自定义

在Spring的扫描逻辑中，默认会添加一个AnnotationTypeFilter给includeFilters，表示默认情况下 Spring扫描过程中会认为类上有@Component注解的就是Bean。