Spring 构建与内置功能

记录spring的简单内置功能以及使用

创建方式

XML

通过加载xml配置文件，获取配置文件里相关的配置项，例如定义的scan标签、bean标签等可以配置扫描的路径以及进行bean的注入。

   ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
   OrderService orderService = (OrderService) context.getBean("orderService");
   orderService.test();

值得一提的是，这种方式需要手动配置bean，所以目前已经很少用了

配置类

通过配置类方式创建spring，其实就是通过注解会自动的解析，与xml类似，只不过不再需要程序员手动写bean。

   AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
   UserService userService = (UserService) context.getBean("userService");
   userService.test();

前置知识（概念）

前置知识主要介绍spring底层源码中会使用的一些概念以及工具类等，方便我们理解底层源码实现的逻辑。

BeanDefinition

BeanDefinition表示的是Bean的定义，BeanDefinition对象内村粗了很多的属性来描述一个Bean的特点，例如：

• class，表示Bean类型
• scope，表示Bean作用域，单例或原型等
• lazyInit：表示Bean是否是懒加载
• initMethodName：表示Bean初始化时要执行的方法
• destroyMethodName：表示Bean销毁时要执行的方法
• 等等...

在Spring中，我们通常通过一下几种方式来定义Bean：

• 声明式

  • 通过xml配置文件的标签
  • 通过@Bean
  • @Component
  • @Service
  • @Controller

• 编程式

直接生成BeanDefinition，并手动设置属性，然后注册到Application中

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 生成一个BeanDefinition对象，并设置beanClass为User.class，并注册到ApplicationContext中
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);// bean的类型
beanDefinition.setScope("prototype"); // 设置作用域
beanDefinition.setInitMethodName("init"); // 设置初始化方法
beanDefinition.setLazyInit(true); // 设置懒加载
context.registerBeanDefinition("user", beanDefinition);// 注册到ApplicationContext中

System.out.println(context.getBean("user"));

BeanDefinitionReader

BeanDefinitionReader是Spring源码中提供的BeanDefinition读取器，在Spring源码中经常会被使用到，相当于Spring源码的基础设施。

AnnotatedBeanDefinitionReader

可以直接把某个类转换为BeanDefinition，并且会解析该类上的注解。它能解析的注解是：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
// 将User.class解析为BeanDefinition
annotatedBeanDefinitionReader.register(User.class);
System.out.println(context.getBean("user"));

XmlBeanDefinitionReader

可以解析<Bean></Bean>标签

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context);
int i = xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml");
System.out.println(context.getBean("user"));

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner是扫描器，但是它的作用和BeanDefinitionReader类似，它可以扫描某个包路径，对扫描到的类进行解析。
如果扫描到的类上如果存在@Component注解，那么就会把这个类解析为一个BeanDefinition。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.refresh();

ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
scanner.scan("com.zhouyu");

System.out.println(context.getBean("userService"));

BeanFactory

BeanFactory表示Bean工厂。BeanFactory是Spring的一个顶级父类，提供了很多操作Bean的功能，例如负责创建Bean以及获取Bean。

在Spring源码中，BeanFactory接口存在一个非常重要的实现类DefaultListableBeanFactory也是非常核心的。

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
beanFactory.registerBeanDefinition("user", beanDefinition);

System.out.println(beanFactory.getBean("user"));

DefaultListableBeanFactory是非常强大的，支持很多功能，可以通过查看DefaultListableBeanFactory的类继承实现结构来看


从上面的结构图可以看到，DefaultListableBeanFactory：继承了AbstractAutowireCapableBeanFactory，实现了ConfigurableListableBeanFactory接口和BeanDefinitionRegistry接口，提供了很多功能：

• AliasRegistry：支持别名功能，一个名字可以对应多个别名
• BeanDefinitionRegistry：可以注册、保存、移除、获取某个BeanDefinition
• BeanFactory：Bean工厂，可以根据某个bean的名字、或类型、或别名获取某个Bean对象
• SingletonBeanRegistry：可以直接注册、获取某个单例Bean
• SimpleAliasRegistry：它是一个类，实现了AliasRegistry接口中所定义的功能，支持别名功能
• ListableBeanFactory：在BeanFactory的基础上，增加了其他功能，可以获取所有BeanDefinition的beanNames，可以根据某个类型获取对应的beanNames，可以根据某个类型获取{类型：对应的Bean}的映射关系
• HierarchicalBeanFactory：在BeanFactory的基础上，添加了获取父BeanFactory的功能
• DefaultSingletonBeanRegistry：它是一个类，实现了SingletonBeanRegistry接口，拥有了直接注册、获取某个单例Bean的功能
• ConfigurableBeanFactory：在HierarchicalBeanFactory和SingletonBeanRegistry的基础上，添加了设置父BeanFactory、类加载器（表示可以指定某个类加载器进行类的加载）、设置Spring
  EL表达式解析器（表示该BeanFactory可以解析EL表达式）、设置类型转化服务（表示该BeanFactory可以进行类型转化）、可以添加BeanPostProcessor（表示该BeanFactory支持Bean的后置处理器），可以合并BeanDefinition，可以销毁某个Bean等等功能
• FactoryBeanRegistrySupport：支持了FactoryBean的功能
• AutowireCapableBeanFactory：是直接继承了BeanFactory，在BeanFactory的基础上，支持在创建Bean的过程中能对Bean进行自动装配
• AbstractBeanFactory：实现了ConfigurableBeanFactory接口，继承了FactoryBeanRegistrySupport，这个BeanFactory的功能已经很全面了，但是不能自动装配和获取beanNames
• ConfigurableListableBeanFactory：继承了ListableBeanFactory、AutowireCapableBeanFactory、ConfigurableBeanFactory
• AbstractAutowireCapableBeanFactory：继承了AbstractBeanFactory，实现了AutowireCapableBeanFactory，拥有了自动装配的功能

ApplicationContext

ApplicationContext是个接口，同时继承了BeanFactory，不过其还提供可其他的功能，比BeanFactory更强大：


• HierarchicalBeanFactory：拥有获取父BeanFactory的功能
• ListableBeanFactory：拥有获取beanNames的功能
• ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）
• EnvironmentCapable：可以获取运行时环境（没有设置运行时环境功能）
• ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）
• MessageSource：拥有国际化功能

AnnotationConfigApplicationContext

AnnotationConfigApplicationContext是ApplicationContext比较重要的一个实现类，不仅有ApplicationContext的功能，还添加了监听器、工厂后置处理器、运行环境等


• ConfigurableApplicationContext：继承了ApplicationContext接口，并且自己实现了添加事件监听器、添加BeanFactoryPostProcessor、设置Environment，获取ConfigurableListableBeanFactory等功能
• AbstractApplicationContext：实现了ConfigurableApplicationContext接口
• GenericApplicationContext：继承了AbstractApplicationContext，实现了BeanDefinitionRegistry接口，拥有了所有ApplicationContext的功能，并且可以注册BeanDefinition，注意这个类中有一个属性(DefaultListableBeanFactory beanFactory)
• AnnotationConfigRegistry：可以单独注册某个为类为BeanDefinition（可以处理该类上的**@Configuration注解**，已经可以处理**@Bean注解**），同时可以扫描
• AnnotationConfigApplicationContext：继承了GenericApplicationContext，实现了AnnotationConfigRegistry接口，拥有了以上所有的功能

ClassPathXmlApplicationContext

它也是继承了AbstractApplicationContext，但是相对于AnnotationConfigApplicationContext而言，功能没有AnnotationConfigApplicationContext强大，比如不能注册BeanDefinition

Resource

Spring提供的资源加载功能，可以加载系统资源、配置文件、网站支援等

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

Resource resource = context.getResource("file://D:\\IdeaProjects\\UserService.java");
System.out.println(resource.contentLength());
System.out.println(resource.getFilename());

Resource resource1 = context.getResource("https://www.baidu.com");
System.out.println(resource1.contentLength());
System.out.println(resource1.getURL());

Resource resource2 = context.getResource("classpath:spring.xml");
System.out.println(resource2.contentLength());
System.out.println(resource2.getURL());

Environment

Environment是记录了Spring运行时的运行时环境，例如系统信息、JVM信息等

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

Map<String, Object> systemEnvironment = context.getEnvironment().getSystemEnvironment();
System.out.println(systemEnvironment);

Map<String, Object> systemProperties = context.getEnvironment().getSystemProperties();
System.out.println(systemProperties);

MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
System.out.println(propertySources);

System.out.println(context.getEnvironment().getProperty("NO_PROXY"));
System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding"));

在开始时，如果要将某个文件中的参数添加到运行时环境中，可以通过注解**@PropertySource("classpath:spring.properties")**来实现

ApplicationListener

事件发布器

类型转换器

在Spring源码中，有可能需要把String转成其他类型，所以在Spring源码中提供了一些技术来更方便的做对象的类型转化。

PropertyEditor

这其实是JDK中提供的类型转化工具类

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);
	}
}


@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

Spring中提供的类型转化服务，它比PropertyEditor更强大

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;
 }
}


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

 return conversionServiceFactoryBean;
}

TypeConverter

整合了PropertyEditor和ConversionService的功能，是Spring内部用的

SimpleTypeConverter typeConverter = new SimpleTypeConverter();
typeConverter.registerCustomEditor(User.class, new StringToUserPropertyEditor());
//typeConverter.setConversionService(conversionService);
User value = typeConverter.convertIfNecessary("1", User.class);
System.out.println(value);

OrderComparator

OrderComparator是Spring所提供的一种比较器，可以用来根据@Order注解或实现Ordered接口来执行值进行标记，从而可以进行排序。Spring中还提供了一个OrderComparator的子类：**
AnnotationAwareOrderComparator**，它支持用@Order来指定order值。

BeanPostProcessor

BeanPostProcess表示Bena的后置处理器，在Bean的生命周期执行过程中，会有很多后置处理器，去处理不同时期的Bean，这样我们就可以修改Bean的信息，干涉Spring创建Bean的过程。

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {

 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
   System.out.println("初始化前");
  }

  return bean;
 }

 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
   System.out.println("初始化后");
  }

  return bean;
 }
}

BeanFactoryPostProcessor

BeanFactoryPostProcessor表示Bean工厂的后置处理器，其实和BeanPostProcessor类似，BeanPostProcessor是干涉Bean的创建过程，BeanFactoryPostProcessor是干涉BeanFactory的创建过程。

@Component
public class ZhouyuBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  System.out.println("加工beanFactory");
 }
}

FactoryBean

FactoryBean其实也是一个Bean。其为程序员提供了一个自己创建Bean的实现，通过FactoryBean创建的Bean，只会经过初始化，而通过@Bean等生成的Bean是会经过完整的Bean生命周期的。

@Component
public class ZhouyuFactoryBean implements FactoryBean {

 @Override
 public Object getObject() throws Exception {
  UserService userService = new UserService();

  return userService;
 }

 @Override
 public Class<?> getObjectType() {
  return UserService.class;
 }
}

Filter

Spring 提供了过滤器，用来排除哪些类会注册成为Bean，哪些不会注册。

ExcludeFilter表示排除过滤器，IncludeFilter表示包含过滤器。

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

/**
* 扫描com.zhouyu这个包下面的所有类，但是排除UserService类
*/
@ComponentScan(value = "com.zhouyu",
  excludeFilters = {@ComponentScan.Filter(
             type = FilterType.ASSIGNABLE_TYPE, 
             classes = UserService.class)}.)
public class AppConfig {
}



/**
* UserService类上没有@Component注解，它也会被扫描成为一个Bean
*/
@ComponentScan(value = "com.zhouyu",
  includeFilters = {@ComponentScan.Filter(
             type = FilterType.ASSIGNABLE_TYPE, 
             classes = UserService.class)})
public class AppConfig {
}

FilterType分类：

• ANNOTATION：表示是否包含某个注解
• ASSIGNABLE_TYPE：表示是否是某个类
• ASPECTJ：表示否是符合某个Aspectj表达式
• REGEX：表示是否符合某个正则表达式
• CUSTOM：自定义

Metadata

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

MetadataReader表示类的元数据读取器，默认实现类为SimpleMetadataReader。SimpleMetadataReader去解析类时，使用的ASM技术。

ClassMetadata表示类的元数据信息。

AnnotationMetadata表示注解的元数据信息。