⭐⭐⭐Spring核心源码分析+自定义Spring框架⭐⭐⭐

学习完这个篇章以后,【23种设计模式·全精解析】至此完结。相信手写完这个自定义Spring框架后,你可以对Spring核心底层有更深的认识,并学会设计模式在具体实际开发中的如何去灵活应用

一、Spring使用回顾

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

// 数据访问层接口
public interface UserDao {
    void add();
}

// 数据访问层实现类
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDao...");
    }
}
// 业务逻辑层接口
public interface UserService {
    void add();
}

// 业务逻辑层实现类
public class UserServiceImpl implements UserService {
    // 声明一个UserDao类型变量
    private UserDao userDao;

    // 通过Spring依赖注入进行赋值
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("UserService...");
        userDao.add();
    }
}
import com.aizen.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

// 控制
public class UserController {
    public static void main(String[] args) {
        // 创建Spring的容器对象(非延时加载
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从ioc容器对象获取userService对象
        UserService userService = applicationContext.getBean("userService", UserService.class);
        //调用userService方法进行业务逻辑处理
        userService.add();
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	<bean id="userDao" class="com.aizen.dao.impl.UserDaoImpl"/><!-- IOC容器管理对象 -->
    <bean id="userService" class="com.aizen.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/><!-- 依赖注入DI -->
    </bean>
</beans>

代码运行结果如下:
image.png

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

上面三点体现了Spring框架的IOC(Inversion of Control)DI(Dependency Injection, DI)


二、Spring核心功能结构

1、Spring核心功能

Spring大约有20个模块,由1300多个不同的文件构成。这些模块可以分为:核心容器AOP和设备支持数据访问与集成Web组件通信报文集成测试等,下面是 Spring 框架的总体架构图:
image.png

核心容器由 beanscorecontextexpression(Spring Expression Language,SpEL)4个模块组成。

// 延时加载示例
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
// 执行getBean方法ioc容器才会创建service和dao对象,并绑定依赖关系
UserService userService = beanFactory.getBean("userService", UserService.class);
userService.add();

2、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.itheima.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>

为什么Bean如此重要呢?

  • spring将bean对象交由一个叫IOC容器进行管理
  • bean对象之间的依赖关系在配置文件中体现,并由spring完成。

三、Spring IOC相关接口分析

1、BeanFactory解析

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

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

那么为何要定义这么多层次的接口呢?
每个接口都有它的使用场合,主要是为了区分在Spring内部操作过程对象的传递转化,对对象的数据访问所做的限制。例如:

这三个接口共同定义了Bean的集合、Bean之间的关系及Bean行为。最基本的IoC容器接口是BeanFactory,来看一下它的源码

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&amp;";

	// 根据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;
	String[] getAliases(String name);
}

在BeanFactory里只对IoC容器的基本行为做了定义,根本不关心Bean是如何定义及怎样加载的
正如我们只关心能从工厂里得到什么产品,不关心工厂是怎么生产这些产品的。
具体如何创建交给该接口的具体子实现类去实现。

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

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

2、BeanDefinition解析

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

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>

bean标签还有很多属性scopeinit-methoddestory-method等。

Spring要解析这些bean标签,必然要把这些bean标签对应属性的值进行一个封装,而封装成的对象就是BeanDefinition对象而BeanDefinition是一个接口,所以Spring封装的是BeanDefinition的子实现类对象

其继承体系如下图所示
image.png

3、BeanDefinitionReader解析

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

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

public interface BeanDefinitionReader {

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

	@Nullable
	ResourceLoader getResourceLoader();

	@Nullable
	ClassLoader getBeanClassLoader();

	BeanNameGenerator getBeanNameGenerator();

	/*
		下面的loadBeanDefinitions都是加载bean定义,从指定资源中获取
        如String类型的字符冲路径,Resource对象类型
	*/
	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
}

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);
}

继承结构图如下(部分):
image.png

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

  • DefaultListableBeanFactory
    在该类中定义了如下代码,就是用来注册bean
  • Map<String, BeanDefinition>:键是BeanDefinition的名称,值是BeanDefinition对象
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
  • SimpleBeanDefinitionRegistry
    在该类中定义了如下代码,就是用来注册bean
  • Map<String, BeanDefinition>:键是BeanDefinition的名称,值是BeanDefinition对象
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

5、创建容器

  • ClassPathXmlApplicationContext(ApplicationContext接口下的子实现类)Bean配置资源的载入(非延迟加载)是从refresh()方法开始的。

  • 通过查看ClassPathXmlApplicationContext的源码,找到refresh()方法。

image.png

image.png

  • 它对 Bean 配置资源进行载入,ClassPathXmlApplicationContext通过调用其父类AbstractApplicationContext的refresh()方法启动整个IoC容器对Bean定义的载入过程

image.png

简单来说refresh()的功能:启动IoC容器,加载配置文件,并初始化Bean对象,将Bean对象存储在容器里面


四、自定义SpringIOC

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

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>

总体项目文件及包结构设计
image.png

1、定义bean相关的pojo类

(1)PropertyValue

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

// 用来封装bean标签下的property标签的属性
public class PropertyValue {
    private String name;
    private String ref;
    private String value;   // 赋值的属性为:基本数据类型及String类型数据

    public PropertyValue() {
    }

    public PropertyValue(String name, String ref, String value) {
        this.name = name;
        this.ref = ref;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

(2)MutablePropertyValues类

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

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

// 用户存储和管理多个PropertyValue对象
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) {
        this.propertyValueList = (propertyValueList != null ? propertyValueList : new ArrayList<PropertyValue>());
    }

    // 获取所有的PropertyValue对象,返回数组的形式
    public PropertyValue[] getPropertyValues() {
        // 将集合转换数组返回
        return propertyValueList.toArray(new PropertyValue[0]); // 参数指定返回数组的类型
    }

    // 根据name属性值名称获取对应的PropertyValue对象
    public PropertyValue getPropertyValue(String propertyName) {
        // 遍历集合对象
        for (PropertyValue pv : propertyValueList) {
            if (pv.getName().equals(propertyName)) {
                return pv;
            }
        }
        return null;
    }

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

    // 添加PropertyValue对象
    public MutablePropertyValues addPropertyValue(PropertyValue pv) {
        // 遍历并判断集合中存储的PropertyValue对象是否和传递进来的pv重复
        for (int i = 0; i < propertyValueList.size(); i++) {
            // 获取集合中每一个PropertyValue对象
            PropertyValue currentPv = propertyValueList.get(i);
            // 如果重复了,进行覆盖
            if (currentPv.getName().equals(pv.getName())) {
                propertyValueList.set(i, pv);
                //this.propertyValueList.set(i, new PropertyValue(pv.getName(), pv.getRef(), pv.getValue()));
                return this;    // 目的是实现链式编程
            }
        }
        // 遍历完说明没有重复的
        this.propertyValueList.add(pv);
        return this;    // 目的是实现链式编程
    }

    // 判断是否有指定name属性值的对象
    public boolean contains(String propertyName) {
        // 如果不等于null说明包含该name的PropertyValue,返回true;如果等于null说明不包含,返回false
        return getPropertyValue(propertyName) != null;
    }

    // 获取迭代器对象
    @Override
    public Iterator<PropertyValue> iterator() {
        return propertyValueList.iterator();
    }
}

(3)BeanDefinition类

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

// 用来封装bean标签数据
public class BeanDefinition {
    private String id;
    private String className;
    private MutablePropertyValues propertyValues;   // property子标签的数据

    public BeanDefinition() {
        propertyValues = new MutablePropertyValues();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public MutablePropertyValues getPropertyValues() {
        return propertyValues;
    }

    public void setPropertyValues(MutablePropertyValues propertyValues) {
        this.propertyValues = propertyValues;
    }
}

2、定义注册表相关类

(1)BeanDefinitionRegistry接口

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

  • 注册BeanDefinition对象到注册表
  • 注册表删除指定名称的BeanDefinition对象
  • 根据名称从注册表中获取BeanDefinition对象
  • 判断注册表中是否包含指定名称的BeanDefinition对象
  • 获取注册表中BeanDefinition对象的个数
  • 获取注册表中所有的BeanDefinition的名称
import com.aizen.framework.beans.BeanDefinition;

// 注册表接口
public interface BeanDefinitionRegistry {
    // 注册BeanDefinition对象到注册表中
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
    // 从注册表中删除指定名称的BeanDefinition对象
    void removeBeanDefinition(String beanName) throws Exception;
    // 根据名称从注册表中获取BeanDefinition对象
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();
}

(2)SimpleBeanDefinitionRegistry

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

import com.aizen.framework.beans.BeanDefinition;

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

// 注册表接口的子实现类
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
    // 定义一个容器,用来存储BeanDefinition对象
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(beanName,beanDefinition);
    }

    @Override
    public void removeBeanDefinition(String beanName) throws Exception {
        beanDefinitionMap.remove(beanName);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public int getBeanDefinitionCount() {
        return beanDefinitionMap.size();
    }

    @Override
    public String[] getBeanDefinitionNames() {
        return beanDefinitionMap.keySet().toArray(new String[0]);
    }
}

3、定义解析器相关类

(1)BeanDefinitionReader接口

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

  • 获取注册表的功能,让外界可以通过该对象获取注册表对象。
  • 加载配置文件,并注册bean数据。
// 用来解析配置文件的,而该接口只是定义了规范
public interface BeanDefinitionReader {
	// 获取注册表对象
    BeanDefinitionRegistry getRegistry();
	// 加载配置文件并在注册表中进行注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

(2)XmlBeanDefinitionReader类

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

<!-- dom4j -->
<dependency>
		<groupId>dom4j</groupId>
		<artifactId>dom4j</artifactId>
		<version>1.6.1</version>
</dependency>
import com.aizen.framework.beans.BeanDefinition;
import com.aizen.framework.beans.MutablePropertyValues;
import com.aizen.framework.beans.PropertyValue;
import com.aizen.framework.beans.factory.support.BeanDefinitionReader;
import com.aizen.framework.beans.factory.support.BeanDefinitionRegistry;
import com.aizen.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

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

// XML解析器针对XML配置文件进行解析的类,把Bean解析封装为BeanDefinition对象,并注册到注册表中
public class XmlBeanDefinitionReader implements BeanDefinitionReader {
    // 声明注册表对象
    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
        registry = new SimpleBeanDefinitionRegistry();
    }

    @Override
    public BeanDefinitionRegistry getRegistry() {
        return registry;
    }

    @Override
    public void loadBeanDefinitions(String configLocation) throws Exception {
        // 使用dom4j进行xml配置文件的解析
        SAXReader reader = new SAXReader();
        // 通过输入流,获取类路径下的配置文件
        InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
        Document document = reader.read(is);
        // 根据Document对象获取根标签对象(<beans>)
        Element rootElement = document.getRootElement();
        // 获取根标签下的所有的bean标签对象
        List<Element> beanElements = rootElement.elements("bean");
        // 遍历所有bean标签集合对象,获取每一个bean
        for (Element beanElement : beanElements) {
            // 获取bean标签下的id属性,class属性,property属性
            String id = beanElement.attributeValue("id");
            String className = beanElement.attributeValue("class");
            // 将id属性和cLass属性封装到BeanDefinition对家中
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);
            // 获取bean标签下所有的property标签对象
            List<Element> propertyElements = beanElement.elements("property");
            // 创建MutablePropertyValues对象
            MutablePropertyValues propertyValues = new MutablePropertyValues();
            for (Element propertyElement : propertyElements) {
                // 获取property标签下的name属性,ref属性,value属性
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");
                // 封装为PropertyValue对象
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                propertyValues.addPropertyValue(propertyValue);
            }
            // 将propertyValues对象封装到beanDefinition对象中
            beanDefinition.setPropertyValues(propertyValues);
            // 将beanDefinition对象注册到注册表中
            registry.registerBeanDefinition(id, beanDefinition);
        }
    }
}

4、IOC容器相关类

(1)BeanFactory接口

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

// IOC容器父接口
public interface BeanFactory {
    // 根据bean对象的名称获取bean对象
    Object getBean(String name) throws Exception;
    // 根据bean对象的名称获取bean对象,并进行类型转换
    <T> T getBean(String name, Class<? extends T> clazz) throws Exception;
}

(2)ApplicationContext接口

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

  • 加载配置文件。
  • 根据注册表中的BeanDefinition对象封装的数据进行bean对象的创建。
import com.aizen.framework.beans.factory.BeanFactory;

// 定义非延时加载功能
public interface ApplicationContext extends BeanFactory {
    // 进行配置文件加载并进行对象创建
    void refresh() throws Exception;
}

(3)AbstractApplicationContext类
  • 作为ApplicationContext接口的子类,所以该类也是非延时加载,所以需要在该类中定义一个Map集合,作为bean对象存储的容器。
  • 声明BeanDefinitionReader类型的变量,用来进行xml配置文件的解析,符合单一职责原则
    BeanDefinitionReader类型的对象创建交由子类实现,因为只有子类明确到底创建BeanDefinitionReader哪儿个子实现类对象(如解析xml配置文件、properties配置文件)。
import com.aizen.framework.beans.factory.support.BeanDefinitionReader;
import com.aizen.framework.beans.factory.support.BeanDefinitionRegistry;
import com.aizen.framework.context.ApplicationContext;

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

// ApplicationContext接口的子实现类(抽象类),用于立即加载(非延时加载)
public abstract class AbstractApplicationContext implements ApplicationContext {
    // 声明解析器变量
    protected BeanDefinitionReader beanDefinitionReader;
    // 定义用于存储bean对象的map容器,key存储的是bean的id值,value存储的是bean对象
    protected Map<String, Object> singletonObjects = new HashMap<String, Object>();
    // 声明配置文件路径的变量
    protected String configLocation;

    @Override
    public void refresh() throws Exception {
        // 加载BeanDefinition对象
        beanDefinitionReader.loadBeanDefinitions(configLocation);
        // 初始化bean
        finishBeanInitialization();
    }

    // bean的初始化
    private void finishBeanInitialization() throws Exception {
        // 从注册表里获取BeanDefinition对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        String[] beanNames = registry.getBeanDefinitionNames();
        // 进行每一个bean的初始化
        for (String beanName : beanNames) {
            // 调用具体子实现类的getBean方法进行bean的初始化
            getBean(beanName);
        }
    }
}

注意:该类finishBeanInitialization()方法中调用getBean()方法使用到模板方法模式

(4)ClassPathXmlApplicationContext类

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

  • 构造方法中,创建BeanDefinitionReader对象,因为在父类中声明了,在不同子类中具体实现。
  • 构造方法中,调用refresh()方法,用于进行配置文件加载、创建bean对象并存储到容器中。
  • 重写父接口中的getBean()方法,并实现依赖注入(DI)操作。
import com.aizen.framework.beans.BeanDefinition;
import com.aizen.framework.beans.MutablePropertyValues;
import com.aizen.framework.beans.PropertyValue;
import com.aizen.framework.beans.factory.support.BeanDefinitionRegistry;
import com.aizen.framework.beans.factory.xml.XmlBeanDefinitionReader;
import com.aizen.framework.utils.StringUtils;

import java.lang.reflect.Method;

// IOC容器的具体子实现类,用于加载类路径下的XML格式的配置文件
public class ClassPathXmlApplicationContext extends AbstractApplicationContext {
    public ClassPathXmlApplicationContext(String configLocation) {
        // 通过构造方法设置类路径下的配置文件路径
        this.configLocation = configLocation;
        // 构建解析器对象
        beanDefinitionReader = new XmlBeanDefinitionReader();
        // 调用refresh方法
        try {
            this.refresh();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // 根据bean对象的名称(id属性值)获取bean对象
    @Override
    public Object getBean(String name) throws Exception {
        // 判断对象容器中是否包含指定名称的bean对象
        Object obj = singletonObjects.get(name);
        // 如果包含,直接返回即可
        if (obj != null) return obj;
        // 如果不包含,需要自行创建,获取BeanDefinition对象,里面有bean的信息
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        // 不存在与该id属性值一致的bean,返回null
        if (beanDefinition == null) return null;

        // 若存在该beanDefinition对象,则获取bean信息中的className,有了全类名通过反射就可以创建对象
        String className = beanDefinition.getClassName();   // com.aizen.service.impl.UserServiceImpl
        // 通过反射创建对象
        Class<?> clazz = Class.forName(className);
        Object beanObj = clazz.newInstance();   // UserServiceImpl

        // 进行依赖注入操作
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        for (PropertyValue propertyValue : propertyValues) {
            // 获取property的属性
            String propertyName = propertyValue.getName();
            String ref = propertyValue.getRef();
            String value = propertyValue.getValue();
            // ref和value属性只能存在一个,判断使用了哪个属性
            if (ref != null &amp;&amp; !ref.isEmpty()) {
                // 注意:<property name="userDao",其中name的值应该和属性名setUserDao方法保持一致
                // 递归获取依赖的bean对象
                Object bean = getBean(ref); // getBean("UserDao"),返回userDao对象
                // 使用自定义工具类StringUtils拼接构造set方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);   // "userDao" --> "setUserDao"
                // 获取所有的方法对象
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    // 如果该方法是set方法
                    if (method.getName().equals(methodName)) {
                        // 执行setter方法进行依赖注入
                        method.invoke(beanObj, bean);   // userServiceImpl.setUserDao(userDao);
                    }
                }
            }

            if (value != null &amp;&amp; !value.isEmpty()) {
                // 使用自定义工具类StringUtils拼接构造set方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);   // 例:"username" -> "setUsername"
                // 获取method方法
                Method method = clazz.getMethod(methodName, String.class);
                method.invoke(beanObj, value);
            }
        }

        // 在返回beanObj对象之前,将该对象存储到Map容器中
        singletonObjects.put(name, beanObj);
        return beanObj;
    }

    @Override
    public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
        Object bean = getBean(name);
        if (bean == null) return null;
        T obj = clazz.cast(bean);
        return obj;
    }
}

StringUtils工具类:

public class StringUtils {
    // 私有构造方法
    private StringUtils() {}

    // ref:"userDao" --> "setUserDao" | value:"username" -> "setUsername"
    public static String getSetterMethodByFieldName(String fieldName) {
        return "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
    }
}

bean配置中属性ref与value的区别

ref value
ref引用已经存在的对象 value创建新的对象
ref可以引用其他的bean对象 value可以赋一些简单类型的值
使用ref的时候,Spring容器会在引用后进行验证,验证当前的xml是否存在引用的bean 使用value的时候,spring会在容器启动,实例化bean的时候进行验证

5、测试运行自定义Spring IOC框架

至此,我们已经完成了自定义SpringIoC的所有功能,下面来运行测试一下。

  1. 先把我们写的项目安装本地仓库mvn install

image.png
image.png

  1. 在我们之前的spring_demo项目引用该自定义的custom_spring依赖,并且注释掉之前的Spring的依赖。

image.png

  1. 将UserController中导入的Spring包删掉,改成导入我们自己的包,其他的地方不需要修改
import com.aizen.framework.context.ApplicationContext;
import com.aizen.framework.context.support.ClassPathXmlApplicationContext;
import com.aizen.service.UserService;

// 控制
public class UserController {
    public static void main(String[] args) throws Exception {
        // 创建Spring的容器对象(非延时加载)
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从ioc容器对象中获取userService对象
        UserService userService = applicationContext.getBean("userService", UserService.class);
        //调用userService方法进行业务逻辑处理
        userService.add();
    }
}
  1. 在此处打断点,Debug模式运行,可以看到执行创建IOC容器后,初始化加载并创建了bean对象,实现了非延时加载。

image.png
image.png

  1. 运行结果可以看到,userDao和userService对象都被创建了,说明IOC容器创建成功,Bean对象初始化并创建成功!并且userService调用add方法可以调用userDao的add方法,说明依赖注入成功!

image.png

  1. 测试完ref属性注入,下面再接着测试一下,value属性注入,添加如下代码后,测试运行
import com.aizen.dao.UserDao;

// 数据访问层实现类
public class UserDaoImpl implements UserDao {
    private String username;
    private String password;

    // 提供set方法进行注入
    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public UserDaoImpl() {
        System.out.println("userDao被创建了");
    }

    @Override
    public void add() {
        System.out.println("UserDao..." + username + " " + password);
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <!-- IOC容器管理对象 -->
    <bean id="userDao" class="com.aizen.dao.impl.UserDaoImpl">
        <property name="username" value="zhangsan"/>
        <property name="password" value="123456"/>
    </bean>
    <bean id="userService" class="com.aizen.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/><!-- 依赖注入DI -->
    </bean>
</beans>
  1. value属性注入String类型成功!实现了自定义依赖管理。

image.png

6、自定义Spring IOC总结

(1)使用到设计模式
  • 工厂模式。这个使用工厂模式 + 配置文件的方式
  • 单例模式。Spring IOC管理的bean对象都是单例的,此处的单例不是通过构造器进行单例的控制的,而是spring框架对每一个bean只创建了一个对象。
  • 模板方法模式。AbstractApplicationContext类中finishBeanInitialization()方法调用了子类的getBean()方法,因为getBean()的实现和环境息息相关。
  • 迭代器模式。对于MutablePropertyValues类定义使用到迭代器模式,因为此类存储并管理PropertyValue对象,也属于一个容器,所以给该容器提供一个遍历方式

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

(2)符合大部分设计原则

自行体会~~( ̄▽ ̄)”

(3)整个设计和Spring的设计还是有一定的出入

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

  • 了解Spring底层对对象的大体管理机制。
  • 了解设计模式在具体的开发中的使用。
  • 以后学习Spring源码,通过该案例的实现,可以降低Spring学习的成本。

五、设计模式常见相关面试问题

在这里插入图片描述

原文地址:https://blog.csdn.net/weixin_52152676/article/details/134692727

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。

如若转载,请注明出处:http://www.7code.cn/show_10807.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除!

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注