BeanDefinition及其实现类

【转自 http://blog.csdn.net/u011179993 】

目录(?)[+]

一、 BeanDefinition及其实现类

BeanDefinition接口

这个接口描述bean的结构，对应XML中的< bean >或者配置类中的@Bean 
它集成了BeanMetadataElement和AttributeAccessor，如下图 
 
【AttributeAccessor接口】 
类似于map，具有保存和访问name/value属性的能力

public interface AttributeAccessor {
    void setAttribute(String name, Object value);
    Object getAttribute(String name);
    Object removeAttribute(String name);
    boolean hasAttribute(String name);
    String[] attributeNames();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

【BeanMetadataElement接口】 
实现此接口的类，访问source（配置源）的能力

public interface BeanMetadataElement {
    Object getSource();
}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

【BeanDefinition接口】 
定义了设置、获取一个BeanDefinition属性方便方法（比如获取scope属性直接使用getScope()）

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

    //单例或原型
    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

     //Bean角色
    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;

    // 返回/设置父BeanDefinition
    String getParentName();
    void setParentName(String parentName);

    //返回/设置 当前的BeanClassName（不等于最终Bean的名称）
    String getBeanClassName();
    void setBeanClassName(String beanClassName);

    //返回设置 factory bean name
    String getFactoryBeanName();
    void setFactoryBeanName(String factoryBeanName);

    String getFactoryMethodName();
    void setFactoryMethodName(String factoryMethodName);

    String getScope();
    void setScope(String scope);

    boolean isLazyInit();
    void setLazyInit(boolean lazyInit);

    String[] getDependsOn();
    void setDependsOn(String... dependsOn);

    boolean isAutowireCandidate();
    void setAutowireCandidate(boolean autowireCandidate);

    boolean isPrimary();
    void setPrimary(boolean primary);

    ConstructorArgumentValues getConstructorArgumentValues();

    MutablePropertyValues getPropertyValues();
    boolean isSingleton();
    boolean isPrototype();
    boolean isAbstract();
    int getRole();
    String getDescription();
    String getResourceDescription();
    BeanDefinition getOriginatingBeanDefinition();

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

BeanDefinition的子接口和实现类

【AnnotatedBeanDefinition 接口】

这个接口可以获取BeanDefinition注解相关数据

public interface AnnotatedBeanDefinition extends BeanDefinition {
    AnnotationMetadata getMetadata();
    MethodMetadata getFactoryMethodMetadata();
}
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

【AbstractBeanDefinition】

这个抽象类的构造方法设置了BeanDefinition的默认属性，重写了equals，hashCode，toString方法。

【ChildBeanDefinition】

可以从父BeanDefinition中集成构造方法，属性等

【RootBeanDefinition】

代表一个从配置源（XML，JavaConfig等）中生成的BeanDefinition

GenericBeanDefinition

GenericBeanDefinition是自2.5以后新加入的bean文件配置属性定义类，是ChildBeanDefinition和RootBeanDefinition更好的替代者

【AnnotatedGenericBeanDefinition】

对应注解@Bean

@Component("t")
public class Tester {
    public static void main(String[] args) throws Exception {
        AnnotatedGenericBeanDefinition beanDefinition=new AnnotatedGenericBeanDefinition(Tester.class);
        System.out.println(beanDefinition.getMetadata().getAnnotationTypes());
        System.out.println(beanDefinition.isSingleton());
        System.out.println(beanDefinition.getBeanClassName());
    }
}

==========输出==============
[org.springframework.stereotype.Component]
true
Tester
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

二 、BeanDefinitionHolder

BeanDefinitionHolder

持有一个BeanDefinition，名称，和别名数组。在spring内部，它用来临时保存BeanDefinition来传递BeanDefinition。 
它的部分方法如下：

public class BeanDefinitionHolder implements BeanMetadataElement {

    private final BeanDefinition beanDefinition;
    private final String beanName;
    private final String[] aliases; 

    public BeanDefinitionHolder(BeanDefinition beanDefinition, String beanName, String[] aliases) {
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        Assert.notNull(beanName, "Bean name must not be null");
        this.beanDefinition = beanDefinition;
        this.beanName = beanName;
        this.aliases = aliases;
    }
    public BeanDefinition getBeanDefinition() {
        return this.beanDefinition;
    }
    public String getBeanName() {
        return this.beanName;
    }
    public String[] getAliases() {
        return this.aliases;
    }
    //其他方法...省略
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

三、BeanDefinitionRegistry接口

这个接口定义了‘注册/获取BeanDefinition’的方法 。 
接口定义：

public interface BeanDefinitionRegistry extends AliasRegistry {
    //注册一个BeanDefinition
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;
    //根据name,从自己持有的多个BeanDefinition 中 移除一个
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    // 获取某个BeanDefinition
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    boolean containsBeanDefinition(String beanName);//是否包含
    String[] getBeanDefinitionNames();//获取所有名称
    int getBeanDefinitionCount();//获取持有的BeanDefinition数量
    boolean isBeanNameInUse(String beanName); //判断某个BeanDefinition是否在使用
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

实现类一般使用Map保存多个BeanDefinition,如下：

Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();
  • 1
  • 1

实现类有SimpleBeanDefinitionRegistry，DefaultListableBeanFactory，GenericApplicationContext等。

SimpleBeanDefinitionRegistry

SimpleBeanDefinitionRegistry是最基本的实现类。 
使用：

public static void main(String[] args) throws Exception {

    //实例化SimpleBeanDefinitionRegistry
    SimpleBeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();

    //注册两个BeanDefinition
    BeanDefinition definition_1 = new GenericBeanDefinition();
    registry.registerBeanDefinition("d1", definition_1);

    BeanDefinition definition_2 = new RootBeanDefinition();
    registry.registerBeanDefinition("d2", definition_2);

    //方法测试
    System.out.println(registry.containsBeanDefinition("d1"));//true
    System.out.println(registry.getBeanDefinitionCount());//2
    System.out.println(Arrays.toString(registry.getBeanDefinitionNames()));//[d1, d2]
}

================结果==================
true
2
[d1, d2]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

四、BeanDefinitionReader接口

BeanDefinitionRegistry接口一次只能注册一个BeanDefinition，而且只能自己构造BeanDefinition类来注册。BeanDefinitionReader解决了这些问题，它一般可以使用一个BeanDefinitionRegistry构造，然后通过#loadBeanDefinitions（..）等方法，把“配置源”转化为多个BeanDefinition并注册到BeanDefinitionRegistry中 。 
可以说BeanDefinitionReader帮助BeanDefinitionRegistry实现了高效、方便的注册BeanDefinition。

BeanDefinitionReader接口定义如下：

public interface BeanDefinitionReader {
    //获取BeanDefinitionRegistry
    BeanDefinitionRegistry getRegistry();

    ResourceLoader getResourceLoader();

    ClassLoader getBeanClassLoader(); 

    //获取Bean的名称生成器
    BeanNameGenerator getBeanNameGenerator();

    //载入BeanDefinition
    int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

     //载入BeanDefinition
    int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;

     //载入BeanDefinition
    int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;

     //载入BeanDefinition
    int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

类的体系结构

AbstractBeanDefinitionReader：实现了EnvironmentCapable，提供了获取/设置环境的方法。定义了一些通用方法，使用策略模式，将一些具体方法放到子类实现。 
XmlBeanDefinitionReader：读取XML文件定义的BeanDefinition 
PropertiesBeanDefinitionReader：可以从属性文件，Resource，Property对象等读取BeanDefinition 
GroovyBeanDefinitionReader：可以读取Groovy语言定义的Bean

实现类：XmlBeanDefinitionReader

把xml配置文件转化成beanDefinition

这个类就不做演示了
  • 1
  • 1

实现类： PropertiesBeanDefinitionReader

可以从Properties文件读取BeanDefinition，文件可以是如下结构：

#bean名称.(属性)=值
==========================
mybean.(class)=PropertyReaderTest
mybean.(abstract)=true
mybean.(lazy-init)=true
mybean.(scope)=prototype
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

程序实例：

public class PropertyReaderTest {
    public static void main(String[] args) {
        //定义BeanDefinitionRegistry
        BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
        //使用BeanDefinitionRegistry实例 构造BeanDefinitionReader
        PropertiesBeanDefinitionReader reader = new PropertiesBeanDefinitionReader(registry);
        //载入文件
        reader.loadBeanDefinitions("config.properties");

        System.out.println(registry.getBeanDefinition("mybean"));
    }
} 

================输出=================
.......//日志信息 略
Generic bean: class [PropertyReaderTest]; scope=prototype; abstract=true; lazyInit=true; autowireMode=0; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; initMethodName=null; destroyMethodName=null
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

五、读取注解定义的BeanDefinition

注解相关的BeanDefinitionReader并没有实现BeanDefinitionReader接口，有如下类：

AnnotatedBeanDefinitionReader类

使用如下：

SimpleBeanDefinitionRegistry registry= new SimpleBeanDefinitionRegistry();
AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(registry);
reader.register(Tester.class);
System.out.println( registry.getBeanDefinitionCount());

=========================
7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

我们只注册了一个Bean，为什么出现7个呢？原来是AnnotatedBeanDefinitionReader 向BeanDefinitionRegistry自动注册了6个BeanDefinition。这个在以后章节中详解。

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner 继承自ClassPathScanningCandidateComponentProvider 
类结构如下： 

【ClassPathScanningCandidateComponentProvider】 
这个类的findCandidateComponents可以扫描到@Component @Repository @Service @Controller 的BeanDefinition，并加入Set 集合中

ClassPathScanningCandidateComponentProvider provider=new ClassPathScanningCandidateComponentProvider(true);
Set<BeanDefinition> definitionSet= provider.findCandidateComponents("com.jazz.web");
System.out.println(definitionSet.size());
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

【ClassPathBeanDefinitionScanner】

这里写代码片
时间： 2024-10-31 13:43:01

BeanDefinition及其实现类的相关文章

Spring IOC的实现

来源:知乎 https://www.zhihu.com/question/21035417/answer/142858103 著作权归作者所有. Spring IOC的实现部分,主要分为三个部分: 第一步: Resouce:首先我们需要获取beanDefinition的资源,我们将通过Spring的resource接口获得bean的资源,这一步也叫做bean资源的定位,下面是Spring内置的一些典型实现,当然,你也可以根据自己的需要实现自己的resource: ClassPathResourc

使用Spring处理自定义注解

使用Spring处理自定义注解 本文只讲思想,不讲代码. 可能的两种方法 spring schema spring aop aspect 参考1 dubbo service 包名:com.alibaba.dubbo.config 参考2 spring mvc 包名:org.springframework.web.servlet.config 可以参考这两个的实现,利用schema添加自定义注解并处理自己的注解,注册搜索模块. 源码分析 通过schema添加配置解析如: 在 spring配置文件中

spring揭秘 读书笔记 二 BeanFactory的对象注冊与依赖绑定

本文是王福强所著<<spring揭秘>>一书的读书笔记 我们前面就说过,Spring的IoC容器时一个IoC Service Provider,并且IoC Service Provider提供两个功能对象的创建,依赖关系的管理. 只是,IoC容器这个词中,我们还得关注容器二字.它还包括了一些别的功能,例如以下图 Spring提供了两种类型的容器,各自是BeanFactory与ApplicationContext. 它们的差别在于: BeanFactory:对于它所管理的bean,採

spring浅析(一)

一.什么是spring? spring是一个基于Java的应用平台,是一个开源的框架,他同EJB一样都是为了为松耦合的POJO类提供中间服务件,框架将服务注入给POJO类,POJO类无需关注如何去连接服务,从而达到将应用开发与复杂的J2EE服务解耦开来,从而简化J2EE的开发,而对于这些功能的具体实现,就要涉及到spring的核心模块IOC,AOP. 二.什么是IOC容器 IOC叫控制反转(IOC)或称依赖注入(DI),两个名称其实说的是同一回事,只是侧重点各有不同,控制反转侧重于,对象的实例化

Spring依赖注入 --- 简单使用说明

Spring依赖注入 --- 简单使用说明 本文将对spring依赖注入的使用做简单的说明,enjoy your time! 1.使用Spring提供的依赖注入 对spring依赖注入的实现方法感兴趣的同学可以参考我的日志:http://www.cnblogs.com/kodoyang/p/Frame_Imitate_Spring.html 我们会用spring提供的ClassPathXmlApplicationContext实现来代替这篇日志中相应的实现 为导入的jar文件配置api 对应的L

Spring源码分析之IOC容器（一）

Spring作为当今风靡世界的Web领域的第一框架,作为一名Java开发程序员是一定要掌握的,除了需要掌握基本的使用之外,更需要掌握其实现原理,因为我们往往在开发的过程中,会出现各种各样的异常问题.而且这样的问题去百度有时候往往也找不到特别有效的解决方法,因为问题的原因非常多而百度的又不准确,这个时候怎么办呢?在熟练掌握Spring代码的情况下,我们可以根据提示的异常信息,去跟到源代码的地方,可以准确的定位到异常的所在,这就犹如debug调试自己的业务逻辑一样轻松了,所以Spring的源代码非常

Atitit.spring体系结构大总结

1. Srping mvc 1 2. Ioc 4 3. ApplicationContext在BeanFactory的基础上构建,区别 4 4. Aop 5 5. 3.2.4.1. @AspectJ形式的SpringAOP 5 6. spring的定时器 6 7. spring的事务处理 6 8. spring与struts的整合 6 9. spring与hibernate的整合 6 10. spring的持久层封装 使用jdbctemptate访问数据 6 11. 2.3.1.3.7. 方法注

spring揭秘 读书笔记 二

本文是王福强所著<<spring揭秘>>一书的读书笔记 我们前面就说过,Spring的IoC容器时一个IoC Service Provider,而且IoC Service Provider提供两个功能对象的创建,依赖关系的管理. 不过,IoC容器这个词中,我们还得关注容器二字.它还包含了一些别的功能,如下图 Spring提供了两种类型的容器,分别是BeanFactory与ApplicationContext. 它们的区别在于: BeanFactory:对于它所管理的bean,采取的

Spring IOC 标签的解析

Spring IOC 标签的解析 上一篇文章说了Spring中的标签包括默认标签和自定义标签两种,本节继续来研究默认标签的解析,parseBeanDefinitions方法为解析标签的总入口 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.get