写点什么

如何实现一个简易版的 Spring - 如何实现 Setter 注入

用户头像
mghio
关注
发布于: 2021 年 03 月 27 日
如何实现一个简易版的 Spring - 如何实现 Setter 注入

前言

之前在 上篇 提到过会实现一个简易版的 IoCAOP,今天它终于来了。。。相信对于使用 Java 开发语言的朋友们都使用过或者听说过 Spring 这个开发框架,绝大部分的企业级开发中都离不开它,通过 [官网](https://spring.io) 可以了解到其生态非常庞大,针对不同方面的开发提供了一些解决方案,可以说 Spring 框架的诞生是对 Java 开发人员的一大福利,自 2004 年发布以来,Spring 为了解决一些企业开发中的痛点先后引入了很多的特性和功能,其中最重要的就是我们经常听到的 IoCAOP 特性,由于涉及到的知识和细节比较多,会分为几篇文章来介绍,今天这篇(也是第一篇)我们来看看如何实现基于 XML 配置方式的 Setter 注入

预备知识

既然是通过 XML 配置文件的方式,首先第一件事就是要读取 XML 文件然后转换为我们需要的数据结构,解析 XML 文件有但不限于这些方式(JDOM、XOM、dom4j),这里使用的是简单易上手的 dom4j,所你得对其基础知识有一些简单了解,其实都是一些很简单的方法基础使用而已,第二个就是你要有一些 Spring 框架的使用经验,这里实现的简易版本质上是对 Spring 的一个精简后的核心部分的简单实现,是的,没错,你只需要有了这些基础预备知识就可以了。

基础数据结构抽象

在开始编码实现前先要做一些简单的构思和设计,首先在 Spring 中把一个被其管理的对象称之为 Bean,然后其它的操作都是围绕这个 Bean 来展开设计的,所以为了能在程序中统一并且规范的表示一个 Bean 的定义,于是第一个接口 BeanDefinition 就出来了,本次需要的一些基本信息包含 Bean 的名称、所属类名称、是否单例、作用域等,如下所示:

现在 BeanDefinition 有了,接下来就是要根据这个 BeanDefinition 去创建出对应的 Bean 实例了,很显然这需要一个 Factory 工厂接口去完成这个创建的工作,这个创建 Bean 的接口命名为 BeanFactory,其提供根据不同条件去创建相对应的 Bean 实例功能(比如 beanId),但是创建的前提是需要先注册这个 BeanDefinition,然后根据一定条件再从中去获取 BeanDefinition,根据 单一职责 原则,这个功能应该由一个新的接口去完成,主要是做注册和获取 BeanDefinition 的工作,故将其命名为 BeanDefinitionRegistry,我们需要的 BeanDefinition 要从哪里获取呢?很显然我们是基于 XML 配置的方式,当然是从 XML 配置文件中获取到的,同样根据单一职责原则,也需要一个类去完成这个事情,将其命名为 XMLBeanDefinitionReader,这部分的整体结构如下所示:

接下来面临的一个问题就是,像 XML 这种配置文件资源要如何表示呢,这些配置对于程序来说是一种资源,可以统一抽象为 Resource,然后提供一个返回资源对应流(InputStream)对象接口,这种资源可以从项目中获取、本地文件获取甚至是从远程获取,它们都是一种 Resource,结构如下:

最后就是要一个提供去组合调用上面的那些类去完成 XML 配置文件解析为 BeanDefinition 并注入到容器中了的功能,担任这程序上下文的职责,将其命名为 ApplicationContext,这里同样也可以根据 Resource 的类型分为多种不同的类,比如:FileSystmXmlApplicationContextClassPathXmlApplicationContext 等,这些内部都有一个将配置文件转换为 Resource 的过程,可以使用 模板方法 抽象出一个公共父类抽象类,如下所示:

总结以上分析结果,得出初步类图设计如下:


最终要实现 Setter 注入这个目标,可以将其分解为以下两个步骤:

  1. XML 配置文件中的 <bean> 标签解析为 BeanDefinition 并注入到容器中

  2. 实现 Setter 注入

下面我们分为这两个部分来分别讲述如何实现。

配置文件解析

假设有如下内容的配置文件 applicationcontext-config1.xml:

<?xml version="1.0" encoding="UTF-8" ?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.e3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="orderService" class="cn.mghio.service.version1.OrderService" />
</beans>
复制代码

最终需要解析出一个 idorderService 类型为 cn.mghio.service.version1.OrderServiceBeanDefinition,翻译成测试类的话也就是需要让如下测试类可以运行通过:

/** * @author mghio */public class BeanFactoryTest {
private Resource resource; private DefaultBeanFactory beanFactory; private XmlBeanDefinitionReader reader;
@BeforeEach public void beforeEach() { resource = new ClassPathResource("applicationcontext-config1.xml"); beanFactory = new DefaultBeanFactory(); reader = new XmlBeanDefinitionReader(beanFactory); }
@Test public void testGetBeanFromXmlFile() { reader.loadBeanDefinition(resource); BeanDefinition bd = beanFactory.getBeanDefinition("orderService");
assertEquals("cn.mghio.service.version1.OrderService", bd.getBeanClassNam()); OrderService orderService = (OrderService) beanFactory.getBean("orderService"); assertNotNull(orderService); }
@Test public void testGetBeanFromXmlFileWithInvalidBeanId() { assertThrows(BeanCreationException.class, () -> beanFactory.getBean("notExistsBeanId")); }
@Test public void testGetFromXmlFilWithFileNotExists() { resource = new ClassPathResource("notExists.xml"); assertThrows(BeanDefinitionException.class, () -> reader.loadBeanDefinition(resource)); }
}
复制代码

可以看到这里面的关键就是如何去实现 XmlBeanDefinitionReader 类的 loadBeanDefinition 从配置中加载和注入 BeanDefinition,思考分析后不然发现这里主要是两步,第一步是解析 XML 配置转换为 BeanDefinition,这就需要上文提到的 dom4j 提供的能力了,第二步将解析出来的 BeanDefinition 注入到容器中,通过组合使用 BeanDefinitionRegistry 接口提供注册 BeanDefinition 的能力来完成。读取 XML 配置的类 XmlBeanDefinitionReader 的代码实现很快就可以写出来了,该类部分代码如下所示:

/** * @author mghio */public class XmlBeanDefinitionReader {
private static final String BEAN_ID_ATTRIBUTE = "id"; private static final String BEAN_CLASS_ATTRIBUTE = "class";
private BeanDefinitionRegistry registry;
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) { this.registry = registry; }
@SuppressWarnings("unchecked") public void loadBeanDefinition(Resource resource) { try (InputStream is = resource.getInputStream()) { SAXReader saxReader = new SAXReader(); Document document = saxReader.read(is); Element root = document.getRootElement(); // <beans> Iterator<Element> iterator = root.elementIterator(); while (iterator.hasNext()) { Element element = iterator.next(); String beanId = element.attributeValue(BEAN_ID_ATTRIBUTE); String beanClassName = element.attributeValue(BEAN_CLASS_ATTRIBUTE); BeanDefinition bd = new GenericBeanDefinition(beanId, beanClassName); this.registry.registerBeanDefinition(beanId, bd); } } catch (DocumentException | IOException e) { throw new BeanDefinitionException("IOException parsing XML document:" + configurationFile, e); } }}
复制代码

然后当调用 BeanFactorygetBean 方法时就可以根据 Bean 的全限定名创建一个实例出来了(PS:暂时不考虑实例缓存),方法实现主要代码如下:

public Object getBean(String beanId) {    BeanDefinition bd = getBeanDefinition(beanId);    if (null == bd) {        throw new BeanCreationException("BeanDefinition does not exists, beanId:" + beanId);    }    ClassLoader classLoader = this.getClassLoader();    String beanClassName = bd.getBeanClassNam();    try {        Class<?> clazz = classLoader.loadClass(beanClassName);        return clazz.newInstance();    } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {        throw new BeanCreationException("Created bean for " + beanClassName + " fail.", e);    }}
复制代码

到这里配置文件解析方面的工作已完成,接下来看看要如何实现 Setter 注入。

如何实现 Setter 注入

首先实现基于 XML 配置文件的 Setter 注入本质上也是解析 XML 配置文件,然后再调用对象属性的 setXXX 方法将配置的值设置进去,配置文件 applicationcontext-config2.xml 如下所示:

<?xml version="1.0" encoding="UTF-8" ?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.e3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="stockDao" class="cn.mghio.dao.version2.StockDao"/>
<bean id="tradeDao" class="cn.mghio.dao.version2.TradeDao"/>
<bean id="orderService" class="cn.mghio.service.version2.OrderService"> <property name="stockDao" ref="stockDao"/> <property name="tradeDao" ref="tradeDao"/> <property name="num" value="2"/> <property name="owner" value="mghio"/> <property name="orderTime" value="2020-11-24 18:42:32"/> </bean>
</beans>
复制代码

我们之前使用了 BeanDefinition 去抽象了 <bean> 标签,这里面临的第一个问题就是要如何去表达配置文件中的 <property> 标签,其中 ref 属性表示一个 beanIdvalue 属性表示一个值(值类型为:IntegerStringDate 等)。观察后可以发现,<property> 标签本质上是一个 K-V 格式的数据(name 作为 Keyrefvalue 作为 Value),将这个类命名为 PropertyValue,很明显一个 BeanDefinition 会有多个 PropertyValue,结构如下:

这里的 value 有两种不同的类型,一种是表示 Beanid 值,运行时会解析为一个 Bean 的引用,将其命名为 RuntimeBeanReference,还有一种是 String 类型,运行时会解析为不同的类型,将其命名为 TypeStringValue。第二个问题就是要如何将一个类型转换为另一个类型呢?比如将上面配置中的字符串 2 转换为整型的 2、字符串 2020-11-24 18:42:32 转换为日期,这类通用的问题前辈们已经开发好了类库处理了,这里我们使用 commons-beanutils 库提供的 BeanUtils.copyProperty(final Object bean, final String name, final Object value) 方法即可。然后只需在之前 XmlBeanDefinitionReader 类的 loadBeanDefinition 方法解析 XML 配置文件的时解析 <bean> 标签下的 <property> 标签并设置到 BeanDefinitionpropertyValues 属性中;DefaultBeanFactory 中的 getBean 方法分为实例化 Bean 和读取向实例化完成的 Bean 使用 Setter 注入配置文件中配置属性对应的值。XmlBeanDefinitionReaderloadBeanDefinition() 方法代码修改为:

public void loadBeanDefinition(Resource resource) {    try (InputStream is = resource.getInputStream()) {        SAXReader saxReader = new SAXReader();        Document document = saxReader.read(is);        Element root = document.getRootElement();  // <beans>        Iterator<Element> iterator = root.elementIterator();        while (iterator.hasNext()) {            Element element = iterator.next();            String beanId = element.attributeValue(BEAN_ID_ATTRIBUTE);            String beanClassName = element.attributeValue(BEAN_CLASS_ATTRIBUTE);            BeanDefinition bd = new GenericBeanDefinition(beanId, beanClassName);            parsePropertyElementValue(element, bd);  // parse <property>            this.registry.registerBeanDefinition(beanId, bd);        }    } catch (DocumentException | IOException e) {        throw new BeanDefinitionException("IOException parsing XML document:" + resource, e);    }}
private void parsePropertyElementValue(Element element, BeanDefinition bd) { Iterator<Element> iterator = element.elementIterator(PROPERTY_ATTRIBUTE); while (iterator.hasNext()) { Element propertyElement = iterator.next(); String propertyName = propertyElement.attributeValue(NAME_ATTRIBUTE); if (!StringUtils.hasText(propertyName)) { return; }
Object value = parsePropertyElementValue(propertyElement, propertyName); PropertyValue propertyValue = new PropertyValue(propertyName, value); bd.getPropertyValues().add(propertyValue); }
}
private Object parsePropertyElementValue(Element propertyElement, String propertyName) { String elementName = (propertyName != null) ? "<property> element for property '" + propertyName + "' " : "<constructor-arg> element";
boolean hasRefAttribute = propertyElement.attribute(REF_ATTRIBUTE) != null; boolean hasValueAttribute = propertyElement.attribute(VALUE_ATTRIBUTE) != null;
if (hasRefAttribute) { String refName = propertyElement.attributeValue(REF_ATTRIBUTE); RuntimeBeanReference ref = new RuntimeBeanReference(refName); return ref; } else if (hasValueAttribute) { String value = propertyElement.attributeValue(VALUE_ATTRIBUTE); TypedStringValue valueHolder = new TypedStringValue(value); return valueHolder; } else { throw new RuntimeException(elementName + " must specify a ref or value"); }}
复制代码

DefaultBeanFactorygetBean 方法也增加 Bean 属性注入操作,部分代码如下:

public Object getBean(String beanId) {    BeanDefinition bd = getBeanDefinition(beanId);    // 1. instantiate bean    Object bean = instantiateBean(bd);    // 2. populate bean    populateBean(bd, bean);    return bean;}
private Object instantiateBean(BeanDefinition bd) { ClassLoader classLoader = this.getClassLoader(); String beanClassName = bd.getBeanClassName(); try { Class<?> clazz = classLoader.loadClass(beanClassName); return clazz.newInstance(); } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) { throw new BeanCreationException("Created bean for " + beanClassName + " fail.", e); }}
private void populateBean(BeanDefinition bd, Object bean) { List<PropertyValue> propertyValues = bd.getPropertyValues(); if (propertyValues == null || propertyValues.isEmpty()) { return; }
BeanDefinitionResolver resolver = new BeanDefinitionResolver(this); SimpleTypeConverted converter = new SimpleTypeConverted(); try { for (PropertyValue propertyValue : propertyValues) { String propertyName = propertyValue.getName(); Object originalValue = propertyValue.getValue(); Object resolvedValue = resolver.resolveValueIfNecessary(originalValue);
BeanUtils.copyProperty(bean, propertyName, resolvedValue); } } catch (Exception e) { throw new BeanCreationException("Failed to obtain BeanInfo for class [" + bd.getBeanClassName() + "]"); }}
复制代码

至此,简单的 Setter 注入功能已完成。

总结

本文简单概述了基于 XML 配置文件方式的 Setter 注入简单实现过程,整体实现 Setter 注入的思路就是先设计一个数据结构去表达 XML 配置文件中的标签数据(比如上面的 PropertyValue),然后再解析配置文件填充数据并利用这个数据结构完成一些功能(比如 Setter 注入等)。感兴趣的朋友可以到这里 mghio-spring 查看完整代码。

发布于: 2021 年 03 月 27 日阅读数: 8
用户头像

mghio

关注

Java 工程师 2018.08.21 加入

Java 工程师 | 微信公众号「mghio」| 个人博客 「https://www.mghio.cn」

评论

发布
暂无评论
如何实现一个简易版的 Spring - 如何实现 Setter 注入