Spring IoC 容器概述

Spring IoC 依赖查找

根据 Bean 名称查找

实时查找

private static void lookupInRealTime(BeanFactory beanFactory) {
    User user = (User) beanFactory.getBean("user");
    System.out.println("实时查找：" + user);
}

延迟查找

<bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
    <property name="targetBeanName" value="user"/>
</bean>

private static void lookupInLazy(BeanFactory beanFactory) {
 	ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
    User user = objectFactory.getObject();
    System.out.println("延迟查找：" + user);
}

根据 Bean 类型查找

单个 Bean 对象

private static void lookupByType(BeanFactory beanFactory) {
    User user = beanFactory.getBean(User.class);
    System.out.println("实时查找：" + user);
}

集合 Bean 对象

private static void lookupCollectionByType(BeanFactory beanFactory) {
    if (beanFactory instanceof ListableBeanFactory) {
        ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
        Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
        System.out.println("查找到的所有的 User 集合对象：" + users);
    }
}

根据 Bean 名称 + 类型查找

private static void lookupByNameAndType(BeanFactory beanFactory) {
    User user = beanFactory.getBean("user",User.class);
    System.out.println("实时查找：" + user);
}

根据 Java 注解查找

private static void lookupByAnnotationType(BeanFactory beanFactory) {
    if (beanFactory instanceof ListableBeanFactory) {
        ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
        Map<String, User> users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);
        System.out.println("查找标注 @Super 所有的 User 集合对象：" + users);
    }
}

Spring IoC 依赖注入

• 根据 Bean 名称注入
• 根据 Bean 类型注入
----- 单个 Bean 对象
----- 集合 Bean 对象
• 注入容器內建 Bean 对象
• 注入非 Bean 对象
• 注入类型
---- 实时注入
---- 延迟注入

<bean id="userRepository" class="org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository"
      autowire="byType"> <!-- Auto-Wiring -->
</bean>

public class UserRepository {

    private Collection<User> users; // 自定义 Bean

    private BeanFactory beanFactory; // 內建非 Bean 对象（依赖）

    private ObjectFactory<ApplicationContext> objectFactory;

    public Collection<User> getUsers() {
        return users;
    }

    public void setUsers(Collection<User> users) {
        this.users = users;
    }

    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    public ObjectFactory<ApplicationContext> getObjectFactory() {
        return objectFactory;
    }

    public void setObjectFactory(ObjectFactory<ApplicationContext> objectFactory) {
        this.objectFactory = objectFactory;
    }
}

Spring IoC 依赖来源

• 自定义 Bean
• 容器內建 Bean 对象
• 容器內建依赖

Spring IoC 配置元信息

Bean 定义配置

• 基于 XML 文件
• 基于 Properties 文件
• 基于 Java 注解
• 基于 Java API（专题讨论）

IoC 容器配置

• 基于 XML 文件
• 基于 Java 注解
• 基于 Java API （专题讨论）

外部化属性配置

• 基于 Java 注解

BeanFactory 和 ApplicationContext 谁才是 Spring IoC 容器？

In short, the BeanFactory provides the configuration framework and basic functionality, and the ApplicationContext adds more enterprise-specific functionality. The ApplicationContext is a complete superset of the BeanFactory and is used exclusively in this chapter in descriptions of Spring’s IoC container. For more information on using the BeanFactory instead of the ApplicationContext, see The BeanFactory.

• BeanFactory 是 Spring 底层 IoC 容器
• ApplicationContext 是具备应用特性的 BeanFactory 超集

Spring 应用上下文

• 面向切面（AOP）
• 配置元信息（Configuration Metadata）
• 资源管理（Resources）
• 事件（Events）
• 国际化（i18n）
• 注解（Annotations）
• Environment 抽象（Environment Abstraction）

https://docs.spring.io/spring/docs/5.2.2.RELEASE/spring-framework-reference/core.html#beans-introduction

面试题

什么是 Spring IoC 容器？
答：Spring Framework implementation of the Inversion of Control (IoC) principle. IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean.

BeanFactory 与 FactoryBean？
答：
BeanFactory 是 IoC 底层容器，FactoryBean 是 创建 Bean 的一种方式，帮助实现复杂的初始化逻辑。

Spring IoC 容器启动时做了哪些准备？
答：IoC 配置元信息读取和解析、IoC 容器生命周期、Spring 事件发布、国际化等