手写简版spring --5--资源加载器解析文件注册对象

一、目标

在完成 Spring 的框架雏形后，现在我们可以通过单元测试进行手动操作Bean对象的定义、注册和属性填充，以及最终获取对象调用方法。但这里会有一个问题，就是如果实际使用这个 Spring 框架，是不太可能让用户通过手动方式创建的，而是最好能通过配置文件的方式简化创建过程。需要完成如下操作：

如图中我们需要把步骤：2、3、4 整合到Spring 框架中，通过 Spring 配置文件的方式将 Bean 对象实例化。

接下来我们就需要在现有的 Spring 框架中，添加能解决 Spring 配置的读取、解析、注册Bean 的操作。

二、设计

依照本章节的需求背景，我们需要在现有的 Spring 框架雏形中添加一个资源解析器，也就是能读取classpath、本地文件和云文件的配置内容。这些配置内容就是像使用 Spring 时配置的 Spring.xml 一样，里面会包括 Bean 对象的描述和属性信息。 在读取配置文件信息后，接下来就是对配置文件中的Bean 描述信息解析后进行注册操作，把 Bean 对象注册到 Spring 容器中。整体设计结构如下图：

资源加载器属于相对独立的部分，它位于 Spring 框架核心包下的IO 实现内容，主要用于处理Class、本地和云环境中的文件信息。

当资源可以加载后，接下来就是解析和注册 Bean 到 Spring 中的操作，这部分实现需要和 DefaultListableBeanFactory 核心类结合起来，因为你所有的解析后的注册动作，都会把 Bean 定义信息放入到这个类中。

那么在实现的时候就设计好接口的实现层级关系，包括我们需要定义出 Bean 定义的读取接口 BeanDefinitionReader 以及做好对应的实现类，在实现类中完成对 Bean 对象的解析和注册。

三、实现

工程结构
类依赖图

该依赖中，不管是文件的来源是什么，加载后都由要经过xml解析，才能实现注入

本章节为了能把 Bean 的定义、注册和初始化交给 Spring.xml 配置化处理，那么就需要实现两大块内容，分别是：资源加载器、xml 资源处理类，实现过程主要以对接口 Resource、ResourceLoader的实现，而另外 BeanDefinitionReader 接口则是对资源的具体使用，将配置信息注册到 Spring 容器中去。

在Resource 的资源加载器的实现中包括了，ClassPath、系统文件、云配置文件，这三部分与 Spring源码中的设计和实现保持一致，最终在 DefaultResourceLoader 中做具体的调用。

接口：BeanDefinitionReader、抽象类：AbstractBeanDefinitionReader、实现类：XmlBeanDefinitionReader，这三部分内容主要是合理清晰的处理了资源读取后的注册 Bean容器操作。接口管定义，抽象类处理非接口功能外的注册Bean 组件填充，最终实现类即可只关心具体的业务实现

另外本章节还参考 Spring 源码，做了相应接口的集成和实现的关系，虽然这些接口目前还并没有太大的作用，但随着框架的逐步完善，它们也会发挥作用

BeanFactory，已经存在的 Bean 工厂接口用于获取 Bean 对象，这次新增加了按照类型获取 Bean 的方法：<T> T getBean(String name, Class<T> requiredType)

ListableBeanFactory，是一个扩展 Bean 工厂接口的接口，新增加了getBeansOfType、getBeanDefinitionNames() 方法，在 Spring 源码中还有其他扩展方法。

HierarchicalBeanFactory，在 Spring 源码中它提供了可以获取父类 BeanFactory方法，属于是一种扩展工厂的层次子接口。Sub-interface implemented by beanfactories that can be part of a hierarchy.

AutowireCapableBeanFactory，是一个自动化处理Bean 工厂配置的接口，目前案例工程中还没有做相应的实现，后续逐步完善。

ConfigurableBeanFactory，可获取 BeanPostProcessor、BeanClassLoader 等的一个配置化接口。

ConfigurableListableBeanFactory，提供分析和修改Bean 以及预先实例化的操作接口，不过目前只有一个 getBeanDefinition 方法。

四、代码

资源加载接口定义和实现

//定义 Resource 接口，提供获取 InputStream 流的方法
public interface Resource {InputStream getInputStream() throws IOException;
}

分别实现三种不同的流文件操作：classPath、FileSystem、URL

classPath

//这一部分的实现是用于通过 ClassLoader 读取ClassPath 下的文件信息，
//具体的读取过程主要是：classLoader.getResourceAsStream(path)
public class ClassPathResource implements Resource {private final String path;private ClassLoader classLoader;public ClassPathResource(String path) {this(path, (ClassLoader) null);}public ClassPathResource(String path, ClassLoader classLoader) {Assert.notNull(path, "Path must not be null");this.path = path;this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());}@Overridepublic InputStream getInputStream() throws IOException {InputStream is = classLoader.getResourceAsStream(path);if (is == null) {throw new FileNotFoundException(this.path + " cannot be opened because it does not exist");}return is;}
}

FileSystem

//通过指定文件路径的方式读取文件信息，这部分大家肯定还是非常熟悉的，经常会读取一些txt、excel 文件输出到控制台。
public class FileSystemResource implements Resource {private final File file;private final String path;public FileSystemResource(File file) {this.file = file;this.path = file.getPath();}public FileSystemResource(String path) {this.file = new File(path);this.path = path;}@Overridepublic InputStream getInputStream() throws IOException {return new FileInputStream(this.file);}public final String getPath() {return this.path;}
}

//通过 HTTP 的方式读取云服务的文件，我们也可以把配置文件放到 GitHub 或者Gitee 上。
public class UrlResource implements Resource{private final URL url;public UrlResource(URL url) {Assert.notNull(url,"URL must not be null");this.url = url;}@Overridepublic InputStream getInputStream() throws IOException {URLConnection con = this.url.openConnection();try {return con.getInputStream();}catch (IOException ex){if (con instanceof HttpURLConnection){((HttpURLConnection) con).disconnect();}throw ex;}}
}

包装资源加载器
按照资源加载的不同方式，资源加载器可以把这些方式集中到统一的类服务下进行处理，外部用户只需要传递资源地址即可，简化使用。

定义接口

//定义获取资源接口，里面传递 location 地址即可。
public interface ResourceLoader {/*** Pseudo URL prefix for loading from the class path: "classpath:"*/String CLASSPATH_URL_PREFIX = "classpath:";Resource getResource(String location);
}

实现接口

public class DefaultResourceLoader implements ResourceLoader {@Overridepublic Resource getResource(String location) {Assert.notNull(location, "Location must not be null");//本地资源if (location.startsWith(CLASSPATH_URL_PREFIX)) {return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()));}//网络资源else {try {URL url = new URL(location);return new UrlResource(url);} catch (MalformedURLException e) {return new FileSystemResource(location);}}}
}

在获取资源的实现中，主要是把三种不同类型的资源处理方式进行了包装，分为：判断是否为ClassPath、URL 以及文件。

虽然 DefaultResourceLoader 类实现的过程简单，但这也是设计模式约定的具体结果，像是这里不会让外部调用放知道过多的细节，而是仅关心具体调用结果即可。

Bean定义读取接口

public interface BeanDefinitionReader {BeanDefinitionRegistry getRegistry();
ResourceLoader getResourceLoader();
void loadBeanDefinitions(Resource resource) throws BeansException;
void loadBeanDefinitions(Resource... resources) throws BeansException;
void loadBeanDefinitions(String location) throws BeansException;
}

这是一个 Simple interface for bean definition readers. 其实里面无非定义了几个方法，包括：getRegistry()、getResourceLoader()，以及三个加载Bean 定义的方法。

这里需要注意 getRegistry()、getResourceLoader()，都是用于提供给后面三个方法的工具，加载和注册，这两个方法的实现会包装到抽象类中，以免污染具体的接口实现方法。

Bean 定义抽象类实现

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader {private final BeanDefinitionRegistry registry;private ResourceLoader resourceLoader;protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {this(registry, new DefaultResourceLoader());}public AbstractBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader)    {this.registry = registry;this.resourceLoader = resourceLoader;}@Overridepublic BeanDefinitionRegistry getRegistry() {return registry;}@Overridepublic ResourceLoader getResourceLoader() {return resourceLoader;}
}

抽象类把 BeanDefinitionReader 接口的前两个方法全部实现完了，并提供了构造函数，让外部的调用使用方，把Bean 定义注入类，传递进来。

这样在接口 BeanDefinitionReader 的具体实现类中，就可以把解析后的 XML 文件中的 Bean 信息，注册到 Spring 容器去了。以前我们是通过单元测试使用，调用 BeanDefinitionRegistry 完成Bean 的注册，现在可以放到 XMl 中操作了

解析XML 处理Bean 注册

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) {super(registry);}public XmlBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {super(registry, resourceLoader);}@Overridepublic void loadBeanDefinitions(Resource resource) throws BeansException {try {try (InputStream inputStream = resource.getInputStream()) {doLoadBeanDefinitions(inputStream);}} catch (IOException | ClassNotFoundException e) {throw new BeansException("IOException parsing XML document from " + resource, e);}}@Overridepublic void loadBeanDefinitions(Resource... resources) throws BeansException {for (Resource resource : resources) {loadBeanDefinitions(resource);}}@Overridepublic void loadBeanDefinitions(String location) throws BeansException {ResourceLoader resourceLoader = getResourceLoader();Resource resource = resourceLoader.getResource(location);loadBeanDefinitions(resource);}protected void doLoadBeanDefinitions(InputStream inputStream) throws ClassNotFoundException {Document doc = XmlUtil.readXML(inputStream);Element root = doc.getDocumentElement();NodeList childNodes = root.getChildNodes();for (int i = 0; i < childNodes.getLength(); i++) {// 判断元素if (!(childNodes.item(i) instanceof Element)) continue;// 判断对象if (!"bean".equals(childNodes.item(i).getNodeName())) continue;// 解析标签Element bean = (Element) childNodes.item(i);String id = bean.getAttribute("id");String name = bean.getAttribute("name");String className = bean.getAttribute("class");// 获取 Class，方便获取类中的名称Class<?> clazz = Class.forName(className);// 优先级 id > nameString beanName = StrUtil.isNotEmpty(id) ? id : name;if (StrUtil.isEmpty(beanName)) {beanName = StrUtil.lowerFirst(clazz.getSimpleName());}// 定义BeanBeanDefinition beanDefinition = new BeanDefinition(clazz);// 读取属性并填充for (int j = 0; j < bean.getChildNodes().getLength(); j++) {if (!(bean.getChildNodes().item(j) instanceof Element)) continue;if (!"property".equals(bean.getChildNodes().item(j).getNodeName())) continue;// 解析标签：propertyElement property = (Element) bean.getChildNodes().item(j);String attrName = property.getAttribute("name");String attrValue = property.getAttribute("value");String attrRef = property.getAttribute("ref");// 获取属性值：引入对象、值对象Object value = StrUtil.isNotEmpty(attrRef) ? new BeanReference(attrRef) : attrValue;// 创建属性信息PropertyValue propertyValue = new PropertyValue(attrName, value);beanDefinition.getPropertyValues().addPropertyValue(propertyValue);}if (getRegistry().containsBeanDefinition(beanName)) {throw new BeansException("Duplicate beanName[" + beanName + "] is not allowed");}// 注册 BeanDefinitiongetRegistry().registerBeanDefinition(beanName, beanDefinition);}}
}

XmlBeanDefinitionReader 类最核心的内容就是对 XML 文件的解析，把我们本来在代码中的操作放到了通过解析 XML 自动注册的方式。

loadBeanDefinitions 方法，处理资源加载，这里新增加了一个内部方法：doLoadBeanDefinitions，它主要负责解析 xml

在 doLoadBeanDefinitions 方法中，主要是对xml 的读取XmlUtil.readXML(inputStream) 和元素 Element 解析。在解析的过程中通过循环操作，以此获取 Bean 配置以及配置中的 id、name、class、value、ref信息。

最终把读取出来的配置信息，创建成 BeanDefinition 以及 PropertyValue，最终把完整的 Bean 定义内容注册到 Bean 容器：getRegistry().registerBeanDefinition(beanName,beanDefinition)

五、测试

准备UserDao,UserService

public class UserDao {private static Map<String, String> hashMap = new HashMap<>();static {hashMap.put("10001", "小傅哥");hashMap.put("10002", "八杯水");hashMap.put("10003", "阿毛");}public String queryUserName(String uId) {return hashMap.get(uId);}
}

public class UserService {private String uId;private UserDao userDao;public String queryUserInfo() {return userDao.queryUserName(uId);}public String getuId() {return uId;}public void setuId(String uId) {this.uId = uId;}public UserDao getUserDao() {return userDao;}public void setUserDao(UserDao userDao) {this.userDao = userDao;}
}

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao"/>
<bean id="userService" class="cn.bugstack.springframework.test.bean.UserService
">
<property name="uId" value="10001"/>
<property name="userDao" ref="userDao"/>
</bean>
</beans>

test

    @Beforepublic void init() {resourceLoader = new DefaultResourceLoader();}@Testpublic void test_classpath() throws IOException {Resource resource = resourceLoader.getResource("classpath:important.properties");InputStream inputStream = resource.getInputStream();String content = IoUtil.readUtf8(inputStream);System.out.println(content);}@Testpublic void test_file() throws IOException {Resource resource = resourceLoader.getResource("src/test/resources/important.properties");InputStream inputStream = resource.getInputStream();String content = IoUtil.readUtf8(inputStream);System.out.println(content);}@Testpublic void test_url() throws IOException {Resource resource = resourceLoader.getResource("https://github.com/fuzhengwei/small-spring/important.properties");InputStream inputStream = resource.getInputStream();String content = IoUtil.readUtf8(inputStream);System.out.println(content);}@Testpublic void test_xml() {// 1.初始化 BeanFactoryDefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 2. 读取配置文件&注册BeanXmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);reader.loadBeanDefinitions("classpath:spring.xml");// 3. 获取Bean对象调用方法UserService userService = beanFactory.getBean("userService", UserService.class);String result = userService.queryUserInfo();System.out.println("测试结果：" + result);}