手撸Spring06: 通过三种资源加载器读取配置文件

上回书说到, 我们每次要注册bean都是代码现场注册去插入,很不方便, 所以我们要开始搞从配置文件里面读出来自动注册,让用户一句话搞定.

BeanDefinitionReader

首先定义一个接口,因为可以有多种方式去读取配置文件

/**
 * 读取 bean定义的接口
 */
public interface BeanDefinitionReader {

    BeanDefinitionRegistry getRegistry();

    ResourceLoader getResourceLoader();

    void loadBeanDefinitions(Resource resource);

    void loadBeanDefinitions(Resource... resources);

    void loadBeanDefinitions(String location);
}

AbstractBeanDefinitionReader

一个抽象的实现类

/**
 * 抽象类实现加载和注册
 */
public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader{

    private final BeanDefinitionRegistry registry;

    private final ResourceLoader resourceLoader;

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

再搞一个类去实现抽象方法

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) {
        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) {
        for (Resource resource : resources) {
            loadBeanDefinitions(resource);
        }
    }

    @Override
    public void loadBeanDefinitions(String location) {
        ResourceLoader resourceLoader = getResourceLoader();
        Resource resource = resourceLoader.getResource(location);
        loadBeanDefinitions(resource);
    }

    /**
     * 从流中读取配置
     * @param inputStream
     */
    private 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);
            //读取属性并填充
            NodeList beanNodeList = bean.getChildNodes();
            for (int j = 0; j <beanNodeList.getLength(); j++) {
                if (!(beanNodeList.item(j) instanceof Element)) continue;
                //判断标签是否为属性
                if (!"property".equals(beanNodeList.item(j).getNodeName())) continue;

                Element property = (Element) beanNodeList.item(j);
                String attrName = property.getAttribute("name");
                String attrValue = property.getAttribute("value");
                String attrRef = property.getAttribute("ref");
                //获取属性值
                Object value=StrUtil.isNotEmpty(attrRef)?(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);

        }
    }
}

Resource

还有一个比较关键的是读取配置文件,也是先搞个抽象类

public interface Resource {
    InputStream getInputStream() throws IOException;
}

ClassPathResource

默认的从配置文件里读

public class ClassPathResource implements Resource {

    private final String path;

    private final ClassLoader classLoader;

    public ClassPathResource(String path) {
        this(path, null);
    }

    public ClassPathResource(String path, ClassLoader classLoader) {
        this.path = path;
        this.classLoader = classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader();
    }

    @Override
    //这一部分的实现是用于通过 ClassLoader 读取ClassPath 下的文件信息
    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;
    }
}

FileSystemResource

根据文件目录读

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.path = path;
        this.file=new File(path);
    }

    @Override
    //通过指定文件路径的方式读取文件信息
    public InputStream getInputStream() throws IOException {
        return new FileInputStream(file);
    }
}

UrlResource

public class UrlResource implements Resource {

    private final URL url;

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

    //通过 HTTP 的方式读取云服务的文件，我们也可以把配置文件放到 GitHub 或者 Gitee 上。
    @Override
    public InputStream getInputStream() throws IOException {
        URLConnection urlConnection = this.url.openConnection();
        return urlConnection.getInputStream();
    }
}

ResourceLoader

包装一下资源加载器, 根据传进来的地址判断使用哪种工具, 简化外部的使用

/**
 * 资源加载器
 */
public interface ResourceLoader {

    String CLASSPATH_URL_PREFIX ="classpath:";

    Resource getResource(String location);
}

DefaultResourceLoader

一般都会给一个默认的实现方式,

public class DefaultResourceLoader implements ResourceLoader{


    @Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        //如果地址是classPath开头
        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);
            }
        }
    }
}

测试

这样我们就可以读取配置去使用了

@Test
public void testClasspath() throws IOException {
    Resource resource = resourceLoader.getResource("classpath:important.properties");
    InputStream inputStream = resource.getInputStream();
    String s = IoUtil.readUtf8(inputStream);
    System.out.println(s);
}

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

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

@Test
public void testXml(){
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
    reader.loadBeanDefinitions("classpath:spring.xml");
    UserService userService = (UserService) beanFactory.getBean("userService", UserService.class);
    String s = userService.queryUserInfo();
    System.out.println("测试结果"+s);
}