手写Spring：第6章-资源加载器解析文件注册对象

news2025/1/15 22:56:27

文章目录

  • 一、目标：资源加载器解析文件注册对象
  • 二、设计：资源加载器解析文件注册对象
  • 三、实现：资源加载器解析文件注册对象
    • 3.1 工程结构
    • 3.2 资源加载器解析文件注册对象类图
    • 3.3 类工具类
    • 3.4 资源加载接口定义和实现
      • 3.4.1 定义资源加载接口
      • 3.4.2 类路径资源实现接口
      • 3.4.3 文件资源实现类
      • 3.4.4 URL资源实现类
    • 3.5 包装资源加载器
      • 3.5.1 资源加载器接口
      • 3.5.2 默认实现的资源加载器
    • 3.6 Bean定义读取接口及实现类
      • 3.6.1 定义Bean读取接口
      • 3.6.2 定义Bean读取抽象类
      • 3.6.3 解析XML处理Bean注册
    • 3.7 Bean工厂接口完善
      • 3.7.1 Bean工厂接口
      • 3.7.2 扩展Bean工厂子接口
      • 3.7.3 扩展Bean工厂的层次子接口
      • 3.7.4 自动化处理Bean工厂配置接口
      • 3.7.5 Bean工厂配置化接口
      • 3.7.6 Bean工厂预先实例化的操作接口
    • 3.8 Bean接口及其实现类完善
      • 3.8.1 Bean工厂抽象类
      • 3.8.2 修改Bean注册接口
      • 3.8.3 默认的Bean工厂实现类
  • 四、测试：资源加载器解析文件注册对象
    • 4.1 添加配置文件
      • 4.1.1 properties配置文件
      • 4.1.2 xml配置文件
    • 4.2 单元测试
      • 4.2.1 xml配置测试
      • 4.2.2 加载类路径测试
      • 4.2.3 加载文件路径测试
      • 4.2.4 加载URL路径测试
  • 五、总结：资源加载器解析文件注册对象

一、目标：资源加载器解析文件注册对象

💡 如何通过 Spring 配置文件的方式将 Bean 对象实例化？

  • 现在是通过单元测试手动操作 Beab 对象的定义、注册和属性填充，以及最终获取对象调用方法。
    • 但是这里有个问题？实际使用 Spring 框架，是不太可能让用户通过手动方式创建的，而是最好能通过配置文件的方式简化创建过程。

在这里插入图片描述

  • 如图中所示：把 2、3、4 整合到 Spring 框架中，通过 Spring 配置文件的方式将 Bean 对象实例化。
  • 接下来就需要在现有的 Spring 框架中，添加能解决 Spring 配置的读取、解析、注册 Bean 操作。

二、设计：资源加载器解析文件注册对象

💡 技术设计：资源加载器解析文件注册对象

  • 需要在现有的 Spring 框架雏形中添加一个资源解析器，也就是能读取 classpath、本地文件和云文件的配置内容。
    • 这些配置内容就是像使用 Spring 时配置的 spring.xml 一样，里面会包括 Bean 对象的描述和属性信息。
    • 在读取配置文件信息后，接下来就是对配置文件中的 Bean 描述信息解析后进行注册操作，把 Bean 对象注册到 Spring 容器中。

在这里插入图片描述

  • 资源加载器属于相对独立的部分，它位于 Spring 框架核心包下的 I/O 实现内容，主要用于处理 Class、本地和云环境的文件信息。
  • 当资源可以加载后，接下来就是解析和注册 Bean 到 Spring 中的操作，这部分实现需要和 DefaultListableBeanFactory 核心类结合起来。
    • 因为你所有的解析后的注册动作，都会把 Bean 定义信息放入到这个类中。
  • 在实现时就设计好接口的实现层级关系，包括我们需要定义出 Bean 定义的读取接口 BeanDefinitionReader 以及做好对应的实现类，在实现类中完成对 Bean 对象的解析和注册。

三、实现：资源加载器解析文件注册对象

3.1 工程结构

spring-step-05
|-src
  |-main
  | |-java
  |   |-com.lino.springframework
  |     |-beans
  |     | |-factory
  |     | | |-config
  |     | | | |-AutowireCapableBeanFactory.java
  |     | | | |-BeanDefinition.java
  |     | | | |-BeanReference.java
  |     | | | |-ConfigurableBeanFactory.java
  |     | | | |-SingletonBeanRegistry.java
  |     | | |-support
  |     | | | |-AbstractAutowireCapableBeanFactory.java
  |     | | | |-AbstractBeabDefinitionReader.java
  |     | | | |-AbstractBeabFactory.java
  |     | | | |-BeabDefinitionReader.java
  |     | | | |-BeanDefinitionRegistry.java
  |     | | | |-CglibSubclassingInstantiationStrategy.java
  |     | | | |-DefaultListableBeanFactory.java
  |     | | | |-DefaultSingletonBeanRegistry.java
  |     | | | |-InstantiationStrategy.java
  |     | | | |-SimpleInstantiationStrategy.java
  |     | | |-support
  |     | | | |-XMLBeanDefinitionReader.java
  |     | | |-BeanFactory.java
  |     | | |-ConfigurableListableBeanFactory.java
  |     | | |-HierarcgicalBeanFactory.java
  |     | | |-ListableBeanFactory.java
  |     | |-BeansException.java
  |     | |-PropertyValue.java
  |     | |-PropertyValues.java
  |     |-core.io
  |     | |-ClassPathResource.java
  |     | |-DefaultResourceLoader.java
  |     | |-FileSystemResource.java
  |     | |-Resource.java
  |     | |-ResourceLoader.java
  |     | |-UrlResource.java
  |     |-util
  |     | |-ClassUtils.java
  |-test
    |-java
      |-com.lino.springframework.test
      |-bean
      | |-UserDao.java
      | |-UserService.java
      |-ApiTest.java
    |-resources
      |-important.properties
      |-spring.xml

3.2 资源加载器解析文件注册对象类图

在这里插入图片描述

  • 为了能把 Bean 的定义、注册和初始化交给 spring.xml 配置化处理，那么就需要实现两大块内容，分别是：资源加载器、xml 资源处理类。
    • 实现过程主要以对接口 Resource、ReourceLoader 的实现。
    • 而另外 BeanDefinitionReader 接口则是对资源的具体使用，将配置信息注册到 Spring 容器中去。
  • 在 Resource 的资源加载器的实现中包括了：ClassPath、系统文件、云配置文件，这三部分与 Spring 源码中的设计和实现保持一致。
    • 最终在 DefaultResourceLoader 中做具体的调用。
  • 接口：BeanDefinitionReader，实现类：AbstractBeanDefinitionReader，实现类：XMLBeanDefinitionReader。
    • 这三部分内容主要是合理清晰的处理了资源读取后的注册 Bean 容器操作。
    • 接口管定义、抽象类处理非接口功能外的注册 Bean 组件填充，最终实现类即可只关心具体的业务实现。

在这里插入图片描述

  • BeanFactory：已经存在的 Bean 工厂接口用于获取 Bean 对象。
    • 这次新增加了按照类型获取 Bean 的方法：<T> T getBean(String name, Class<T> requiredType)
  • ListableBeanFactory：是一个扩展 Bean 工厂接口的接口，新增加了 getBeansOfType、getBeanDefinitionNames 方法。
  • HierarchicalBeanFactory：在 Spring 源码中它提供了可以获取父类 BeanFactory 方法，属于是一种扩展工厂的层次子接口
  • AutowireCapableBeanFactory：是一个自动化处理 Bean 工厂配置的接口。
  • ConfigurableBeanFactory：可获取 BeanPostProcessor、BeanClassLoader 等的一个配置化接口
  • ConfigurableListableBeanFactory：提供分析和修改 Bean 以及预先实例化的操作接口。先在只有 getBeanDefinition 方法。

3.3 类工具类

ClassUtils

package com.lino.springframework.util;

/**
 * @description: 类工具类
 */
public class ClassUtils {

    /**
     * 获取默认类加载器
     * @return 类加载器
     */
    public static ClassLoader getDefaultClassLoader() {
        ClassLoader cl = null;
        try {
            cl = Thread.currentThread().getContextClassLoader();
        } catch (Throwable ex) {
            // Cannot access thread context ClassLoader - falling back to system class loader...
        }
        if (cl == null) {
            // No thread context class loader -> use class loader of this class.
            cl = ClassUtils.class.getClassLoader();
        }
        return cl;
    }
}

3.4 资源加载接口定义和实现

3.4.1 定义资源加载接口

Resource.java

package com.lino.springframework.core.io;

import java.io.IOException;
import java.io.InputStream;

/**
 * @description: 资源处理接口
 */
public interface Resource {

    /**
     * 加载资源流
     *
     * @return 输入流
     * @throws IOException IO异常
     */
    InputStream getInputStream() throws IOException;
}
  • 在 Spring 框架下创建 core.io 核心包，在这个包中主要用于处理资源加载流。
  • 定义 Resource 接口，提供获取 InputStream 流的方法，接下来再分别实现三种不同的流文件操作：classPath、FileSystem、URL

3.4.2 类路径资源实现接口

ClassPathResource.java

package com.lino.springframework.core.io;

import cn.hutool.core.lang.Assert;
import com.lino.springframework.util.ClassUtils;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * @description: 类路径资源
 */
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());
    }

    @Override
    public 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;
    }
}
  • 这部分的实现是用于通过 ClassLoader 读取 ClassPath 下的文件信息，具体的读取过程：classLoader.getResourceAsStream(path)。

3.4.3 文件资源实现类

FileSystemResource.java

package com.lino.springframework.core.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * @description: 文件资源
 */
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;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        return new FileInputStream(this.file);
    }

    public final String getPath() {
        return this.path;
    }
}
  • 通过指定文件路径的方式读取文件信息。

3.4.4 URL资源实现类

UrlResource.java

package com.lino.springframework.core.io;

import cn.hutool.core.lang.Assert;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

/**
 * @description: URL 资源
 */
public class UrlResource implements Resource {

    private final URL url;

    public UrlResource(URL url) {
        Assert.notNull(url, "URL must not be null");
        this.url = url;
    }

    @Override
    public 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;
        }
    }
}
  • 通过 HTTP 的方式读取云服务的文件。

3.5 包装资源加载器

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

3.5.1 资源加载器接口

ResourceLoader.java

package com.lino.springframework.core.io;

/**
 * @description: 资源加载器
 */
public interface ResourceLoader {

    /**
     * Pseudo URL prefix for loading from the class path: "classpath:"
     */
    String CLASSPATH_URL_OREFIX = "classpath:";

    /**
     * 获取资源
     *
     * @param location 资源名称
     * @return 资源
     */
    Resource getResource(String location);
}
  • 定义获取资源接口，里面传递 location 地址即可。

3.5.2 默认实现的资源加载器

DefaultResourceLoader.java

package com.lino.springframework.core.io;

import cn.hutool.core.lang.Assert;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * @description: 默认实现的资源处理器
 */
public class DefaultResourceLoader implements ResourceLoader {

    @Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        if (location.startsWith(CLASSPATH_URL_OREFIX)) {
            return new ClassPathResource(location.substring(CLASSPATH_URL_OREFIX.length()));
        } else {
            try {
                URL url = new URL(location);
                return new UrlResource(url);
            } catch (MalformedURLException e) {
                return new FileSystemResource(location);
            }
        }
    }
}
  • 在获取资源的实现中，主要把三种不同类型的资源处理方式进行了包装，分为：判断是否为 ClassPath、URL、文件。
  • 虽然 DefaultResourceLoader 类实现的过程简单，但这也是设计模式约定的具体结果，像是这里不会让外部调用方知道太多的细节，而是仅关心具体调用结果即可。

3.6 Bean定义读取接口及实现类

3.6.1 定义Bean读取接口

BeanDefinitionReader.java

package com.lino.springframework.beans.factory.support;

import com.lino.springframework.beans.BeansException;
import com.lino.springframework.core.io.Resource;
import com.lino.springframework.core.io.ResourceLoader;

/**
 * @description: Bean定义读取接口
 */
public interface BeanDefinitionReader {

    /**
     * 获取bean对象注册对象
     *
     * @return bean对象注册对象
     */
    BeanDefinitionRegistry getRegistry();

    /**
     * 获取资源加载器
     *
     * @return 资源加载器
     */
    ResourceLoader getResourceLoader();

    /**
     * 加载bean定义方法
     *
     * @param resource 资源
     * @throws BeansException bean异常
     */
    void loadBeanDefinitions(Resource resource) throws BeansException;

    /**
     * 加载bean定义方法
     *
     * @param resources 资源列表
     * @throws BeansException bean异常
     */
    void loadBeanDefinitions(Resource... resources) throws BeansException;

    /**
     * 加载bean定义方法
     *
     * @param location 路径名称
     * @throws BeansException bean异常
     */
    void loadBeanDefinitions(String location) throws BeansException;
}
  • 这是一个简单 Bean 读取接口，这个接口里面定义了几个方法，包括：getRegistry、getResourceLoader，以及三个加载 Bean 定义的方法。
  • 这里需要注意 getRegistry、getResourceLoader，都是用于提供给后面三个方法的工具，加载和注册。
    • 这两个方法的实现会包装到抽象类中，以免污染具体的接口实现方法。

3.6.2 定义Bean读取抽象类

AbstractBeanDefinitionReader.java

package com.lino.springframework.beans.factory.support;

import com.lino.springframework.core.io.DefaultResourceLoader;
import com.lino.springframework.core.io.ResourceLoader;

/**
 * @description: 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;
    }

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

    @Override
    public ResourceLoader getResourceLoader() {
        return resourceLoader;
    }
}
  • 抽象类把 BeanDefinitionReader 接口的前两个方法全部实现了，并提供了构造函数，让外部的调用使用方，把 Bean 定义注入类，传递进来。
  • 这样在接口 BeanDefinitionReader 的具体实现类中，就可以把解析后的 XML 文件中的 Bean 信息，注册到 Spring 容器去了。

3.6.3 解析XML处理Bean注册

XMLBeanDefinitionReader.java

package com.lino.springframework.beans.factory.xml;

import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.XmlUtil;
import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.PropertyValue;
import com.lino.springframework.beans.factory.config.BeanDefinition;
import com.lino.springframework.beans.factory.config.BeanReference;
import com.lino.springframework.beans.factory.support.AbstractBeanDefinitionReader;
import com.lino.springframework.beans.factory.support.BeanDefinitionRegistry;
import com.lino.springframework.core.io.Resource;
import com.lino.springframework.core.io.ResourceLoader;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.IOException;
import java.io.InputStream;

/**
 * @description: XML处理Bean注册
 */
public class XMLBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public XMLBeanDefinitionReader(BeanDefinitionRegistry registry) {
        super(registry);
    }

    public XMLBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
        super(registry, resourceLoader);
    }

    @Override
    public 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);
        }
    }

    @Override
    public void loadBeanDefinitions(Resource... resources) throws BeansException {
        for (Resource resource : resources) {
            loadBeanDefinitions(resource);
        }
    }

    @Override
    public 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 > name
            String beanName = StrUtil.isNotEmpty(id) ? id : name;
            if (StrUtil.isEmpty(beanName)) {
                beanName = StrUtil.lowerFirst(clazz.getSimpleName());
            }

            // 定义bean
            BeanDefinition 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;
                }
                // 解析标签：property
                Element 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");
            }
            // 注册 BeanDefinition
            getRegistry().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)

3.7 Bean工厂接口完善

3.7.1 Bean工厂接口

BeanFactory.java

package com.lino.springframework.beans.factory;

import com.lino.springframework.beans.BeansException;

/**
 * @description: 定义 Bean 工厂接口
 */
public interface BeanFactory {

    /**
     * 返回 Bean 的实例对象
     *
     * @param name 要检索的bean的名称
     * @return 实例化的 Bean 对象
     * @throws BeansException 不能获取 Bean 对象，抛出异常
     */
    Object getBean(String name) throws BeansException;

    /**
     * 返回含构造函数的 Bean 实例对象
     *
     * @param name 要检索的bean的名称
     * @param args 构造函数入参
     * @return 实例化的 Bean 对象
     * @throws BeansException 不能获取 Bean 对象，抛出异常
     */
    Object getBean(String name, Object... args) throws BeansException;

    /**
     * 返回指定泛型的对象
     *
     * @param name         要检索的bean的名称
     * @param requiredType 类型
     * @param <T>          泛型
     * @return 实例化的的 Bean 对象
     * @throws BeansException 不能获取 Bean 对象，抛出异常
     */
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
}

3.7.2 扩展Bean工厂子接口

ListableBeanFactory.java

package com.lino.springframework.beans.factory;

import com.lino.springframework.beans.BeansException;

import java.util.Map;

/**
 * @description: Listable Bean 工厂子接口
 */
public interface ListableBeanFactory extends BeanFactory {
    /**
     * 按照类型返回 Bean 实例
     *
     * @param type 类型
     * @param <T>  泛型
     * @return 泛型Map
     * @throws BeansException Bean异常
     */
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;

    /**
     * 返回注册表中所有的Bean名称
     *
     * @return 注册表中所有的Bean名称
     */
    String[] getBeanDefinitionNames();
}

3.7.3 扩展Bean工厂的层次子接口

HierarchicalBeanFactory.java

package com.lino.springframework.beans.factory;

/**
 * @description: hierarchy bean工厂层次子接口
 */
public interface HierarchicalBeanFactory extends BeanFactory {
}

3.7.4 自动化处理Bean工厂配置接口

AutowireCapableBeanFactory.java

package com.lino.springframework.beans.factory.config;

import com.lino.springframework.beans.factory.BeanFactory;

/**
 * @description: 自动化处理Bean工厂配置接口
 */
public interface AutowireCapableBeanFactory extends BeanFactory {
}

3.7.5 Bean工厂配置化接口

ConfigurableBeanFactory.java

package com.lino.springframework.beans.factory.config;

import com.lino.springframework.beans.factory.HierarchicalBeanFactory;

/**
 * @description: 配置Bean工厂接口
 */
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    String SCOPE_SINGLETON = "singleton";

    String SCOPE_PROTOTYPE = "prototype";
}

3.7.6 Bean工厂预先实例化的操作接口

ConfigurableListableBeanFactory.java

package com.lino.springframework.beans.factory;

import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.config.AutowireCapableBeanFactory;
import com.lino.springframework.beans.factory.config.BeanDefinition;
import com.lino.springframework.beans.factory.config.ConfigurableBeanFactory;

/**
 * @description: 配置列表 Bean工厂接口
 */
public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    /**
     * 根据对象名称获取bean对象
     *
     * @param beanName 对象名称
     * @return bean对象
     * @throws BeansException bean异常
     */
    BeanDefinition getBeanDefinition(String beanName) throws BeansException;
}

3.8 Bean接口及其实现类完善

3.8.1 Bean工厂抽象类

AbstractBeanFactory.java

package com.lino.springframework.beans.factory.support;

import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.BeanFactory;
import com.lino.springframework.beans.factory.config.BeanDefinition;

/**
 * @description: 抽象的 Bean 工厂基类，定义模板方法
 */
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {

    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null);
    }

    @Override
    public Object getBean(String name, Object... args) throws BeansException {
        return doGetBean(name, args);
    }

    @Override
    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return (T) getBean(name);
    }

    protected <T> T doGetBean(final String name, final Object[] args) {
        Object bean = getSingleton(name);
        if (bean != null) {
            return (T) bean;
        }
        BeanDefinition beanDefinition = getBeanDefinition(name);
        return (T) createBean(name, beanDefinition, args);
    }

    /**
     * 获取 Bean 对象
     *
     * @param beanName 要检索的bean的名称
     * @return Bean 对象
     */
    protected abstract BeanDefinition getBeanDefinition(String beanName);

    /**
     * 创建Bean对象
     *
     * @param beanName       要检索的bean的名称
     * @param beanDefinition Bean对象
     * @param args           构造函数入参
     * @return 实例化的Bean对象
     */
    protected abstract Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args);
}

3.8.2 修改Bean注册接口

BeanDefinitionRegistry.java

package com.lino.springframework.beans.factory.support;

import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.config.BeanDefinition;

/**
 * @description: Bean 定义注册接口
 */
public interface BeanDefinitionRegistry {

    /**
     * 向注册表中注册 BeanDefinition
     *
     * @param beanName       Bean 名称
     * @param beanDefinition Bean 定义
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    /**
     * 使用Bean名称查询BeanDefinition
     *
     * @param beanName bean名称
     * @return bean对象
     * @throws BeansException bean异常
     */
    BeanDefinition getBeanDefinition(String beanName) throws BeansException;

    /**
     * 判断是否包含指定名称的BeanDefinition
     *
     * @param beanName bean名称
     * @return 是否包含
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 返回注册表中所有的Bean对象
     *
     * @return Bean对象数组
     */
    String[] getBeanDefinitionNames();
}

3.8.3 默认的Bean工厂实现类

DefaultListableBeanFactory.java

package com.lino.springframework.beans.factory.support;

import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.ConfigurableListableBeanFactory;
import com.lino.springframework.beans.factory.config.BeanDefinition;

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

/**
 * @description: 默认的Bean工厂实现类
 */
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry, ConfigurableListableBeanFactory {

    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();

    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        if (beanDefinition == null) {
            throw new BeansException("No bean named '" + beanName + "' is defined");
        }
        return beanDefinition;
    }

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

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

    @Override
    public <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
        Map<String, T> result = new HashMap<>(16);
        beanDefinitionMap.forEach((beanName, beanDefinition) -> {
            Class beanClass = beanDefinition.getBeanClass();
            if (type.isAssignableFrom(beanClass)) {
                result.put(beanName, (T) getBean(beanName));
            }
        });
        return result;
    }

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

四、测试：资源加载器解析文件注册对象

4.1 添加配置文件

💡 这里的两份配置文件，一份用于测试资源加载器，另外 spring.xml 用于测试整体的 Bean 注册功能。

4.1.1 properties配置文件

important.properties

# Config File
system.key=OLpj9823dZ

4.1.2 xml配置文件

spring.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans>
    <bean id="userDao" class="com.lino.springframework.test.bean.UserDao"/>

    <bean id="userService" class="com.lino.springframework.test.bean.UserService">
        <property name="uId" value="10001"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

4.2 单元测试

4.2.1 xml配置测试

ApiTest.java

package com.lino.springframework.test;

import cn.hutool.core.io.IoUtil;
import com.lino.springframework.beans.factory.support.DefaultListableBeanFactory;
import com.lino.springframework.beans.factory.xml.XMLBeanDefinitionReader;
import com.lino.springframework.core.io.DefaultResourceLoader;
import com.lino.springframework.core.io.Resource;
import com.lino.springframework.test.bean.UserService;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;

/**
 * @description: 测试类
 */
public class ApiTest {

    private DefaultResourceLoader resourceLoader;

    @Before
    public void init() {
        resourceLoader = new DefaultResourceLoader();
    }

    @Test
    public void test_xml() {
        // 1.初始化 BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        // 2.读取配置文件&注册Bean
        XMLBeanDefinitionReader 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);
    }
}

测试结果

查询用户信息: 张三
  • 从测试结果来看，已经把注册 Bean 以及配置属性信息的内容，交给了 newXMLBeanDefinitionReader(beanFactory) 类读取 spring.xml 的方式来处理，并通过了测试。

4.2.2 加载类路径测试

ApiTest.java

@Test
public 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);
}

测试结果

# Config File
system.key=OLpj9823dZ

4.2.3 加载文件路径测试

ApiTest.java

@Test
public 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);
}

测试结果

# Config File
system.key=OLpj9823dZ

4.2.4 加载URL路径测试

ApiTest.java

@Test
public 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);
}

测试结果

# Config File
system.key=OLpj9823dZ

五、总结：资源加载器解析文件注册对象

  • 此时的工程结构，以配置文件为入口解析和注册 Bean 信息，最终再通过 Bean 工厂获取 Bean 以及做相应的调用操作。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/980823.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

面试算法-常用数据结构

面试算法-常用数据结构

文章目录 数据结构数组链表 栈队列双端队列树 1&#xff09;算法和数据结构 2&#xff09;判断候选人的标准 算法能力能够准确辨别一个程序员的功底是否扎实 数据结构 数组 链表 优点&#xff1a; 1&#xff09;O(1)时间删除或者添加 灵活分配内存空间 缺点&#xff1a; 2&…
阅读更多...
把文件上传到Gitee的详细步骤

把文件上传到Gitee的详细步骤

目录 第一步&#xff1a;创建一个空仓库 第二步&#xff1a;找到你想上传的文件所在的地址&#xff0c;打开命令窗口&#xff0c;git init 第三步&#xff1a;git add 想上传的文件 &#xff0c;git commit -m "给这次提交取个名字" 第四步&#xff1a;和咱们在第…
阅读更多...
生成多样、真实的评论(2019 IEEE International Conference on Big Data )

生成多样、真实的评论(2019 IEEE International Conference on Big Data )

论文题目&#xff08;Title&#xff09;&#xff1a;Learning to Generate Diverse and Authentic Reviews via an Encoder-Decoder Model with Transformer and GRU 研究问题&#xff08;Question&#xff09;&#xff1a;评论生成&#xff0c;由上下文评论->生成评论 研…
阅读更多...
Android之“写死”数据

Android之“写死”数据

何为“写死”&#xff0c;即写完之后除非手动修改&#xff0c;否像嘎了一样在那固定死了 在实际安卓开发中&#xff0c;这种写死的概念必不可少&#xff0c;如控件的id&#xff0c;某一常量&#xff0c;Kotlin中的Val 当然&#xff0c;有些需求可能也会要求我们去写死数据&am…
阅读更多...
实战：大数据Flink CDC同步Mysql数据到ElasticSearch

实战：大数据Flink CDC同步Mysql数据到ElasticSearch

文章目录 前言知识积累CDC简介CDC的种类常见的CDC方案比较 Springboot接入Flink CDC环境准备项目搭建 本地运行集群运行将项目打包将包传入集群启动远程将包部署到flink集群 写在最后 前言 前面的博文我们分享了大数据分布式流处理计算框架Flink和其基础环境的搭建&#xff0c…
阅读更多...
入门力扣自学笔记279 C++ （题目编号：1123）

入门力扣自学笔记279 C++ （题目编号：1123）

1123. 最深叶节点的最近公共祖先 题目&#xff1a; 给你一个有根节点 root 的二叉树&#xff0c;返回它 最深的叶节点的最近公共祖先 。 回想一下&#xff1a; 叶节点 是二叉树中没有子节点的节点树的根节点的 深度 为 0&#xff0c;如果某一节点的深度为 d&#xff0c;那它…
阅读更多...
PyCharm中使用matplotlib.pyplot.show()报错MatplotlibDeprecationWarning的解决方案

PyCharm中使用matplotlib.pyplot.show()报错MatplotlibDeprecationWarning的解决方案

其实这只是一个警告&#xff0c;忽略也可。 一、控制台输出 MatplotlibDeprecationWarning: Support for FigureCanvases without a required_interactive_framework attribute was deprecated in Matplotlib 3.6 and will be removed two minor releases later. MatplotlibD…
阅读更多...
iOS 17中的Safari配置文件改变了游戏规则，那么如何设置呢

iOS 17中的Safari配置文件改变了游戏规则，那么如何设置呢

Safari在iOS 17中最大的升级是浏览配置文件——能够在一个应用程序中创建单独的选项卡和书签组。这些也可以跟随你的iPad和Mac&#xff0c;但在本指南中&#xff0c;我们将向你展示如何使用运行iOS 17的iPhone。 你可能有点困惑&#xff0c;为什么Safari中没有明显的位置可以添…
阅读更多...
Power BI的发布到web按钮怎么没有？有人知道怎么办吗？？？？？？

Power BI的发布到web按钮怎么没有？有人知道怎么办吗？？？？？？

Power BI的发布到web按钮怎么没有&#xff1f;有人知道怎么办吗&#xff1f;&#xff1f;&#xff1f;&#xff1f;&#xff1f; .
阅读更多...
使用Spring-data-jpa

使用Spring-data-jpa

EnableJpaAuditing 它是用来启动Jpa的审计功能。 jpa querydsl 多表的联合查询 导入依赖 querydsl-jpa 、querydsl-apt Repository接口, 继承QuerydslPredicateExecutor接口 NoRepositoryBean public interface BaseMongoRepository<T> extends MongoRepository<T…
阅读更多...
GptFuck—开源Gpt4分享

GptFuck—开源Gpt4分享

这个项目不错&#xff0c;分享给大家 项目地址传送门
阅读更多...
c语言 2.0

c语言 2.0

1.数据类型 数据类型介绍 数据类型&#xff1a;c语言中数据类型有3种&#xff0c;分别是基本数据类型、构造数据类型、指针数据类型。 数据类型的作用&#xff1a;编译器预算数据分配的内存空间大小。 ps&#xff1a;可以通俗理解为&#xff1a;数据类型是用来规范内存的开销…
阅读更多...
避坑之路 —— 前后端 json 的注意问题

避坑之路 —— 前后端 json 的注意问题

当我们在进行开发项目的时候&#xff0c;在前后端需要进行数据之间的传输&#xff0c;那么就会需要到json。而json算是字符串中的一种 1.先说一下前端的, 其实这两种都是表示前端希望能收到后端json这样的数据格式&#xff0c;那么我们在后端就需要注意将数据进行转换为json进…
阅读更多...
Python实现猎人猎物优化算法(HPO)优化卷积神经网络回归模型(CNN回归算法)项目实战

Python实现猎人猎物优化算法(HPO)优化卷积神经网络回归模型(CNN回归算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 猎人猎物优化搜索算法(Hunter–prey optimizer, HPO)是由Naruei& Keynia于2022年提出的一种最新的…
阅读更多...
人工智能的优势：使用 GPT 和扩散模型生成图像

人工智能的优势：使用 GPT 和扩散模型生成图像

推荐&#xff1a;使用 NSDT场景编辑器快速搭建3D应用场景 世界被人工智能 &#xff08;AI&#xff09; 所吸引&#xff0c;尤其是自然语言处理 &#xff08;NLP&#xff09; 和生成 AI 的最新进展&#xff0c;这是有充分理由的。这些突破性技术有可能提高各种任务的日常生产力。…
阅读更多...
借助各大模型的优点生成原创视频（真人人声）Plus

借助各大模型的优点生成原创视频（真人人声）Plus

【技术背景】 众所周知&#xff0c;组成视频的3大元素&#xff0c;即文本语音图片。接着小编逐一介绍生成原创视频的过程。 【文本生成】 天工AI搜索&#xff08;thttp://iangong.cn&#xff09; 直接手机短信验证就可以使用&#xff0c;该大模型已经接入互联网&#xff0c…
阅读更多...
实现CenterNet图像分割算法模型的转换和量化（SDK0301-转ONNX编译）

实现CenterNet图像分割算法模型的转换和量化（SDK0301-转ONNX编译）

一、实现CenterNet图像分割算法模型的转换和量化&#xff08;SDK0301-转ONNX编译&#xff09; 1、模型转换 &#xff08;1&#xff09;下载CenterNet算法移植代码&#xff1a; $ git clone https://github.com/sophon-ai-algo/examples.git # CenterNet示例项目代码位置 /ex…
阅读更多...
成集云 | 飞书审批同步金蝶云星空销售订单 | 解决方案

成集云 | 飞书审批同步金蝶云星空销售订单 | 解决方案

源系统成集云目标系统 方案介绍 飞书是字节跳动于2016年自研的新一代一站式协作平台&#xff0c;将即时沟通、日历、云文档、云盘和工作台深度整合&#xff0c;通过开放兼容的平台&#xff0c;让成员在一处即可实现高效的沟通和流畅的协作&#xff0c;全方位提升企业效率。 …
阅读更多...
【vue2第十五章】VueRouter 路由配置(VueRouter)与使用 和 router-link与router-view标签使用

【vue2第十五章】VueRouter 路由配置(VueRouter)与使用 和 router-link与router-view标签使用

单页面应用 与 多页面应用 单页面应用&#xff08;Single-Page Application&#xff0c;SPA&#xff09;和多页面应用&#xff08;Multi-Page Application&#xff0c;MPA&#xff09;是 Web 应用程序的两种不同架构方式。它们在页面加载和交互方式上有所区别。 单页面应用&a…
阅读更多...
【工作记录】基于spiderflow+ocr实现图片验证码识别@20230906

【工作记录】基于spiderflow+ocr实现图片验证码识别@20230906

声明: 本文引用的网站仅用于演示&#xff0c;如侵删。 背景 这两天收到运营同事一个关于需要登录的网站的数据爬取需求&#xff0c;登录同时需要填入图片验证码。 经过多次尝试&#xff0c;结合百度OCR可以完成图片验证码的获取和识别&#xff0c;特此记录。 希望能帮助到需要…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023