程序员小杰

V1

2022/01/17阅读:41主题:全栈蓝

Spring源码(三)-Bean工厂-BeanFactory

日积月累,水滴石穿 😄

DefaultListableBeanFactory

上篇就使用到了 DefaultListableBeanFactory类中的registerBeanDefinition方法将 BeanDefinition 缓存在了 beanDefinitionMap Map中。DefaultListableBeanFactory 是Spring中最为核心的 BeanFactory。先来看一下它的继承关系图。 继承关系图

看到这个图可能会吓一大跳,DefaultListableBeanFactory 实现了这么多接口,不过这也代表着它拥有很多功能,我们先来分析每个接口的作用吧!

    1. AliasRegistry:支持别名功能,一个 beanName 可以对应多个别名
    1. BeanDefinitionRegistry:可以注册、保存、移除、获取某个BeanDefinition
    1. SimpleAliasRegistry:它是一个类,实现了AliasRegistry接口中所定义的功能,支持别名功能,使用 map 作为 alias 的缓存
    1. SingletonBeanRegistry:可以直接注册、获取某个单例 Bean
    1. BeanFactory:Bean工厂,可以根据某个 bean 的名字、或类型、或别名获取某个 Bean 对象
    1. ListableBeanFactory:在 BeanFactory 的基础上,增加了其他功能,可以获取所有 BeanDefinitionbeanNames,可以根据某个类型获取对应的 beanNames,可以根据某个类型获取{类型:对应的Bean}的映射关系
    1. HierarchicalBeanFactory:在 BeanFactory 的基础上,添加了获取父 BeanFactory 的功能
    1. DefaultSingletonBeanRegistry:它是一个类,实现了 SingletonBeanRegistry 接口,拥有了直接注册、获取某个单例Bean的功能,还继承了 SimpleAliasRegistry,支持别名功能
    1. ConfigurableBeanFactory:在 HierarchicalBeanFactorySingletonBeanRegistry 的基础上,添加了设置父 BeanFactory、类加载器(表示可以指定某个类加载器进行类的加载)、设置SpringEL表达式解析器(表示该 BeanFactory 可以解析EL表达式)、设置类型转化服务(表示该 ``BeanFactory可以进行类型转化)、可以添加BeanPostProcessor(表示该BeanFactory支持Bean的后置处理器),可以合并BeanDefinition`,可以销毁某个 Bean 等功能
    1. FactoryBeanRegistrySupport:支持了FactoryBean的功能
    1. AutowireCapableBeanFactory:直接继承了 BeanFactory,在 BeanFactory 的基础上,支持在创建Bean 的过程中能对 Bean 进行自动装配
    1. AbstractBeanFactory:实现了 ConfigurableBeanFactory 接口,继承了FactoryBeanRegistrySupport,这个 BeanFactory的功能已经很全面了,但是不能自动装配和获取beanNames
    1. ConfigurableListableBeanFactory:继承了 ListableBeanFactoryAutowireCapableBeanFactoryConfigurableBeanFactory
    1. AbstractAutowireCapableBeanFactory:继承了 AbstractBeanFactory,实现了AutowireCapableBeanFactory,拥有了自动装配的功能
    1. DefaultListableBeanFactory:继承了 AbstractAutowireCapableBeanFactory,实现了ConfigurableListableBeanFactory 接口和 BeanDefinitionRegistry接口,所以DefaultListableBeanFactory的功能很强大
    1. XmlBeanFactory:XmlBeanFactory 类继承自DefaultListableBeanFacotry类,使用了自定义的XML 读取器 XmlBeanDefinitionReader,主要使用reader 属性对资源文件进行读取和注册

通过以上分析,我们可以知道,通过DefaultListableBeanFactory我们可以做很多事情,比如:

 public static void main(String[] args) {
  AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
  beanDefinition.setBeanClass(User.class);

  DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
  // 注册BeanDefinition
  factory.registerBeanDefinition("user", beanDefinition);
  // 注册别名
  factory.registerAlias("user""user1");
        // 添加BeanPostProcessor
  factory.addBeanPostProcessor(new GongjBeanPostProcessor());
  // 获取别名获取Bean对象
  System.out.println(factory.getBean("user1"));
  // 根据类型获取beanNames
  String[] beanNamesForType = factory.getBeanNamesForType(User.class);
  for (String s : beanNamesForType) {
   System.out.println(s);
  }
 }
  • GongjBeanPostProcessor
public class GongjBeanPostProcessor implements BeanPostProcessor {
 //bean初始化方法调用前被调用
 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  System.out.println("bean初始化方法调用前被调用");
  return null;
 }
 //bean初始化方法调用后被调用
 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  System.out.println("bean初始化方法调用后被调用");
  return null;
 }
}

BeanPostProcessorSpring IOC 容器给我们提供的一个扩展接口,该接口就不在本文中阐述。


容器概览

Spring 中的 Ioc 容器,我们可以大致上分为两种:

  • BeanFactory
  • ApplicationContext

BeanFactory

BeanFactory 是最最基础的 IoC 容器,它提供了一个 IoC 容器所需的基本功能。 BeanFactory 默认采用延迟初始化策略,即当容器启动时,并未完成 Bean 的初始化,只有当调用到该 Bean 的实例时,才会完成其初始化操作,并进行依赖注入。

如下代码:

XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
User user = factory.getBean(User.class);

当第一行代码执行的时候,beans.xml中配置的 User 对象并未进行初始化,只有当第二行 getBean 方法调用时,User 对象才进行了初始化操作。

这样设计的好处是容器启动速度快,因为要做的事情比较少。接下来看看BeanFactory的示例:

public interface BeanFactory {  

 //FactoryBean的前缀
    //有&符号:返回工厂本身
   //无&符号:返回工厂创建的实例
 String FACTORY_BEAN_PREFIX = "&";

 //返回指定bean的一个实例,如果没有找到指定bean,该方法会抛出异常
 Object getBean(String name) throws BeansException;

 //返回以给定名称注册的bean实例,并转换为给定class类型
 //如果没有找到指定bean、或者类型转换失败,该方法会抛出异常
 <T> getBean(String name, Class<T> requiredType) throws BeansException;

    // 通过name获取Bean, 通过第二个参数可以给对象赋值,这种方式需要 指定Bean的作用域为 prototype
 Object getBean(String name, Object... args) throws BeansException;

 // 根据指定Class类型查找Bean
 // 如果没有找到指定bean、或者找到多个类型,该方法会抛出异常
 <T> getBean(Class<T> requiredType) throws BeansException;

 //通过类型查找Bean,通过第二个参数可以给对象赋值,需要 指定Bean的作用域为 prototype
 <T> getBean(Class<T> requiredType, Object... args) throws BeansException;

 // 获取bean的提供者
 <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
 <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

 // 是否包含指定名字的bean
 boolean containsBean(String name);

 // 指定名称的bean是否为单例
 boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

 // 指定名称的bean是否为原型
 boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

 // 指定名称的bean是否和指定的类型匹配
 boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
 boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

 // 获取指定名字的bean的类型
 @Nullable
 Class<?> getType(String name) throws NoSuchBeanDefinitionException;
//获取指定名字的bean的类型,如果该 Bean 的类型为 FactoryBean,第二个参数就有作用,当 参数值为 false 时,FactoryBean不会被创建。
 @Nullable
 Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

 // 获取指定名字的bean的所有别名
 String[] getAliases(String name);
}

实例

  public static void main(String[] args) {
  ClassPathResource resource = new ClassPathResource("spring-config.xml");
  DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
  XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
  reader.loadBeanDefinitions(resource);
  //获取别名获取Bean对象
  System.out.println("person1 = " + factory.getBean("person"));
  System.out.println("person2 = " +factory.getBean("person", Person.class));
  System.out.println("person3 = " + factory.getBean("person""gongj""shanghai"));
  System.out.println("person4 = " + factory.getBean(Person.class));
  System.out.println("person4 = " + factory.getBean(Person.class,"gognj"));

  System.out.println("getBeanProvider = " + factory.getBeanProvider(Person.class));

  System.out.println("containsBean = " + factory.containsBean("person"));
  System.out.println("isSingleton = " + factory.isSingleton("person"));
  System.out.println("isPrototype = " + factory.isPrototype("person"));
  System.out.println("isPrototype = " + factory.isTypeMatch("person",Person.class));
  System.out.println("getType = " + factory.getType("person",false));
  System.out.println("getType = " + factory.getType("p",false));

  String[] people = factory.getAliases("person");
  for (String s : people) {
   System.out.println("getAliases = " + s);
  }
  // 根据类型获取beanNames
  String[] beanNamesForType = factory.getBeanNamesForType(User.class);
  for (String s : beanNamesForType) {
   System.out.println(s);
  }
 }
  • xml
<bean id="person" class="com.gongj.bean.Person" scope="prototype"></bean>
<alias name="person" alias="person2"/>
<bean id="p" class="com.gongj.bean.PersonFactory"></bean>

  • Person
public class Person {

 private String name;
 private String address;

 public Person(String name, String address) {
  this.name = name;
  this.address = address;
 }

 public Person(String name) {
  this.name = name;
 }

 public Person() {
 }

 @Override
 public String toString() {
  return "Person{" +
    "name='" + name + '\'' +
    ", address='" + address + '\'' +
    '}';
 }
}
  • PersonFactory
public class PersonFactory implements FactoryBean {
 @Override
 public Object getObject() throws Exception {
  return new User();
 }

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

 @Override
 public boolean isSingleton() {
  return true;
 }
}

ApplicationContext

ApplicationContext 是在 BeanFactory 的基础上实现的,BeanFactory 的功能它都有,算是一种高级容器。ApplicationContextBeanFactory 的基础上提供了事件发布、国际化等功能。同时,ApplicationContextBeanFactory 还有一个很大的不同。在于 ApplicationContext 在容器启动时,就会完成所有单例非懒加载 Bean 的初始化,这也就以为着容器启动时间较长,并且对系统资源要求也较高。

如下一段代码:

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

当这段代码执行时,beans.xml中配置的 User 对象就会完成初始化。 ApplicationContext是个接口,可以把它理解为一个特殊的BeanFactory,通常建议比BeanFactory优先 。

  • ApplicationContext 不等于 BeanFactoryApplicationContext 只是继承了BeanFactory, 拥有了Bean 工厂的功能,同时,ApplicationContext 还继承了其他接口,比如:
  • HierarchicalBeanFactory:拥有获取父 BeanFactory 的功能
  • ListableBeanFactory:拥有获取 beanNames 的功能
  • ResourcePatternResolver:资源加载器,可以一次性获取多个资源(文件资源等等)
  • EnvironmentCapable:可以获取运行时环境(没有设置运行时环境功能)
  • ApplicationEventPublisher:拥有广播事件的功能(没有添加事件监听器的功能)
  • MessageSource:拥有国际化功能 image.png

ApplicationContext 还有两个比较重要的实现类:

  • AnnotationConfigApplicationContext
  • ClassPathXmlApplicationContext

AnnotationConfigApplicationContext

image.png
image.png
  • ConfigurableApplicationContext:继承了 ApplicationContext 接口,增加了添加事件监听器、添加 BeanFactoryPostProcessor、设置 Environment,获取 ConfigurableListableBeanFactory 等功能
  • AbstractApplicationContext:实现了 ConfigurableApplicationContext 接口,继承 DefaultResourceLoader
  • GenericApplicationContext:继承了 AbstractApplicationContext,实现了 BeanDefinitionRegistry 接口,拥有了所有 ApplicationContext 的功能,并且可以注册 BeanDefinition,注意这个类中有一个属性是(DefaultListableBeanFactory beanFactory)
  • AnnotationConfigRegistry:可以单独注册某个类为 BeanDefinition(可以处理该类上的@Configuration注解,可以处理@Bean注解)。
  • AnnotationConfigApplicationContext:继承了GenericApplicationContext,实现了AnnotationConfigRegistry接口,拥有了以上所有的功能

ClassPathXmlApplicationContext

image.png
image.png

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

参考文献

Spring 源码系列之容器概览

分类:

后端

标签:

Java

作者介绍

程序员小杰
V1