Mybatis学习之自定义持久层框架（三） 自定义持久层框架：读取并解析配置文件

前言

前两篇文章分别讲解了JDBC和Mybatis的基本知识，以及自定义持久层框架的设计思路，从这篇文章开始，我们正式来实现一个持久层框架。

新建一个项目

首先我们新建一个maven项目，将其命名为IPersistence，创建以下目录结构：

完成目录创建工作后，我们首先在pom.xml文件中引入相关依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hardy</groupId>
    <artifactId>IPersistence</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

</project>

下面，就可以开始正式的编码工作了。

读取配置文件

前面讲到了，第一步是要读取数据库配置的相关信息，以流的形式将其存放在内存中。那么首先我们就要在上图“io”包下创建一个Resources类，编写如下代码：

package com.hardy.io;

import java.io.InputStream;

public class Resources {

    // 根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
    public static InputStream getResourceAsStream(String path) {
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }
}

这个类的调用方法十分简单，直接传递配置文件的路径名作为参数即可。

解析配置文件

创建容器对象

上面读取完配置文件的信息后，仅仅是将其以输入流的形式存放在内存中，而我们在项目开发过程中，需要调用到这些配置信息中的很多不同属性，如果每次都从内存中读取数据流，是很不方便的。

这里我们将配置文件分为核心配置文件（提供存放数据库核心配置的信息）和映射配置文件（提供sql配置信息（包括sql语句、参数类型和返回类型））。因此，我们可以在“pojo”包下创建两个容器对象类，分别命名为Configuration（存放核心配置信息）和MappedStatement（存放映射配置信息），编写如下代码：

package com.hardy.pojo;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/*
    Configuration：
    核心配置类，存放数据库基本信息
    即sqlMapConfig.xml解析出来的内容
    */
public class Configuration {

    private DataSource dataSource;

    /*
        key: statementId value: 封装好的mappedStatement对象
        */
    Map<String, MappedStatement> mappedStatementMap = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map<String, MappedStatement> getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }

}

 

package com.hardy.pojo;

// Mapper.xml文件中一个select标签对应一个MappedStatement对象

/*
    映射配置类：
    存放sql语句、statement类型、输入参数java类型、输出参数java类型
    即Mapper.xml解析出来的内容
    */
public class MappedStatement {

    // id标识
    private String id;

    // sql语句
    private String sql;

    // 输入参数值类型
    private String parameterType;

    // 返回结果集类型
    private String resultType;

    public String getId() {
        return id;
    }

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

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public String getParameterType() {
        return parameterType;
    }

    public void setParameterType(String parameterType) {
        this.parameterType = parameterType;
    }

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }

}

创建配置文件解析类

上面创建了存放配置文件信息的两个容器对象，但配置文件信息不会自动存放到容器对象中，因此我们还需要编写两个配置文件信息的解析类，可以在“config”包下分别创建XMLConfigBuilder和XMLMapperBuilder，编写以下代码：

package com.hardy.config;

import com.hardy.io.Resources;
import com.hardy.pojo.Configuration;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.beans.PropertyVetoException;
import java.io.InputStream;
import java.util.List;
import java.util.Properties;

public class XMLConfigBuilder {

    private Configuration configuration;

    public XMLConfigBuilder(Configuration configuration) {
        this.configuration = new Configuration();
    }

    /*
    该方法就是使用dom4j对配置文件进行解析，封装成Configuration
    */
    public Configuration parseConfiguration(InputStream inputStream) throws DocumentException, PropertyVetoException, ClassNotFoundException {

        // 1、解析sqlMapConfig.xml
        /*
        * 这里需要注意一下：Document和Element等类用的都是org.dom4j库中的类，而不是javax.swing的
        * 若编译器自动导入了javax.swing，需要手动删除，否则会报错
        * */
        Document document = new SAXReader().read(inputStream);
        //<configuation>
        Element rootElement = document.getRootElement();
        List<Element> propertyElements =
                rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element propertyElement : propertyElements) {
            String name = propertyElement.attributeValue("name");
            String value = propertyElement.attributeValue("value");
            properties.setProperty(name,value);
        }
        // 连接池
        ComboPooledDataSource comboPooledDataSource = new
                ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
        comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        comboPooledDataSource.setUser(properties.getProperty("username"));
        comboPooledDataSource.setPassword(properties.getProperty("password"));

        // 填充configuration
        configuration.setDataSource(comboPooledDataSource);

        // 2、解析UserMapper.xml：拿到路径——获取字节输入流——使用dom4j进行解析
        List<Element> mapperElements = rootElement.selectNodes("//mapper");
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
        for (Element element : mapperElements) {
            String mapperPath = element.attributeValue("resource");
            InputStream resourceAsStream = Resources.getResourceAsStream(mapperPath);
            xmlMapperBuilder.parse(resourceAsStream);
        }

        return configuration;
    }
}

 

package com.hardy.config;

import com.hardy.pojo.Configuration;
import com.hardy.pojo.MappedStatement;
import com.hardy.pojo.SqlOperationEnum;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

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

public class XMLMapperBuilder {

    private Configuration configuration;

    public XMLMapperBuilder(Configuration configuration) {
        this.configuration = configuration;
    }

    // 解析mapper.xml文件
    public void parse(InputStream inputStream) throws DocumentException {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();

        String namespace = rootElement.attributeValue("namespace");

        List<Element> elementList = rootElement.elements();
        for (Element element : elementList) {
            // id的值
            String id = element.attributeValue("id");
            // 输入参数类型
            String parameterType = element.attributeValue("parameterType");
            // 返回结果集类型
            String resultType = element.attributeValue("resultType");
            // sql语句
            String sqlText = element.getTextTrim();

            // 封装mappedStatement
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setParameterType(parameterType);
            mappedStatement.setResultType(resultType);
            mappedStatement.setSql(sqlText);

            // 获取sql操作名，并将其转换为大写
            String elementName = element.getName();
            mappedStatement.setSqlOperationEnum(SqlOperationEnum.valueOf(elementName.toUpperCase()));

            // statementId
            String key = namespace + "." + id;

            //填充configuration
            configuration.getMappedStatementMap().put(key, mappedStatement);

        }
    }

}

总结

本篇文章中，我们创建了IPersistence项目，做了一些必要的准备工作，然后完成了读取数据库配置信息及解析数据库配置信息的编码工作。

到这里，我们就可以调用我们自定义的工具来读取和解析数据库配置信息了，下一篇文章会讲解如何调用这些工具。