欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

容器之beanfactory抽丝剥茧系列一

程序员文章站 2023-03-08 18:12:13
1.总所周知,spring ioc功能实现的顶层接口就是BeanFactory。如下面类结构图 这张更加全面: 还有更加变态的 2.BeanFactory为最顶层接口,定义了最核心的需要实现的接口 package org.springframework.beans.factory; public i ......

1.总所周知,spring ioc功能实现的顶层接口就是beanfactory。如下面类结构图

容器之beanfactory抽丝剥茧系列一

这张更加全面:

容器之beanfactory抽丝剥茧系列一

还有更加变态的

容器之beanfactory抽丝剥茧系列一

2.beanfactory为最顶层接口,定义了最核心的需要实现的接口

容器之beanfactory抽丝剥茧系列一
package org.springframework.beans.factory;

public interface beanfactory {

    /**
     * 用来引用一个实例,或把它和工厂产生的bean区分开,就是说,如果一个factorybean的名字为a,那么,&a会得到那个factory
     */
    string factory_bean_prefix = "&";

    /*
     * 四个不同形式的getbean方法,获取实例
     */
    object getbean(string name) throws beansexception;

    <t> t getbean(string name, class<t> requiredtype) throws beansexception;

    <t> t getbean(class<t> requiredtype) throws beansexception;

    object getbean(string name, object... args) throws beansexception;

    boolean containsbean(string name); // 是否存在

    boolean issingleton(string name) throws nosuchbeandefinitionexception;// 是否为单实例

    boolean isprototype(string name) throws nosuchbeandefinitionexception;// 是否为原型(多实例)

    boolean istypematch(string name, class<?> targettype)
            throws nosuchbeandefinitionexception;// 名称、类型是否匹配

    class<?> gettype(string name) throws nosuchbeandefinitionexception; // 获取类型

    string[] getaliases(string name);// 根据实例的名字获取实例的别名

}
view code

3.分层的bean工厂:hierarchicalbeanfactory,定义工厂之间的层级关系

public interface hierarchicalbeanfactory extends beanfactory {

    beanfactory getparentbeanfactory();    //  返回本bean工厂的父工厂

    boolean containslocalbean(string name);    //  本地工厂是否包含这个bean,忽略其他所有父工厂

}

4.可将bean逐一列出的工厂——listablebeanfactory

 

public interface listablebeanfactory extends beanfactory {

    boolean containsbeandefinition(string beanname); // 对于给定的名字是否含有beandefinition

    int getbeandefinitioncount(); // 返回工厂的beandefinition总数

    string[] getbeandefinitionnames(); // 返回工厂中所有bean的名字

    string[] getbeannamesfortype(class<?> type); // 返回对于指定类型bean(包括子类)的所有名字

    /*
     * 返回指定类型的名字 includenonsingletons为false表示只取单例bean,true则不是
     * alloweagerinit为true表示立刻加载,false表示延迟加载。 注意:factorybeans都是立刻加载的。
     */
    string[] getbeannamesfortype(class<?> type, boolean includenonsingletons,
            boolean alloweagerinit);

    <t> map<string, t> getbeansoftype(class<t> type) throws beansexception; // 根据类型(包括子类)返回指定bean名和bean的map

    <t> map<string, t> getbeansoftype(class<t> type,
            boolean includenonsingletons, boolean alloweagerinit)
            throws beansexception;

    map<string, object> getbeanswithannotation(
            class<? extends annotation> annotationtype) throws beansexception; // 根据注解类型,查找所有有这个注解的bean名和bean的map

    <a extends annotation> a findannotationonbean(string beanname,
            class<a> annotationtype);// 根据指定bean名和注解类型查找指定的bean

}

5.自动装配的bean工厂——autowirecapablebeanfactory

容器之beanfactory抽丝剥茧系列一
public interface autowirecapablebeanfactory extends beanfactory {

    int autowire_no = 0;   //  这个常量表明工厂没有自动装配的bean

    int autowire_by_name = 1;  //表明根据名称自动装配

    int autowire_by_type = 2;  //表明根据类型自动装配

    int autowire_constructor = 3;  //表明根据构造方法快速装配

    @deprecated
    int autowire_autodetect = 4;   //表明通过bean的class的内部来自动装配(有没翻译错...)spring3.0被弃用。

    <t> t createbean(class<t> beanclass) throws beansexception;    //  根据指定class创建一个全新的bean实例

    void autowirebean(object existingbean) throws beansexception;  //  给定对象,根据注释、后处理器等,进行自动装配

    /*
     * 根据bean名的beandefinition装配这个未加工的object,执行回调和各种后处理器。
     */
    object configurebean(object existingbean, string beanname) throws beansexception;

    /*
     * 分解bean在工厂中定义的这个指定的依赖descriptor
     */
    object resolvedependency(dependencydescriptor descriptor, string beanname) throws beansexception;

    /*
     * 根据给定的类型和指定的装配策略,创建一个新的bean实例
     */
    object createbean(class<?> beanclass, int autowiremode, boolean dependencycheck) throws beansexception;

    /*
     * 与上面类似,不过稍有不同。
     */
    object autowire(class<?> beanclass, int autowiremode, boolean dependencycheck) throws beansexception;

    /*
     * 根据名称或类型自动装配
     */
    void autowirebeanproperties(object existingbean, int autowiremode, boolean dependencycheck)
            throws beansexception;

    /*
     * 也是自动装配
     */
    void applybeanpropertyvalues(object existingbean, string beanname) throws beansexception;

    /*
     * 初始化一个bean...
     */
    object initializebean(object existingbean, string beanname) throws beansexception;

    /*
     * 初始化之前执行beanpostprocessors
     */
    object applybeanpostprocessorsbeforeinitialization(object existingbean, string beanname)
            throws beansexception;
    /*
     * 初始化之后执行beanpostprocessors
     */
    object applybeanpostprocessorsafterinitialization(object existingbean, string beanname)
            throws beansexception;

    /*
     * 分解指定的依赖
     */
    object resolvedependency(dependencydescriptor descriptor, string beanname,
            set<string> autowiredbeannames, typeconverter typeconverter) throws beansexception;

}
view code

6.复杂的配置bean工厂——configurablebeanfactory

容器之beanfactory抽丝剥茧系列一
public interface configurablebeanfactory extends hierarchicalbeanfactory, singletonbeanregistry {

    string scope_singleton = "singleton";  //  单例

    string scope_prototype = "prototype";  //  原型

    /*
     * 搭配hierarchicalbeanfactory接口的getparentbeanfactory方法
     */
    void setparentbeanfactory(beanfactory parentbeanfactory) throws illegalstateexception;

    /*
     * 设置、返回工厂的类加载器
     */
    void setbeanclassloader(classloader beanclassloader);

    classloader getbeanclassloader();

    /*
     * 设置、返回一个临时的类加载器
     */
    void settempclassloader(classloader tempclassloader);

    classloader gettempclassloader();

    /*
     * 设置、是否缓存元数据,如果false,那么每次请求实例,都会从类加载器重新加载(热加载)

     */
    void setcachebeanmetadata(boolean cachebeanmetadata);
    
    boolean iscachebeanmetadata();//是否缓存元数据

    /*
     * bean表达式分解器
     */
    void setbeanexpressionresolver(beanexpressionresolver resolver);
    
    beanexpressionresolver getbeanexpressionresolver();

    /*
     * 设置、返回一个转换服务
     */
    void setconversionservice(conversionservice conversionservice);

    conversionservice getconversionservice();

    /*
     * 设置属性编辑登记员...
     */
    void addpropertyeditorregistrar(propertyeditorregistrar registrar);

    /*
     * 注册常用属性编辑器
     */
    void registercustomeditor(class<?> requiredtype, class<? extends propertyeditor> propertyeditorclass);

    /*
     * 用工厂中注册的通用的编辑器初始化指定的属性编辑注册器
     */
    void copyregisterededitorsto(propertyeditorregistry registry);

    /*
     * 设置、得到一个类型转换器
     */
    void settypeconverter(typeconverter typeconverter);

    typeconverter gettypeconverter();

    /*
     * 增加一个嵌入式的stringvalueresolver
     */
    void addembeddedvalueresolver(stringvalueresolver valueresolver);

    string resolveembeddedvalue(string value);//分解指定的嵌入式的值

    void addbeanpostprocessor(beanpostprocessor beanpostprocessor);//设置一个bean后处理器

    int getbeanpostprocessorcount();//返回bean后处理器的数量

    void registerscope(string scopename, scope scope);//注册范围

    string[] getregisteredscopenames();//返回注册的范围名

    scope getregisteredscope(string scopename);//返回指定的范围

    accesscontrolcontext getaccesscontrolcontext();//返回本工厂的一个安全访问上下文

    void copyconfigurationfrom(configurablebeanfactory otherfactory);//从其他的工厂复制相关的所有配置

    /*
     * 给指定的bean注册别名
     */
    void registeralias(string beanname, string alias) throws beandefinitionstoreexception;

    void resolvealiases(stringvalueresolver valueresolver);//根据指定的stringvalueresolver移除所有的别名

    /*
     * 返回指定bean合并后的bean定义
     */
    beandefinition getmergedbeandefinition(string beanname) throws nosuchbeandefinitionexception;

    boolean isfactorybean(string name) throws nosuchbeandefinitionexception;//判断指定bean是否为一个工厂bean

    void setcurrentlyincreation(string beanname, boolean increation);//设置一个bean是否正在创建

    boolean iscurrentlyincreation(string beanname);//返回指定bean是否已经成功创建

    void registerdependentbean(string beanname, string dependentbeanname);//注册一个依赖于指定bean的bean

    string[] getdependentbeans(string beanname);//返回依赖于指定bean的所欲bean名

    string[] getdependenciesforbean(string beanname);//返回指定bean依赖的所有bean名

    void destroybean(string beanname, object beaninstance);//销毁指定的bean

    void destroyscopedbean(string beanname);//销毁指定的范围bean

    void destroysingletons();  //销毁所有的单例类

}
view code

在具体介绍之前,先看一下接口singletonbeanregistry的源码:

public interface singletonbeanregistry {

    void registersingleton(string beanname, object singletonobject); //在容器内注册一个单例类  
    
    object getsingleton(string beanname);//返回给定名称对应的单例类

    boolean containssingleton(string beanname);//给定名称是否对应单例类

    string[] getsingletonnames();//返回容器内所有单例类的名字

    int getsingletoncount();//返回容器内注册的单例类数量

}

singletonbeanregistry这个接口非常简单,5个方法,实现了单例类注册的功能。

configurablebeanfactory同时继承了hierarchicalbeanfactory 和 singletonbeanregistry 这两个接口,即同时继承了分层和单例类注册的功能。

7.beanfactory的集大成者:configurablelistablebeanfactory

public interface configurablelistablebeanfactory
        extends listablebeanfactory, autowirecapablebeanfactory, configurablebeanfactory {

    void ignoredependencytype(class<?> type);//忽略自动装配的依赖类型

    void ignoredependencyinterface(class<?> ifc);//忽略自动装配的接口
    /*
     * 注册一个可分解的依赖
     */
    void registerresolvabledependency(class<?> dependencytype, object autowiredvalue);
    /*
     * 判断指定的bean是否有资格作为自动装配的候选者
     */
    boolean isautowirecandidate(string beanname, dependencydescriptor descriptor) throws nosuchbeandefinitionexception;
    /*
     * 返回注册的bean定义
     */
    beandefinition getbeandefinition(string beanname) throws nosuchbeandefinitionexception;

    void freezeconfiguration();//暂时冻结所有的bean配置

    boolean isconfigurationfrozen();//判断本工厂配置是否被冻结

    void preinstantiatesingletons() throws beansexception;//使所有的非延迟加载的单例类都实例化。

}

 

8.额外的接口:beandefinitionregistry

这个接口基本用来操作定义在工厂内部的beandefinition的。我们先来看一下这个接口的父接口:

public interface aliasregistry {

    void registeralias(string name, string alias);//对指定的名称注册别名

    void removealias(string alias);//从当前容器移除指定别名

    boolean isalias(string beanname);//判断指定名称是否为别名

    string[] getaliases(string name);//返回指定名称的所有别名

}

可以看到这4个方法都非常简单,都是用来操作别名的。

再来看一下beandefinitionregistry的源码:

public interface beandefinitionregistry extends aliasregistry {

    void registerbeandefinition(string beanname, beandefinition beandefinition) throws beandefinitionstoreexception;//给定bean名称,注册一个新的bean定义
    /*
     * 根据指定bean名移除对应的bean定义
     */
    void removebeandefinition(string beanname) throws nosuchbeandefinitionexception;
    /*
     * 根据指定bean名得到对应的bean定义
     */
    beandefinition getbeandefinition(string beanname) throws nosuchbeandefinitionexception;
    /*
     * 查找,指定的bean名是否包含bean定义
     */
    boolean containsbeandefinition(string beanname);

    string[] getbeandefinitionnames();//返回本容器内所有注册的bean定义名称

    int getbeandefinitioncount();//返回本容器内注册的bean定义数目

    boolean isbeannameinuse(string beanname);//指定bean名是否被注册过。

}