spring

Spring源码(三)-BeanFactory

2021-02-24  本文已影响0人  程序员小杰

DefaultListableBeanFactory

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

继承关系图

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

通过以上分析，我们可以知道，通过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);
        }
    }

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

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

容器概览

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

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> 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> T getBean(Class<T> requiredType) throws BeansException;

    //通过类型查找Bean,通过第二个参数可以给对象赋值，需要 指定Bean的作用域为 prototype
    <T> 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);
        }
    }

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


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 + '\'' +
                '}';
    }
}

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

如下一段代码：

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

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

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

AnnotationConfigApplicationContext

image.png

ClassPathXmlApplicationContext

image.png

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

参考文献：
Spring 源码系列之容器概览

上一篇 下一篇

猜你喜欢

热点阅读