BeanFactory处理IOC依赖关系

BeanFactory API简单介绍

Spring IOC容器是一个IOC服务提供者，是一个提供IOC支持的轻量级容器，除了IOC支持外还提供了AOP支持及企业服务集成服务，Spring IOC容器与一般IOC service Provider 提供的服务之间存在着一定的交集。

在这里插入图片描述

spring在容器类型上提供了两种容器类型：BeanFactory与ApplicationContext。
两者的区别：
BeanFactory.这是一个基础类型的Ioc容器。默认使用懒加载模式（当用户需要访问受管理的对象时候，才对管理的对象进行初始化及依赖注入操作）。有事在于启动初期的速度快。需要的资源有限。

ApplicationContext.是在BeanFactory上构建的高级容器实现。除了拥有BeanFactory所有支持，也提供了高级特效。包含事件发布，国际化。默认该类型容器在启动后，会初始化全部管理的bean，因而启动时间较长。同时提供更多功能

在这里插入图片描述

两者之间存在的依赖关系如上图所示。

BeanFactory会提供一个获取组装完对象的方法接口。这里贴出一下beanFactory的定义下：

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {


    String FACTORY_BEAN_PREFIX = "&";
    
    Object getBean(String name) throws BeansException;


    <T> T getBean(String name, Class<T> requiredType) throws BeansException;


    Object getBean(String name, Object... args) throws BeansException;


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


    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

 
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);


    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);


    boolean containsBean(String name);


    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

  
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

   
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;


    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;


    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

  
    String[] getAliases(String name);

}

FACTORY_BEAN_PREFIX 这个属性的前缀可以使用这个前缀获取实际的BeanFactory地址.在当前版本的Factory中提供了5种获取Bean的方法，还提供了bean类型校验，类型获取的方法，bean作用域的判定方法等。在一般情况下，对于独立的应用，只有主入口会与容器API直接耦合。

拥有BeanFactory的不同之处

不同之处就一处。对象之间的依赖关系解决方式变了。最早如果没有IOC容器，需要我们手动new创建一个对象，并将其中存在的依赖关系一个个的通过注入的方式，注入到对象当中，当需要多次使用这个对象的时候，多次创建对象并且手动处理这个依赖关系是一个非常巨大的工作量，有了IOC后，BeanFactory创建对象的过程中会依赖关系进行自动注入，减少了大量的工作量。
至于BeanFactory记录对象之间的依赖关系的方式，可以参照上一篇文章：IOC如何管理对象之间的依赖关系

Spring管理依赖关系的三种方式：

IOC一般有三种管理bean之间依赖关系的方式，spring对这三种方式全部支持：

编码方式：

编码方式管理bean之间的依赖关系其实并不是说特别的准确，因为不管是配置文件的方式还是注解的方式最终的话都是会被转为编码的方式进行处理。使用编码方式处理bean之间的依赖关系的步骤三步走：

 - 将即将管控的对象bean每个创建一个BeanDefinition
 - 将BeanDefinition注册到相应容器中
 - 使用构造函数注入，setter注入的方式，处理BeanDefinition之间的依赖关系

经过处理后可以使用BeanFactory的getBean()直接获得已经注入了依赖对象值的bean对象。以编码方式呈现出来的话就是如下的效果：

public class CodeMethod {
    
    
    private static BeanFactory bindVidCode(BeanDefinitionRegistry registry) {
        //定义bean
        AbstractBeanDefinition a=new RootBeanDefinition(Aclass.class);
        AbstractBeanDefinition b=new RootBeanDefinition(Bclass.class);
        AbstractBeanDefinition ab=new RootBeanDefinition(ABclass.class);
        //注册bean
        registry.registerBeanDefinition("a", a);
        registry.registerBeanDefinition("b", b);
        registry.registerBeanDefinition("c", ab);
        
        /**
         * 对象的依赖关系处理
         */
        
        //1.构造器注入
        ConstructorArgumentValues argValues=new ConstructorArgumentValues();
        argValues.addIndexedArgumentValue(0, a);
        argValues.addIndexedArgumentValue(1, b);
        ab.setConstructorArgumentValues(argValues);
        
        //2.setter注入
        MutablePropertyValues propertyValues=new MutablePropertyValues();
        propertyValues.addPropertyValue(new PropertyValue("a",a));
        propertyValues.addPropertyValue(new PropertyValue("b",b));
        ab.setPropertyValues(propertyValues);
        
        return (BeanFactory)registry;
    }
    
    
    public static void main(String[] args) {
        BeanDefinitionRegistry registry=new DefaultListableBeanFactory();
        BeanFactory beanFactory= (BeanFactory)bindVidCode(registry);
        
        ABclass ab=beanFactory.getBean(ABclass.class);
        Aclass a=ab.getA();
        Bclass b=ab.getB();
        a.say();
        b.listen(); 
    }
}

这里的编码中出现了两个类。DefaultListableBeanFactory，BeanDefinition，在此介绍一下其作用。

DefaultListableBeanFactory：这是一个BeanFactory的常见实现类，在实现了BeanFactory的同时，也实现了注册接口BeanDefinitionRegistry，因而在上述代码的过程中有使用强转BeanDefinitionRegistry为BeanFactory，事实上如果一个BeanDefinitionRegistry实现类没有实现BeanFactory的情况下二者是不能强转成功的。BeanDefinitionRegistry类似于BeanFactory中bean的管理员，它管理着BeanDefinition之间的存放位置，例如A箱子跟B箱子谁该放在谁里面，购买新箱子这些工作都由BeanDefinitionRegistry管控。

BeanDefinition：每一个受容器托管的对象在容器中都会有一个BeanDefinition与之对应。BeanDefinition存储着受托管对象的全部信息，包括了对象类型，是否是抽象的，构造方法参数及其他属性，类似于箱子的存在。这里的例子中使用了其常见的实现类RootBeanDefinition。

以上的类之间的类图关系呈现如下：

在这里插入图片描述

外部配置文件的方式：

spring IOC支持两种配置文件格式：Properties/XML文件格式。也可以自己引入自己的文件格式。对于不同的文件格式。Spring会给出相应的处理方式，外部配置文件的处理不走一般分为4步

Spring判断外部文件类型根据不同的文件类型给出不同的BeanDefinitionReader。
BeanDefinitionReader负责把配置文件内容读取并映射到BeanDefinition.。
将映射好的BeanDefinition注册到BeanDefinitionRegistry
由BeanDefinitionRegistry完成bean注册加载

先讲Properties配置格式文件的加载：

核心：PropertiesBeanDefinitionReader

此处用例与编码时候的用例一致。都是使用构造器注入，setter处理bean之间的依赖关系，唯一不同的是新增了记录依赖关系的载体。格式如下所示：

ab.(class)=com.example.demo.core.bean.ABclass
a.(class)=com.example.demo.core.bean.impl.Aclass
b.(class)=com.example.demo.core.bean.impl.Bclass

#by construction
ab.$0(ref)=a
ab.$1(ref)=b

#by setter
ab.a(ref)=a
ab.b(ref)=b

解释下，此处的ab，a，b为变量名称可以随意起名，.（class）之后的信息是类的完整路径名，通过这个将变量与类挂钩起来构建beanDefinition。使用构造注入的时候使用$N(ref) 指向已经定义好的beanDefinition信息，N代表的是参数的位置，起始下标为0，使用setter注入的场合，则可以直接使用.属性（ref）的方式，将属性指向已经定义好的beanDefinition。完成注入。调用的时候通过加载这个配置文件，可以将配置文件信息映射到容器中，加载依赖关系，之后通过BeanFactory完成返回Bean的工作，类似于编码方式，只是把代码处理依赖关系的过程转交给了PropertiesBeanDefinitionReader

测试代码如下：

public class PropertiesCore {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanRegistry=new DefaultListableBeanFactory();
        BeanFactory provider=bindViaPropertiesFile(beanRegistry);
        
       ABclass ab=provider.getBean(ABclass.class);
       Aclass a=ab.getA();
       Bclass b=ab.getB();
       a.say();
       b.listen();
    }
    
    private static BeanFactory bindViaPropertiesFile(BeanDefinitionRegistry registry) {
        PropertiesBeanDefinitionReader reader=new PropertiesBeanDefinitionReader(registry);
        reader.loadBeanDefinitions("classpath:simple.properties");
        return (BeanFactory)registry;
    }
}

XML配置格式加载依赖关系：
xml是Spring支持的最完整的，功能最强大的表达式。同Properties文件的加载方式类似。而且语义相对的更加方便理解，对于构造注入与setter注入，给出如下的配置文件：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="a" class="com.example.demo.core.bean.impl.Aclass"></bean>
    <bean id="b" class="com.example.demo.core.bean.impl.Bclass"></bean>
    <bean id="ab" class="com.example.demo.core.bean.ABclass">
        <!-- 构造注入 -->
        <constructor-arg index="0">
            <ref bean="a"/>
        </constructor-arg>
        <constructor-arg index="1">
            <ref bean="b"/>
        </constructor-arg>
        <!-- setter注入  -->
        <property name="a" ref="a"></property>
        <property name="b" ref="b"></property>
    </bean>
</beans>

调用时候同Properties:

public class XMLCore {
    //装载xml中的依赖关系
    private static BeanFactory bindViaXmlFile(BeanDefinitionRegistry registry) {
      XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader(registry);
      reader.loadBeanDefinitions("classpath:simple.xml");
      return (BeanFactory)registry;
    }
    
    public static void main(String[] args) {
        DefaultListableBeanFactory registry=new DefaultListableBeanFactory();
        BeanFactory beanFactory=bindViaXmlFile(registry);
        ABclass ab=beanFactory.getBean(ABclass.class);
        
        Aclass a=ab.getA();
        Bclass b=ab.getB();
        
        a.say();
        b.listen();
    }
}

注解方式处理依赖关系

spring在2.5版本之后才支持的注解方式处理依赖关系。具体的操作为，使用标签@Autowired及@Component对相关的类进行标记。

这个方式在目前springboot流行的情况下非常受欢迎。在之前的版本中一般配合xml文件classpath-scanning一起使用，目前已经可以使用spring标签@ComponentScan替代了，springboot的默认设置还可以免去繁琐的xml文件配置。

具体使用如下：

@Component
public class Aclass implements AClass{
    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("hello spring");
    }
}


@Component
public class ABclass {
    @Autowired
    private Aclass a;
    @Autowired
    private Bclass b;
    public ABclass(Aclass a, Bclass b) {
        super();
        this.a = a;
        this.b = b;
    }
    public ABclass() {
        super();
    }
    public Aclass getA() {
        return a;
    }
    public void setA(Aclass a) {
        this.a = a;
    }
    public Bclass getB() {
        return b;
    }
    public void setB(Bclass b) {
        this.b = b;
    }
    
    
}


@Component
public class Bclass implements BClass{
    @Override
    public void listen() {
        // TODO Auto-generated method stub
        System.out.println("try listen");
    }
}

@ComponentScan("com.example.demo")
public class AutowiredCore {
    
    public static void main(String[] args) {
        ApplicationContext ctx=new AnnotationConfigApplicationContext(AutowiredCore.class);
        ABclass ab=ctx.getBean(ABclass.class);
        Aclass a=ab.getA();
        Bclass b=ab.getB();
        
        a.say();
        b.listen();
    }
}

附上全文整理的Demo：
github下载地址