【Spring入门-03】IoC 容器

Spring IoC

概念

IoC（Inverse of Control）——控制反转

• 控制：控制对象的创建与销毁（生命周期）
• 反转：将对象的控制权交给 IoC 容器

通过使用 IoC 容器，对象依赖关系的管理被反转了，转到 IoC 容器中，对象之间的相互依赖关系由 IoC 容器进行管理，并由 IoC 容器完成对象的注入。IoC 容器为开发者管理对象之间的依赖关系提供了很多便利和基础服务。

Spring 实例化 Bean

1. 构造方法实例化

public class Bean1 {
    public Bean1() {
        System.out.println("Bean1");
    }
}

    <bean id="bean1" class="com.chen.bean.Bean1"/>

2. 静态方法实例化

public class Bean2 {
    public Bean2() {
        System.out.println("Bean2");
    }
}

public class BeanFactory {
    public static Bean2 getBean2() {
        return new Bean2();
    }
}

    <bean id="bean2" class="com.chen.bean.BeanFactory"
          factory-method="getBean2"/>

3. 实例方法实例化

public class Bean3 {
    public Bean3() {
        System.out.println("Bean3");
    }
}

public class BeanFactory {
    public Bean3 getBean3() {
        return new Bean3();
    }
}

    <bean id="beanFactory" class="com.chen.bean.BeanFactory"/>
    <bean id="bean3" factory-bean="beanFactory" factory-method="getBean3"/>

Spring 管理 Bean 的别名

Spring 可以通过 name 属性，或 <alias> 标签指定 Bean 的别名。

    <bean id="bean1" class="com.chen.bean.Bean1" name="bean1_1,bean1_2"/>
    <alias name="bean1" alias="bean1_3"/>

Spring 注入 Bean

以 Bean 类为例：

public class Bean {

    private Bean1 bean1;
    private String name1;
    private Bean2 bean2;
    private String name2;
    private List<Bean1> bean1List;
    private Map<String, Bean1> bean1Map;
    private Set<Bean1> bean1Set;
    private Properties properties;
    private Bean3 bean3;
    private Bean3 bean33;

    public Bean(Bean1 bean1, String name1) {
        this.bean1 = bean1;
        this.name1 = name1;
    }
    
    // Setter 
    ...
}

1. 构造注入

    <bean id="bean" class="com.chen.bean.Bean">
        <constructor-arg index="0" name="bean1" ref="bean1" type="com.chen.bean.Bean1"/>
        <constructor-arg index="1" name="name1" value="111" type="java.lang.String"/>
    </bean>

2. 设值注入

    <bean id="bean" class="com.chen.bean.Bean">
        <property name="bean2" ref="bean2"/>
        <property name="name2" value="222"/>
    </bean>

3. 设值集合注入

    <bean id="bean" class="com.chen.bean.Bean">
        <property name="bean1List">
            <list>
                <ref bean="bean1"/>
                <ref bean="bean1"/>
            </list>
        </property>
        <property name="bean1Map">
            <map>
                <entry key="aa" value-ref="bean1"/>
                <entry key="bb" value-ref="bean1"/>
            </map>
        </property>
        <property name="bean1Set">
            <set>
                <ref bean="bean1"/>
                <ref bean="bean1"/>
            </set>
        </property>
        <property name="properties">
            <props>
                <prop key="database">MySQL</prop>
            </props>
        </property>
    </bean>

4. null 值注入

    <bean id="bean" class="com.chen.bean.Bean">
        <property name="bean3">
            <null/>
        </property>
    </bean>

5. 注入内部 Bean

    <bean id="bean" class="com.chen.bean.Bean">
        <property name="bean33">
            <bean class="com.chen.bean.Bean3"/>
        </property>
    </bean>

两个核心接口

Spring 有两个核心接口：BeanFactory 和 ApplicationContext，其中 ApplicationContext 是 BeanFactory 的子接口。

1. BeanFactory

BeanFactory 提供了简单容器的基本功能，在容器启动时不会实例化 Bean，只有需要从容器中获取 Bean 时才会实例化（延迟实例化）。

1. 提供了 IOC 的配置机制
2. 包含 Bean 的各种定义，便于实例化 Bean
3. 建立 Bean 之间的依赖关系
4. Bean 生命周期的控制

getBean() 方法

1. 转换 beanName
2. 从缓存中加载实例
3. 实例化 Bean
4. 检测 parentBeanFactory
5. 初始化依赖的 Bean
6. 创建 Bean

区分 BeanFactory 和 FactoryBean
BeanFactory 是 Factory ，是 IoC 容器。
FactoryBean 是 Bean ，在 Spring 中，所有的 Bean 都是由 BeanFactory（也就是IoC容器）来进行管理的。

2. ApplicationContext

ApplicationContext 也称为 Spring 应用上下文，继承 BeanFactory 接口，是更高级的容器，在容器启动时就会把所有的 Bean 实例化（可通过配置参数 lazy-init=true 实现延迟实例化），提供了更多的高级功能。它继承了多个接口

• BeanFactory：管理、装配 Bean
• ResourcePatternResolver：加载资源文件
• MessageSource：实现国际化等功能
• ApplicationEventPublisher：注册监听器，实现监听机制

参考

1. GitHub 代码
2. Spring框架小白的蜕变