在前面博客中介绍什么是依赖注入时有提到:依赖注入是组件之间依赖关系由容器在运行期决定,即由容器动态的将某个依赖关系注入到组件之中。那什么是容器?既然Spring框架实现了IOC,那Spring中的容器是什么呢?
 一、容器介绍
在日常生活中容器是指用以容纳物料并以壳体为主的基本装置,它是用来盛放东西的。在编程中容器是用来存储和组织其他对象的对象,首先要确定容器也是对象,也可以当做bean,只是这个对象是用来存储和组织其他对象,那其他对象是什么呢?其他对象其实就是bean对象,这也是面向对象编程的一种体现,万物皆对象。在Spring提供了BeanFactory、ApplicationContext两个IOC容器,来管理众多的bean对象。
二、BeanFactory
一提到工厂我们生活当中可能会想到富某康,工厂是一类用以生产货物的大型工业建筑物。而BeanFactory不是用来生产货物的而是用来生产管理bean的。BeanFactory会在bean的生命周期的各个阶段中对bean进行各种管理,并且Spring将这些阶段通过各种接口暴露给我们,让我们可以对bean进行各种处理,我们只要让bean实现对应的接口,那么Spring就会在bean的生命周期调用我们实现的接口来处理该bean。那它是怎么实现的呢?它主要分两个阶段。
1)、Bean容器的启动
工厂要生产货物那首先得把工厂运转起来之后才能生产货物。同样bean容器要管理bean也需要先把容器启动起来,获取到bean的定义信息之后才能管理。
1. 读取bean的xml配置文件,然后将xml中每个bean元素分别转换成BeanDefinition对象。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
private volatile Object beanClass;
private String scope = SCOPE_DEFAULT;
private boolean abstractFlag = false;
private boolean lazyInit = false;
private int autowireMode = AUTOWIRE_NO;
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
private String[] dependsOn;
private ConstructorArgumentValues constructorArgumentValues;
private MutablePropertyValues propertyValues;
private String factoryBeanName;
private String factoryMethodName;
private String initMethodName;
private String destroyMethodName;

 BeanClass保存bean的class属性,scop保存Bean的作用域,abstractFlag保存该bean是否抽象,lazyInit保存是否延迟初始化,autowireMode保存是否自动装配,dependencyCheck保存是否坚持依赖,dependsOn保存该bean依赖于哪些bean(这些bean必须提取初始化),constructorArgumentValues保存通过构造函数注入的依赖,propertyValues保存通过setter方法注入的依赖,factoryBeanName和factoryMethodName用于factorybean,也就是工厂类型的bean,initMethodName和destroyMethodName分别对应bean的init-method和destory-method属性。后面会对这些内容进行详细介绍。

2. 通过BeanDefinitionRegistry将bean注册到beanFactory中

上面获取到bean的信息之后,是怎么注册到BeanFactory中的呢?其实是通过BeanDefinitionRegistry将bean注册到beanFactory中。因为BeanFactory的实现类,需要实现BeanDefinitionRegistry 接口。

public interface BeanDefinitionRegistry extends AliasRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException;
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    boolean containsBeanDefinition(String beanName);
    String[] getBeanDefinitionNames();
    int getBeanDefinitionCount();
    boolean isBeanNameInUse(String beanName);
}

BeanDefinitionRegistry接口提供了根据beanName注册对应beanDefinition的方法,而在DefaultListableBeanFactory中实现了该方法,并将beanDefinition保存在了ConcurrentHashMap中。

@SuppressWarnings("serial")
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    /** Map of bean definition objects, keyed by bean name */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);
    
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {
        // ... ...
       this.beanDefinitionMap.put(beanName, beanDefinition);
       }

另外Spring还对外暴露了一些接口用来对bean初始化,例如BeanFactoryPostProcessor。

public interface BeanFactoryPostProcessor {
    /**
     * Modify the application context's internal bean factory after its standard
     * initialization. All bean definitions will have been loaded, but no beans
     * will have been instantiated yet. This allows for overriding or adding
     * properties even to eager-initializing beans.
     * @param beanFactory the bean factory used by the application context
     * @throws org.springframework.beans.BeansException in case of errors
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

我们可以翻译一下postProcessBeanFactory的注释信息,postProcessBeanFactory可以修改应用上下文中已经进行standard初始化的beanFactory,此时所有bean的定义信息已经加载完成,但还未实例化,允许覆盖、新增甚至重新初始化bean信息,一个典型的例子就是属性覆盖器PropertyOverrideConfigurer。对于一些参数可以配置在properties中,而不用配置在Spring的XML配置文件中。

2)、容器Bean的实例化

上面把bean容器启动之后,工厂算是运转起来了,配方(beanDefinition)也已经准备充分,然后就是生产(实例化)、管理货物(bean)了。实例化bean主要通过反射和CGLIB两种方式,在bean的实例化过程中,Spring也暴露了一些接口。
BeanNameAware 获取该bean在配置文件中对应的id
BeanFactoryAware 获取实例化该bean的BeanFactory
InitializingBean bean实例化、所有属性设置后调用初始化方法
DisposableBean 在bean丢弃的时候调用销毁方法
我们可以通过示例演示一下这几个接口的使用。
1. 首先创建了Maven project,pom.xml引入spring-core、spring-context。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>com.demo</groupId>
  <artifactId>BeanFactoryDemo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>BeanFactoryDemo</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>5.0.0.RELEASE</spring.version>
  </properties>
  <dependencies>
     <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

 2. 创建bean对象,实现上面列出的接口

package com.demo.model;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
 
public class UserBean implements BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean {
 
public void setBeanName(String name) {
System.out.println(name);
}
 
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println(beanFactory);
}
 
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean");
}
 
public void destroy() throws Exception {
System.out.println("DisposableBean");
}
}

3. bean配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <bean id="user" class="com.demo.model.UserBean"></bean>
</beans>

 4. 测试

 使用ApplicationContext获取BeanFactory,再通过getBean方法获取到对应的bean,最后调用destroy方法进行销毁,从输出结果可以看到依次调用了BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean接口。

    public static void main( String[] args ) throws Exception
    {
        ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
        BeanFactory factory=context;
        UserBean user=(UserBean)factory.getBean("user");
        user.destroy();
     }

输出结果:user

org.springframework.beans.factory.support.DefaultListableBeanFactory@6bf256fa: defining beans [user]; root of factory hierarchy
InitializingBean
DisposableBean
三、ApplicationContext
在上面的示例中使用了ApplicationContext获取bean的配置,然后直接将ApplicationContext接口 对象赋值给了BeanFactory接口对象,为什么可以赋值呢?其实ApplicationContext接口实现了BeanFactory接口。

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver

从上面ApplicationContext接口的继承关系可以看到,它还通过继承其他接口扩展了BeanFactory的功能。MessageSource:为应用提供国际化访问功能。ResourceLoader:提供资源(如URL和文件系统)的访问支持。ApplicationEventPublisher:引入事件机制,包括启动事件、关闭事件等,让容器在上下文中提供了对应用事件的支持。它代表的是一个应用的上下文环境。beanFactory主要是面对与 spring 框架的基础设施,面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 。所以在上面实例使用的ApplicationContext获取BeanFactory接口对象。

版权声明:本文为5ishare原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/5ishare/p/9498533.html