IOC类图

Posted 叶沐雨

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了IOC类图相关的知识,希望对你有一定的参考价值。

BeanFactory系列

DefaultListableBeanFactory

描述

BeanFactory

定义容器接口。
核心方法:

//从容器中获取bean
Object getBean(String name) throws BeansException;

HierarchicalBeanFactory

扩展容器的层次结构。
核心方法:

//获取父容器
BeanFactory getParentBeanFactory();

ListableBeanFactory

扩展容器的遍历功能,BeanFatory只能使用名称获取bean,ListableBeanFactory可以遍历容器中的bean。
核心方法:

//返回此类(包括子类)的bean,如果type为空,返回所有bean。
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
//返回此类(包括子类)的bean名称。
String[] getBeanNamesForType(@Nullable Class<?> type);

AutowireCapableBeanFactory

扩展自动装配功能,不过此接口一般不在应用中直接使用,也不太常用

SingletonBeanRegistry

该接口定义了共享单例bean实例的注册中心,提供注册单例bean到容器和从容器中获取单例bean的功能,BeanFactory的子类来做实现。
方法:

//注册单例Bean
void registerSingleton(String beanName, Object singletonObject);
//获取单例Bean
Object getSingleton(String beanName);

DefaultSingletonBeanRegistry

核心类,实现了SingletonBeanRegistry接口。实现注册bean,获取bean。
字段:各种map,存放bean

/** Cache of singleton objects: bean name to bean instance. */  
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);  
  
/** Cache of singleton factories: bean name to ObjectFactory. */  
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);  
  
/** Cache of early singleton objects: bean name to bean instance. */  
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);  
  
/** Set of registered singletons, containing the bean names in registration order. */  
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

FactoryBeanRegistrySupport

抽象类,继承DefaultSingletonBeanRegistry,提供FactoryBean的注册。
方法:

//获取FactoryBean创建的Object,不是FactoryBean本身对象
//最终调用object = factory.getObject();使用factory创建对象
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess);

字段:存储factoryBean创建的对象,缓存的原因未知,具体使用场景未知

private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

ConfigurableBeanFactory

接口,继承HierarchicalBeanFactory, SingletonBeanRegistry接口。扩展对BeanFactory配置的功能,内部使用,不在应用程序中使用,应用中应该使用BeanFactory和ListableBeanFactory
核心方法:

void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

ConfigurableListableBeanFactory

接口,继承ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory接口,就当它是一个聚合接口吧,内部使用,使用场景未知。
方法:

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

AbstractAutowireCapableBeanFactory

核心类,抽象类,继承AbstractBeanFactory,实现AutowireCapableBeanFactory。实现了容器的基本功能,主要功能为创建bean。
核心方法:

public <T> T createBean(Class<T> beanClass) throws BeansException;
public Object initializeBean(Object existingBean, String beanName);

BeanDefinitionRegistry

接口,bean定义的注册。

void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
throws BeanDefinitionStoreException;
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

DefaultListableBeanFactory

核心类,继承AbstractAutowireCapableBeanFactory,实现ConfigurableListableBeanFactory, BeanDefinitionRegistry接口,实现一个较完善的BeanFacotry。

public <T> T getBean(Class<T> requiredType) throws BeansException;

ApplicationContext系列

ClassPathXmlApplicationContext

ResourceLoader

加载资源相关

ApplicationContext

核心接口,继承ListableBeanFactory,拥有访问BeanFactory的功能,继承ResourceLoader,拥有加载资源的能力。
方法:

ApplicationContext getParent();
// 暴露AutowireCapableBeanFactory
AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

Lifecycle

生命周明接口

void start();
void stop();
boolean isRunning();

ConfigurableApplicationContext

接口,提供配置ApplicationContext的功能。接口注释中提到此接口是SPI接口,不太懂。
方法:

void setParent(@Nullable ApplicationContext parent);
void setEnvironment(ConfigurableEnvironment environment);
//添加BeanFactoryPostProcessor
void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);
//加载或刷新配置,初始化BeanFactory
void refresh() throws BeansException, IllegalStateException;

AbstractApplicationContext

ApplicationContext的实现,使用模板模式(主要是refresh方法)。
核心方法:

public void refresh() throws BeansException, IllegalStateException   

    synchronized (this.startupShutdownMonitor)   
        // Prepare this context for refreshing.  
        prepareRefresh();  
        // Tell the subclass to refresh the internal bean factory.  
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
        // Prepare the bean factory for use in this context.  
        prepareBeanFactory(beanFactory);  
        try   
            // Allows post-processing of the bean factory in context subclasses.  
            postProcessBeanFactory(beanFactory);  
            // Invoke factory processors registered as beans in the context.  
            invokeBeanFactoryPostProcessors(beanFactory);  
            // Register bean processors that intercept bean creation.  
            registerBeanPostProcessors(beanFactory);  
            // Initialize message source for this context.  
            initMessageSource();  
            // Initialize event multicaster for this context.  
            initApplicationEventMulticaster();  
            // Initialize other special beans in specific context subclasses.  
            onRefresh();  
            // Check for listener beans and register them.  
            registerListeners();  
            // Instantiate all remaining (non-lazy-init) singletons.  
            finishBeanFactoryInitialization(beanFactory);  
            // Last step: publish corresponding event.  
            finishRefresh();  
          
        catch (BeansException ex)   
            if (logger.isWarnEnabled())   
            logger.warn("Exception encountered during context initialization - " +  
            "cancelling refresh attempt: " + ex);  
          
        // Destroy already created singletons to avoid dangling resources.  
        destroyBeans();  
        // Reset \'active\' flag.  
        cancelRefresh(ex);  
        // Propagate exception to caller.  
        throw ex;  
          
        finally   
        // Reset common introspection caches in Spring\'s core, since we  
        // might not ever need metadata for singleton beans anymore...  
        resetCommonCaches();  
          
      

refresh核心步骤

//创建BeanFactory,new一个DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
//执行BeanFactoryPostProcessor,对容器后置处理
//BeanFactoryPostProcessor接口只有postProcessBeanFactory,没有前置处理方法
invokeBeanFactoryPostProcessors(beanFactory);  
//注册BeanPostProcessor
//从容器中遍历BeanPostProcessor,注册到容器
registerBeanPostProcessors(beanFactory);
//完成beanFactory初始化,最重要是的实例化单例bean
//通过调用beanFactory的preInstantiateSingletons(),此方法有DefaultListableBeanFactory实现,是核心方法
finishBeanFactoryInitialization(beanFactory);

AbstractRefreshableApplicationContext

抽象类,AbstractApplicationContext的实现。
主要实现刷新(包括第一次刷新,即启动)容器的功能:

  1. 刷新BeanFatory,如果已存在,则删除重新创建BeanFactory
  2. 加载不同配置(xml,文件,等)到BeanFactory
    方法:
// 实现了父类AbstractApplicationContext中的刷新容器方法
protected final void refreshBeanFactory() throws BeansException;
// 加载bean定义到BeanFactory
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)  
throws BeansException, IOException;

Aware

标记接口,无任何方法,只是作为标记,有时候很有用。
Aware的作用是标识bean有可以回调来从容器中获取某种信息。

BeanNameAware

从容器中获取beanName

// 并不是设置name,参数的name是容器暴露出来的,用于我们使用
void setBeanName(String name);

InitializingBean

接口,由bean来实现,在bean的属性被设置后调用,处理自定义的初始化操作

void afterPropertiesSet() throws Exception;

AbstractRefreshableConfigApplicationContext

抽象类,设置配置文件路径

public void setConfigLocation(String location);

AbstractXmlApplicationContext

抽象类,处理xml类型的配置文件加载解析

ClassPathXmlApplicationContext

提供参数为xml配置文件路径的构造方法

AnnotationConfigApplicationContext

注解AnnotationConfigApplicationContext并不是继承AbstractRefreshableApplicationContext或AbstractRefreshableConfigApplicationContext,而是继承的AbstractApplicationContext,AbstractApplicationContext中有最核心的refresh流程

GenericApplicationContext

通用ApplicationContext实现,它持有单个内部DefaultListableBeanFactory实例。ClassPathXmlApplicationContext并没有继承自此类,但是此类也可以用于读取xml配置文件做ApplicationContext。此类可用于自定义的ApplicationContext。
典型的用法是通过BeanDefinitionRegistry接口注册各种bean定义,然后调用refresh()初始化这些bean。
使用示例:

GenericApplicationContext ctx = new GenericApplicationContext();
XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx);
xmlReader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
PropertiesBeanDefinitionReader propReader = new PropertiesBeanDefinitionReader(ctx);
propReader.loadBeanDefinitions(new ClassPathResource("otherBeans.properties"));
ctx.refresh();

MyBean myBean = (MyBean) ctx.getBean("myBean");

方法:

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
throws BeanDefinitionStoreException;

AnnotationConfigRegistry

用于注释配置应用程序上下文的公共接口,定义注册和扫描方法。

//注册带注解的类
void register(Class<?>... annotatedClasses);
void scan(String... basePackages);

AnnotationConfigApplicationContext

注解配置ApplicationContext
方法:

// 使用时就是调用构造方法,构造方法中传入配置类,然后注册配置中的bean,refresh
//this()无参构造,会注册一个ConfigurationClassPostProcessor,来处理@Configuration,@Bean,@Import等注解,把注入的bean注册到容器中
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses)   
	this();  
	register(annotatedClasses);  
	refresh();  

spring学习-IOC-生命周期简介

spring的创建,依赖ApplicationContext上下文

常用ApplicationContext-三个:

  • 先看下应用上下文的简单类图:

  • ClassPathXmlApplicationContext 加载类路径下的xml配置文件(优先于FileSystemXmlApplicationContext使用)

  • AnnotationConfigApplicationContext 读取注解创建容器的

  • FileSystemXmlApplicationContext 加载磁盘路径下的配置文件

  • 容器两个核心接口类:

    • ApplicationContext:单例对象适用
      • 构建核心容器时,创建对象采取的策略是,采用立即加载的方式
    • BeanFactory:多例对象适用
      • 构建核心容器时,创建对象采取的策略时,延迟加载的方式:即什么时候获取,什么时候才加载
  • Bean的作用范围:

    • singleton
    • prototype
    • request:作用于web应用的请求范围
    • session:作用于web应用的会话范围
    • global-session:作用于集群环境会话范围(全局会话范围),当不是集群范围时,它就是session

    关于session、request相关的,这里不做描述

bean的生命周期

生命周期单例多例
创建IOC初始化即创建使用时创建
运行IOC活着即可使用创建后一直可用
销毁IOC关闭时长时间不用时,由java的垃圾回收器搞定
  • xml定义:
<!--bean的生命周期-->
<bean id="birdLife" class="ioc3.Fly" scope="singleton"
      init-method="init" destroy-method="destroy”/>
  • 代码:
public class Fly 
    public void say() 
        System.out.println("I can fly");
    
    public void init() 
        System.out.println("Fly init...");
    
    public void destroy() 
        System.out.println("Fly destroy...");
    

  • Main测试:
System.out.println("========== bean的生命周期 ==========");
ClassPathXmlApplicationContext beanFactory1 = new ClassPathXmlApplicationContext("ioc3-scope.xml");
Fly flyLife = beanFactory1.getBean("birdLife", Fly.class);
flyLife.say();
beanFactory1.close();
  • 输出:
========== bean的生命周期 ==========
Fly init...
I can fly
Fly destroy...
  • 备注:
    • 单例时,销毁需要手动调用close才可以观察到
    • 多例时,不容易观察

参考自:IT黑马

以上是关于IOC类图的主要内容,如果未能解决你的问题,请参考以下文章

spring源码之IOC的依赖注入

spring学习-IOC-生命周期简介

spring学习-IOC-生命周期简介

Spring IOC源代码具体解释之容器初始化

03Spring源码-手写篇-手写AOP实现(上)

03Spring源码-手写篇-手写AOP实现(上)