设计模式 ~ Spring。

设计模式看 Spring。

---

---

自定义 Spring 框架。

7.1 Spring 使用回顾。

自定义 Spring 框架前，先回顾一下 spring 框架的使用，从而分析 spring 的核心，并对核心功能进行模拟。

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

• 数据访问层。定义 UserDao 接口及其子实现类。

package com.example.design.pattern.spring.dao;

/**
 * 接口 ~ 数据访问层。
 *
 * @author geek
 */
public interface IUserDao {

    /**
     * insert。
     */
    void insert();

}

package com.geek.design.pattern.spring.dao.impl;

import com.geek.design.pattern.spring.dao.IUserDao;

/**
 * 实现类 ~ 数据访问层。
 *
 * @author geek
 */
public class UserDaoImpl implements IUserDao {

    public UserDaoImpl() {
        System.out.println(" ~ UserDaoImpl ~ public UserDaoImpl(); ~ ");
    }

    /**
     * insert。
     */
    @Override
    public void insert() {
        System.out.println(" ~ UserDaoImpl ~ insert; ~ ");
    }

}

• 业务逻辑层。定义 UserService 接口及其子实现类。

package com.geek.design.pattern.spring.service.impl;

import com.geek.design.pattern.spring.dao.IUserDao;
import com.geek.design.pattern.spring.service.IUserService;

/**
 * 实现类 ~ 业务逻辑层。
 *
 * @author geek
 */
public class UserServiceImpl implements IUserService {

    /**
     * 声明一个 IUserDao 类型的变量。
     */
    private IUserDao userDao;

    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    /**
     * add。
     */
    @Override
    public void add() {
        System.out.println(" ~ UserServiceImpl ~ add; ~ ");
        this.userDao.insert();
    }

}

package com.geek.design.pattern.spring.service.impl;

import com.geek.design.pattern.spring.dao.IUserDao;
import com.geek.design.pattern.spring.service.IUserService;

/**
 * 实现类 ~ 业务逻辑层。
 *
 * @author geek
 */
public class UserServiceImpl implements IUserService {

    /**
     * 声明一个 IUserDao 类型的变量。
     */
    private IUserDao userDao;

    public UserServiceImpl(IUserDao userDao) {
        System.out.println(" ~ UserServiceImpl ~ public UserServiceImpl(IUserDao userDao); ~ 0。");
        this.userDao = userDao;
        System.out.println(" ~ UserServiceImpl ~ public UserServiceImpl(IUserDao userDao); ~ 1。");
    }

    public void setUserDao(IUserDao userDao) {
        System.out.println(" ~ UserServiceImpl ~ serUserDao; ~ 0。");
        this.userDao = userDao;
        System.out.println(" ~ UserServiceImpl ~ serUserDao; ~ 1。");
    }

    /**
     * add。
     */
    @Override
    public void add() {
        System.out.println(" ~ UserServiceImpl ~ add; ~ ");
        this.userDao.insert();
    }

}

• 定义 UserController 类，使用 main 方法模拟 controller 层。

package com.geek.design.pattern.spring.controller;

import com.geek.design.pattern.spring.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author geek
 */
public class UserController {

    public static void main(String[] args) {
        // 创建 Spring 容器对象。
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从容器对象中获取 userService 对象。
        System.out.println("使用对象前。");
        IUserService userService = applicationContext.getBean("userService", IUserService.class);
        // 调用 userService 的方法进行业务逻辑处理。
        userService.add();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:49467', transport: 'socket'
00:36:39.319 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@dc24521
00:36:39.559 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [applicationContext.xml]
00:36:39.626 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userDao'
 ~ UserDaoImpl ~ public UserDaoImpl(); ~ 
00:36:39.649 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userService'
 ~ UserServiceImpl ~ public UserServiceImpl();
 ~ UserServiceImpl ~ serUserDao; ~ 0。
 ~ UserServiceImpl ~ serUserDao; ~ 1。
使用对象前。
 ~ UserServiceImpl ~ add; ~ 
 ~ UserDaoImpl ~ insert; ~ 
Disconnected from the target VM, address: '127.0.0.1:49467', transport: 'socket'

Process finished with exit code 0
 */

• 编写配置文件。在类路径下编写一个名为 applicationContext.xml 的配置文件。

<?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="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

通过上面代码及结果可以看出。

• userService 对象是从 applicationContext 容器对象获取到的，也就是 userService 对象交由 Spring 进行管理。

• 上面结果可以看到调用了 UserDao 对象中的 add 方法，也就是说 UserDao 子实现类对象也交由 Spring 管理了。

• UserService 中的 userDao 变量我们并没有进行赋值，但是可以正常使用，说明 Spring 已经将 UserDao 对象赋值给了 userDao 变量。

上面三点体现了 Spring 框架的 IoC（Inversion of Control）和 DI（Dependency Injection, DI）。

---

7.2 Spring 核心功能结构。

Spring 大约有20个模块，由1300多个不同的文件构成。这些模块可以分为:

核心容器、AOP 和设备支持、数据访问与集成、Web 组件、通信报文和集成测试等，下面是 Spring 框架的总体架构图。

核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4 个模块组成。

• spring-beans 和 spring-core 模块是 Spring 框架的核心模块，包含了控制反转（Inversion of Control，IoC）和依赖注入（Dependency
  Injection，DI）。BeanFactory 使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory
  属于延时加载，也就是说在实例化容器对象后并不会自动实例化 Bean，只有当 Bean 被使用时，BeanFactory 才会对该 Bean
  进行实例化与依赖关系的装配。

（延时加载）。

package com.geek.design.pattern.spring.controller;

import com.geek.design.pattern.spring.service.IUserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

/**
 * 延时加载。
 *
 * @author geek
 */
public class UserController1 {

    public static void main(String[] args) {
        // 创建 Spring 容器对象。
//        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        // 从容器对象中获取 userService 对象。
//        IUserService userService = applicationContext.getBean("userService", IUserService.class);
        System.out.println("使用对象前。");
        IUserService userService = beanFactory.getBean("userService", IUserService.class);
        // 调用 userService 的方法进行业务逻辑处理。
        userService.add();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:49453', transport: 'socket'
00:35:53.288 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [applicationContext.xml]
使用对象前。
00:35:53.299 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanFactory - Creating shared instance of singleton bean 'userService'
 ~ UserServiceImpl ~ public UserServiceImpl();
00:35:53.316 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanFactory - Creating shared instance of singleton bean 'userDao'
 ~ UserDaoImpl ~ public UserDaoImpl(); ~
 ~ UserServiceImpl ~ serUserDao; ~ 0。
 ~ UserServiceImpl ~ serUserDao; ~ 1。
 ~ UserServiceImpl ~ add; ~
 ~ UserDaoImpl ~ insert; ~
Disconnected from the target VM, address: '127.0.0.1:49453', transport: 'socket'

Process finished with exit code 0
 */

• spring-context 模块构架于核心模块之上，扩展了 BeanFactory，为它添加了 Bean
  生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与 BeanFactory 不同，ApplicationContext 实例化后会自动对所有的单实例 Bean 进行实例化与依赖关系的装配，使之处于待用状态。

• spring-context-support 模块是对 Spring IoC 容器及 IoC 子容器的扩展支持。

• spring-context-indexer 模块是 Spring 的类管理组件和 Classpath 扫描组件。

• spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。ta 的语法类似于传统 EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL 的特性是基于 Spring 产品的需求而设计的，可以非常方便地同 Spring IoC 进行交互。

---

7.2.1 bean 概述。

Spring 就是面向 Bean 的编程（BOP, Bean Oriented Programming），Bean 在 Spring 中处于核心地位。Bean 对于 Spring 的意义就像 Object 对于 OOP 的意义一样，Spring 中没有 Bean 也就没有 Spring 存在的意义。Spring IoC 容器通过配置文件或者注解的方式来管理 bean 对象之间的依赖关系。

Spring 中 bean 用于对一个类进行封装。如下面的配置。

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

为什么 Bean 如此重要呢？

• Spring 将 bean 对象交由一个叫 IoC 容器进行管理。

• bean 对象之间的依赖关系在配置文件中体现，并由 Spring 完成。

---

7.3 Spring IoC 相关接口分析。

7.3.1 BeanFactory 解析。

Spring 中 Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，即 IoC 容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多 IoC 容器的实现供用户选择，其相互关系如下图所示。

其中，BeanFactory 作为最顶层的一个接口，定义了 IoC 容器的基本功能规范，BeanFactory 有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，ta 实现了所有的接口。

那么为何要定义这么多层次的接口呢？

每个接口都有它的使用场合，主要是为了区分在 Spring 内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，

• ListableBeanFactory 接口表示这些 Bean 可列表化。

• HierarchicalBeanFactory 表示这些 Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean。

• AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。

这三个接口共同定义了 Bean 的集合、Bean 之间的关系及 Bean 行为。最基本的 IoC 容器接口是 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 = "&";

	// 根据 bean 的名称获取 IoC 容器中的的 bean 对象。
	Object getBean(String name) throws BeansException;

	// 根据 bean 的名称获取 IoC 容器中的的 bean 对象，并指定获取到的 bean 对象的类型，这样我们使用时就不需要进行类型强转了。
	<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);

	// 判断容器中是否包含指定名称的 bean 对象。
	boolean containsBean(String name);

	// 根据 bean 的名称判断是否是单例。
	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;

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

	String[] getAliases(String name);

}

在 BeanFactory 里只对 IoC 容器的基本行为做了定义，根本不关心你的 Bean 是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。

BeanFactory 有一个很重要的子接口，就是 ApplicationContext 接口，该接口主要来规范容器中的 bean 对象是非延时加载，即在创建容器对象的时候就对象 bean 进行初始化，并存储到一个容器中。

要知道工厂是如何产生对象的，我们需要看具体的 IoC 容器实现，Spring 提供了许多 IoC 容器实现，比如：

• ClasspathXmlApplicationContext : 根据类路径加载 xml 配置文件，并创建 IoC 容器对象。

• FileSystemXmlApplicationContext ：根据系统路径加载 xml 配置文件，并创建 IoC 容器对象。

• AnnotationConfigApplicationContext ：加载注解类配置，并创建 IoC 容器。

---

7.3.2 BeanDefinition 解析。

Spring IoC 容器管理我们定义的各种 Bean 对象及其相互关系，而 Bean 对象在 Spring 实现中是以 BeanDefinition 来描述的，如下面配置文件。

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

bean 标签还有很多属性：
scope、init-method、destory-method 等。

其继承体系如下图所示。

---

7.3.3 BeanDefinitionReader 解析。

Bean 的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过 BeanDefinitionReader 来完成，看看 Spring 中 BeanDefinitionReader 的类结构图，如下图所示。

看看 BeanDefinitionReader 接口定义的功能来理解它具体的作用。

public interface BeanDefinitionReader {

	// 获取 BeanDefinitionRegistry 注册器对象。
	BeanDefinitionRegistry getRegistry();

	@Nullable
	ResourceLoader getResourceLoader();

	@Nullable
	ClassLoader getBeanClassLoader();

	BeanNameGenerator getBeanNameGenerator();

// 下面的 loadBeanDefinitions 都是加载 bean 定义，从指定的资源中。

	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;

	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;

}

---

7.3.4 BeanDefinitionRegistry 解析。

BeanDefinitionReader 用来解析 bean 定义，并封装 BeanDefinition 对象，而我们定义的配置文件中定义了很多 bean 标签，所以就有一个问题，解析的 BeanDefinition 对象存储到哪儿？答案就是 BeanDefinition 的注册中心，而该注册中心顶层接口就是 BeanDefinitionRegistry。

public interface BeanDefinitionRegistry extends AliasRegistry {

	// 往注册表中注册 bean。
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	// 从注册表中删除指定名称的 bean。
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 获取注册表中指定名称的 bean。
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 判断注册表中是否已经注册了指定名称的 bean。	
	boolean containsBeanDefinition(String beanName);

	// 获取注册表中所有的 bean 的名称。
	String[] getBeanDefinitionNames();

	int getBeanDefinitionCount();

	boolean isBeanNameInUse(String beanName);

}

继承结构图如下。

从上面类图可以看到 BeanDefinitionRegistry 接口的子实现类主要有以下几个。

• DefaultListableBeanFactory。

  在该类中定义了如下代码，就是用来注册 bean。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {


	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

• SimpleBeanDefinitionRegistry。

  在该类中定义了如下代码，就是用来注册 bean。

public class SimpleBeanDefinitionRegistry extends SimpleAliasRegistry implements BeanDefinitionRegistry {

	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

---

7.3.5 创建容器。

ClassPathXmlApplicationContext 对 Bean 配置资源的载入是从 refresh(); 方法开始的。refresh(); 方法是一个模板方法，规定了 IoC 容器的启动流程，有些逻辑要交给其子类实现。ta 对 Bean 配置资源进行载入，ClassPathXmlApplicationContext 通过调用其父类
AbstractApplicationContext 的 refresh() 方法启动整个 IoC 容器对 Bean 定义的载入过程。

---

7.4 自定义 SpringIoC。

现要对下面的配置文件进行解析，并自定义 Spring 框架的 IoC 对涉及到的对象进行管理。

<?xml version="1.0" encoding="UTF-8" ?>
<beans>

    <bean id="userDao" class="com.geek.design.pattern.spring.dao.impl.UserDaoImpl"/>

    <bean id="userService" class="com.geek.design.pattern.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

7.4.1 定义 bean 相关的 pojo 类。

7.4.1.1 PropertyValue 类。

用于封装 bean 的属性，体现到上面的配置文件就是封装 bean 标签的子标签 property 标签数据。

package com.geek.design.pattern.spring.geek.framework.beans;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 封装 bean 标签下 property 标签的属性。
 *
 * @author geek
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PropertyValue {

    private String name;
    private String ref;
    /**
     * 给基本数据类型及 String 类型的数据赋值。
     */
    private String value;

}

---

7.4.1.2 MutablePropertyValues 类。

一个 bean 标签可以有多个 property 子标签，所以再定义一个 MutablePropertyValues 类，用来存储并管理多个 PropertyValue 对象。

package com.geek.design.pattern.spring.geek.framework.beans;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/**
 * 存储和管理多个 PropertyValue 对象。
 *
 * @author geek
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {

    /**
     * 定义 list 集合对象，用来存储 PropertyValue 对象。
     */
    private final List<PropertyValue> propertyValueList;

    public MutablePropertyValues() {
        this.propertyValueList = new ArrayList<PropertyValue>();
    }

    public MutablePropertyValues(List<PropertyValue> propertyValueList) {
        if (Objects.isNull(propertyValueList)) {
            this.propertyValueList = new ArrayList<PropertyValue>();
        } else {
            this.propertyValueList = propertyValueList;
        }
    }

    /**
     * 获取迭代器对象。
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    @Override
    public Iterator<PropertyValue> iterator() {
//        return null;
        return this.propertyValueList.iterator();
    }

    /**
     * 获取所有的 PropertyValue 对象，以数组形式返回。
     *
     * @return
     */
    public PropertyValue[] getPropertyValues() {
        // 将集合转换为数组并返回。
        return this.propertyValueList.toArray(new PropertyValue[0]);
    }

    /**
     * 根据 name 属性值获取 PropertyValue 对象。
     *
     * @param propertyName
     * @return
     */
    public PropertyValue getPropertyValue(String propertyName) {
        for (PropertyValue propertyValue : this.propertyValueList) {
            String propertyValueName = propertyValue.getName();
            if (propertyValueName.equals(propertyName)) {
                return propertyValue;
            }
        }
        return null;
    }

    /**
     * 判断集合是否为空。
     *
     * @return
     */
    public boolean isEmpty() {
        return this.propertyValueList.isEmpty();
    }

    /**
     * 添加 PropertyValue 对象。
     *
     * @param propertyValue
     * @return
     */
    public MutablePropertyValues addPropertyValue(PropertyValue propertyValue) {
        // 判断集合中存储的 PropertyValue 对象是否和传递的重复。如果重复，进行覆盖。
        for (int i = 0; i < this.propertyValueList.size(); i++) {
            PropertyValue propertyValueCurrent = this.propertyValueList.get(i);
            if (propertyValueCurrent.getName().equals(propertyValue.getName())) {
                this.propertyValueList.set(i, propertyValue);
                // 目的：实现链式编程。
                return this;
            }
        }
        this.propertyValueList.add(propertyValue);
        // 目的：实现链式编程。
        return this;
    }

    /**
     * 判断是否有指定 name 属性值的对象。
     *
     * @param propertyName
     * @return
     */
    public boolean contains(String propertyName) {
        return this.getPropertyValue(propertyName) != null;
    }

}

---

7.4.1.3 BeanDefinition 类。

BeanDefinition 类用来封装 bean 信息的，主要包含 id（即 bean 对象的名称）、class（需要交由 Spring 管理的类的全类名）及子标签 property 数据。

package com.geek.design.pattern.spring.geek.framework.beans;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * 封装 Bean 标签数据。
 * - id 属性。
 * - class 属性。
 * - property 子标签的数据。
 *
 * @author geek
 */
@Data
public class BeanDefinition {

    /**
     * 定义 list 集合对象，用来存储 PropertyValue 对象。
     */
    private final List<PropertyValue> propertyValueList;

    public BeanDefinition() {
        this.propertyValueList = new ArrayList<PropertyValue>();
    }

    public BeanDefinition(List<PropertyValue> propertyValueList) {
        if (propertyValueList == null) {
            this.propertyValueList = new ArrayList<>();
        } else {
            this.propertyValueList = propertyValueList;
        }
    }

}

---

7.4.2 定义注册表相关类。

7.4.2.1 BeanDefinitionRegistry 接口。

BeanDefinitionRegistry 接口定义了注册表的相关操作，定义如下功能。

• 注册 BeanDefinition 对象到注册表中。

• 从注册表中删除指定名称的 BeanDefinition 对象。

• 根据名称从注册表中获取 BeanDefinition 对象。

• 判断注册表中是否包含指定名称的 BeanDefinition 对象。

• 获取注册表中 BeanDefinition 对象的个数。

• 获取注册表中所有的 BeanDefinition 的名称。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;

/**
 * 注册表对象接口。
 *
 * @author geek
 */
public interface IBeanDefinitionRegistry {

    /**
     * 注册 BeanDefinition 对象到注册表中。
     *
     * @param beanName
     * @param beanDefinition
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    /**
     * 从注册表中删除指定名称的 BeanDefinition 对象。
     *
     * @param beanName
     * @throws Exception
     */
    void removeBeanDefinition(String beanName) throws Exception;

    /**
     * 根据名称从注册表中获取 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     * @throws Exception
     */
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    /**
     * 根据名称判断注册表中是否有 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 注册表中的对象数量。
     *
     * @return
     */
    int getBeanDefinitionCount();

    /**
     * 获取注册表中对象属性名集合。
     *
     * @return
     */
    String[] getBeanDefinitionNames();

}

7.4.2.2 SimpleBeanDefinitionRegistry 类。

该类实现了 BeanDefinitionRegistry 接口，定义了 Map 集合作为注册表容器。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;

import java.util.HashMap;
import java.util.Map;

/**
 * 注册表对象接口子实现类。
 *
 * @author geek
 */
public class SimpleBeanDefinitionRegistry implements IBeanDefinitionRegistry {

    /**
     * 存储 BeanDefinition 对象的容器。
     */
    private final Map<String, BeanDefinition> definitionMap = new HashMap<String, BeanDefinition>();

    /**
     * 注册 BeanDefinition 对象到注册表中。
     *
     * @param beanName
     * @param beanDefinition
     */
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        this.definitionMap.put(beanName, beanDefinition);
    }

    /**
     * 从注册表中删除指定名称的 BeanDefinition 对象。
     *
     * @param beanName
     */
    @Override
    public void removeBeanDefinition(String beanName) {
        this.definitionMap.remove(beanName);
    }

    /**
     * 根据名称从注册表中获取 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return this.definitionMap.get(beanName);
    }

    /**
     * 根据名称判断注册表中是否有 BeanDefinition 对象。
     *
     * @param beanName
     * @return
     */
    @Override
    public boolean containsBeanDefinition(String beanName) {
        return this.definitionMap.containsKey(beanName);
    }

    /**
     * 注册表中的对象数量。
     *
     * @return
     */
    @Override
    public int getBeanDefinitionCount() {
        return this.definitionMap.size();
    }

    /**
     * 获取注册表中对象属性名集合。
     *
     * @return
     */
    @Override
    public String[] getBeanDefinitionNames() {
        return this.definitionMap.keySet().toArray(new String[0]);
    }

}

---

7.4.3 定义解析器相关类。

7.4.3.1 BeanDefinitionReader 接口。

BeanDefinitionReader 是用来解析配置文件并在注册表中注册 bean 的信息。定义了两个规范.

• 获取注册表的功能，让外界可以通过该对象获取注册表对象。

• 加载配置文件，并注册 bean 数据。

package com.geek.design.pattern.spring.geek.framework.beans.factory.support;

/**
 * 解析配置文件。接口 ~ 定义规范。
 *
 * @author geek
 */
public interface IBeanDefinitionReader {

    /**
     * 获取注册表对象。
     *
     * @return
     */
    IBeanDefinitionRegistry getRegistry();

    /**
     * 加载配置文件并在注册表中进行注册
     *
     * @param configLocation
     * @throws Exception
     */
    void loadBeanDefinitions(String configLocation) throws Exception;

}

---

7.4.3.2 XmlBeanDefinitionReader 类。

XmlBeanDefinitionReader 类是专门用来解析 xml 配置文件的。该类实现 BeanDefinitionReader 接口并实现接口中的两个功能。

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

package com.geek.design.pattern.spring.geek.framework.beans.factory.xml;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.MutablePropertyValues;
import com.geek.design.pattern.spring.geek.framework.beans.PropertyValue;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

/**
 * 针对 xml 配置文件进行解析的类。
 *
 * @author geek
 */
public class XmlBeanDefinitionReader implements IBeanDefinitionReader {

    /**
     * 声明注册表对象。
     */
    private final IBeanDefinitionRegistry beanDefinitionRegistry;

    public XmlBeanDefinitionReader() {
        this.beanDefinitionRegistry = new SimpleBeanDefinitionRegistry();
    }

    /**
     * 获取注册表对象。
     *
     * @return
     */
    @Override
    public IBeanDefinitionRegistry getRegistry() {
        return this.beanDefinitionRegistry;
    }

    /**
     * 加载配置文件并在注册表中进行注册。
     *
     * @param configLocation
     * @throws DocumentException
     */
    @Override
    public void loadBeanDefinitions(String configLocation) throws DocumentException {
        // dom4j 进行 xml 配置文件解析。
        SAXReader saxReader = new SAXReader();
        // 获取类路径下的配置文件。
        InputStream resourceAsStream = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
        Document document = saxReader.read(resourceAsStream);
        // 根据 document 对象获取根标签对象（beans）。
        Element rootElement = document.getRootElement();
        // 获取根标签下所有 bean 标签对象。
        List<Element> beanElementList = rootElement.elements("bean");
        for (Element beanElement : beanElementList) {
            // 获取 id 属性。
            String id = beanElement.attributeValue("id");
            // 获取 class 属性。
            String className = beanElement.attributeValue("class");
            // 将 id 属性和 class 属性封装到 BeanDefinition 对象中。
            // 创建 BeanDefinition。
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            // 创建 MutablePropertyValues 对象。
            MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();

            // 获取 bean 标签下所有的 property 标签对象。
            List<Element> propertyElementList = beanElement.elements("property");
            for (Element propertyElement : propertyElementList) {
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                MutablePropertyValues mutablePropertyValues1 = mutablePropertyValues.addPropertyValue(propertyValue);
                System.out.println("mutablePropertyValues1 = " + mutablePropertyValues1);
            }
            // 将 mutablePropertyValues 封装到 BeanDefinition 对象中。
            beanDefinition.setPropertyValues(mutablePropertyValues);

            // 将 beanDefinition 对象注册到注册表中。
            this.beanDefinitionRegistry.registerBeanDefinition(id, beanDefinition);
        }
    }

}

---

7.4.4 IoC 容器相关类。

7.4.4.1 BeanFactory 接口。

在该接口中定义 IoC 容器的统一规范即获取 bean 对象。

package com.geek.design.pattern.spring.geek.framework.beans.factory;

/**
 * IoC 容器父接口。
 *
 * @author geek
 */
public interface IBeanFactory {

    /**
     * 根据 bean 对象的名称获取 bean 对象。
     *
     * @param name
     * @return
     */
    Object getBean(String name);

    /**
     * 根据 bean 对象的名称获取 bean 对象，并进行类型转换。
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     * @throws Exception
     */
    <T> T getBean(String name, Class<? extends T> clazz) throws Exception;

}

7.4.4.2 ApplicationContext 接口。

该接口的所以的子实现类对 bean 对象的创建都是非延时的，所以在该接口中定义 refresh() 方法，该方法主要完成以下两个功能：

• 加载配置文件。

• 根据注册表中的 BeanDefinition 对象封装的数据进行 bean 对象的创建。

package com.geek.design.pattern.spring.geek.framework.context;

import com.geek.design.pattern.spring.geek.framework.beans.factory.IBeanFactory;

/**
 * 定义非延时加载功能。
 *
 * @author geek
 */
public interface IApplicationContext extends IBeanFactory {

    /**
     * 进行配置文件加载并进行对象创建。
     */
    void refresh();

}

---

7.4.4.3 AbstractApplicationContext 类。

• 作为 ApplicationContext 接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个 Map 集合，作为 bean 对象存储的容器。

• 声明 BeanDefinitionReader 类型的变量，用来进行 xml 配置文件的解析，符合单一职责原则。
  BeanDefinitionReader 类型的对象创建交由子类实现，因为只有子类明确到底创建 BeanDefinitionReader 哪儿个子实现类对象。

package com.geek.design.pattern.spring.geek.framework.context.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.context.IApplicationContext;
import org.dom4j.DocumentException;
import org.omg.CORBA.Object;

import java.util.HashMap;
import java.util.Map;

/**
 * IApplicationContext 接口的子实现类，用于立即加载。
 *
 * @author geek
 */
public abstract class AbstractClassApplicationContext implements IApplicationContext {

    /**
     * 声明解析器变量。
     */
    protected IBeanDefinitionReader beanDefinitionReader;

    /**
     * 用于存储 bean 对象的 map 容器。
     */
    protected Map<String, Object> singletonObjectMap = new HashMap<String, Object>();

    /**
     * 配置文件路径。
     */
    protected String configLocation;

    /**
     * 进行配置文件加载并进行对象创建。
     */
    @Override
    public void refresh() throws DocumentException {
        // 加载 BeanDefinition 对象。
        this.beanDefinitionReader.loadBeanDefinitions(this.configLocation);
        // 初始化 Bean。

    }

    /**
     * bean 的初始化。
     */
    private void finishBeanInitialization() {
        // 获取注册表对象。
        IBeanDefinitionRegistry beanDefinitionReaderRegistry = this.beanDefinitionReader.getRegistry();
        // 获取 BeanDefinition 对象。
        String[] beanNames = beanDefinitionReaderRegistry.getBeanDefinitionNames();
        // bean 的初始化。
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanDefinitionReaderRegistry.getBeanDefinition(beanName);
            this.getBean(beanName);
        }
    }

}

注意：该类 finishBeanInitialization(); 方法中调用 getBean(); 方法使用到了模板方法模式。

---

7.4.4.4 ClassPathXmlApplicationContext 类。

该类主要是加载类路径下的配置文件，并进行 bean 对象的创建，主要完成以下功能。

• 在构造方法中，创建 BeanDefinitionReader 对象。

• 在构造方法中，调用 refresh(); 方法，用于进行配置文件加载、创建 bean 对象并存储到容器中。

• 重写父接口中的 getBean(); 方法，并实现依赖注入操作。

package com.geek.design.pattern.spring.geek.framework.context.support;

import com.geek.design.pattern.spring.geek.framework.beans.BeanDefinition;
import com.geek.design.pattern.spring.geek.framework.beans.MutablePropertyValues;
import com.geek.design.pattern.spring.geek.framework.beans.PropertyValue;
import com.geek.design.pattern.spring.geek.framework.beans.factory.support.IBeanDefinitionRegistry;
import com.geek.design.pattern.spring.geek.framework.beans.factory.xml.XmlBeanDefinitionReader;
import com.geek.design.pattern.spring.geek.framework.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.dom4j.DocumentException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * IoC 容器具体的子实现类。加载类路径下的 xml 格式的配置文件。
 *
 * @author geek
 */
@Slf4j
public class ClassPathXmlApplicationContext extends AbstractClassApplicationContext {

    public ClassPathXmlApplicationContext(String configLocation) {
        this.configLocation = configLocation;
        // 构建 XmlBeanDefinitionReader 对象。
        beanDefinitionReader = new XmlBeanDefinitionReader();
        try {
            this.refresh();
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 根据 bean 对象的名称获取 bean 对象。
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws NoSuchMethodException
     */
    @Override
    public Object getBean(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        // 判断对象容器中是否包含指定名称的 bean 对象。
        Object object = this.singletonObjectMap.get(name);
        log.info(" ~ ClassPathXmlApplicationContext ~ getBean; ~ object ~ {}",
                object);
        if (object != null) {
            return object;
        }

        // 获取 BeanDefinition 对象。
        IBeanDefinitionRegistry beanDefinitionReaderRegistry = this.beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = beanDefinitionReaderRegistry.getBeanDefinition(name);
        if (beanDefinition == null) {
            return null;
        }
        // 获取 bean 信息中的 className。
        String className = beanDefinition.getClassName();
        // 通过反射创建对象。
        Class<?> clazz = Class.forName(className);
        Object beanObj = clazz.newInstance();
        // 依赖注入。
        MutablePropertyValues beanDefinitionPropertyValues = beanDefinition.getPropertyValues();

        for (PropertyValue propertyValue : beanDefinitionPropertyValues) {

            // name 属性值。
            String propertyName = propertyValue.getName();
            // value 属性。
            String value = propertyValue.getValue();
            // ref 属性。
            String ref = propertyValue.getRef();

            if (ref != null && !"".equals(ref)) {
                // 获取依赖的 bean 对象。递归。
                Object bean = getBean(ref);
                // 拼接方法名。
                String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                // 获取所有的方法对象。
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (method.getName().equals(methodName)) {
                        // 执行该 setter 方法。
                        method.invoke(beanObj, bean);
                    }
                }
            }

            if (value != null && !"".equals(value)) {
                // 拼接方法名。
                String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                // 获取 Method 对象。
                Method method = clazz.getMethod(methodName, String.class);
                method.invoke(beanObj, value);
            }
        }
        // 在返回 BeanObj 对象之前，将该对象存储到 map 容器中。
        this.singletonObjectMap.put(name, beanObj);
        return beanObj;
    }

    /**
     * 根据 bean 对象的名称获取 bean 对象，并进行类型转换。
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     * @throws ClassNotFoundException
     * @throws InvocationTargetException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     */
    @Override
    public <T> T getBean(String name, Class<? extends T> clazz) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {

        Object beanObj = getBean(name);
        if (beanObj != null) {
            // 类型强转。
            return clazz.cast(beanObj);
        }
        return null;
    }

}

---

7.4.5 自定义 Spring IoC 总结。

7.4.5.1 使用到的设计模式。

• 工厂模式。
  工厂模式 + 配置文件的方式。

• 单例模式。
  Spring IoC 管理的 bean 对象都是单例的，此处的单例不是通过构造器进行单例的控制的，而是 Spring 框架对每一个 bean 只创建了一个对象。

• 模板方法模式。
  AbstractApplicationContext 类中的 finishBeanInitialization(); 方法调用了子类的 getBean(); 方法，因为 getBean(); 的实现和环境息息相关。

• 迭代器模式。
  对于 MutablePropertyValues 类定义使用到了迭代器模式，因为此类存储并管理 PropertyValue 对象，也属于一个容器，所以给该容器提供一个遍历方式。

Spring 框架其实使用到了很多设计模式，如 AOP 使用到了代理模式，选择 JDK 代理或者 CGLIB 代理使用到了策略模式，还有适配器模式，装饰者模式，观察者模式等。

---

7.4.5.2 符合大部分设计原则。

7.4.5.3 整个设计和 Spring 的设计还是有一定的出入。

spring 框架底层是很复杂的，进行了很深入的封装，并对外提供了很好的扩展性。而我们自定义 SpringIoC 有以下几个目的。

• 了解 Spring 底层对对象的大体管理机制。

• 了解设计模式在具体的开发中的使用。

• 以后学习 Spring 源码，通过该案例的实现，可以降低 Spring 学习的入门成本。