三、持久层框架设计实现及MyBatis源码分析-自定义持久层框架（三）

在前一章节，我们对自定义持久层框架使用端的编写，这一章节我们接着来编写自定义持久层框架本身，在编写之前，我们先来对第一章节中分析出来编写自定义持久层框架的基本思路进行一个回顾：

自定义持久层框架的本质是对JDBC代码进行了封装，所以底层执行的还是JDBC代码，JDBC代码想要正常执行，两部分信息必不可少，一部分是数据库配置信息，还有一部分是SQL配置信息，面这两部份信息，已经被使用端使用两个配置文件进行了提供，所以自定义持久层框架需要做的事情就是使用dom4j来对使用端提供的两个配置文件进行解析，并将解析出来的信息封装到Configuration(核心配置类)和MappedStatement(映射配置类)这两个javaBean中，然后这两个javeBean可以作为参数，进行层层传递，传递到SimpleExecutor的query方法当中，而query在JDBC代码执行过程中，会取出Configuration和MappedStatement这两个配置文件所封装的信息进行使用

既然自定义框架，要使用dom4j对配置文件进行解析，那么持久层框架第一步要做的事情把使用端提供的两个配置文件进行加载，将它们加载成字节输入流程存储在内存当中，以便后期我们使用dom4j进行解析，那如何去加载配置文件呢，我们先创建一个Resources类，在这个类中编写一个InputStream getResourceAsStream（String path）方法，根据这个路径我们将两个配置文件加载出来存放到内存当中，同样我们新建一个工程来进行编写

一、解析配置文件

持久层框架中的pom.xml文件

    4.0.0

    study.lagou.com
    persistence
    1.0-SNAPSHOT

    
        UTF-8
        UTF-8
        1.8
        1.8
        1.8
    

Resources类

package study.lagou.com.io;

import java.io.InputStream;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 20:45
 */
public class Resources {

    //根据配置文件路径，将配置文件加载成字节输入流，存放到配置文件当中
    public static InputStream getResourceAsStream(String path){
        //借助类加载器，通过path对配置文件进行加载
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }
    
}

编写完成这个类，我们在使用端编写一个测试类，对该方法进行一下测试，因为在使用端调用持久层框架中的方法，所以我们需要先在使用端引入持久层框架中的jar包（注意先安装持久层框架的代码到本地），然后修改使用端使用端配置文件

打包持久层框架到本地maven仓库.png

使用端pom.xml文件中引入持久屋框架依赖

    4.0.0

    study.lagou.com
    persistence-test
    1.0-SNAPSHOT

    
        UTF-8
        UTF-8
        1.8
        1.8
        1.8
    

    
        
            study.lagou.com
            persistence
            1.0-SNAPSHOT
        
    

接着在使用端项目中编写测试类

package study.lagou.com.test;

import study.lagou.com.io.Resources;

import java.io.InputStream;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 21:19
 */
public class PersistenceTest {

    public void test(){
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    }
}

二、创建两个javaBean容器对象

接下来我们先来定义两个javaBean

Configuration核心配置类：主要用于存储数据库配置文件driverClass、jdbcUrl、username、password信息和mapper.xml的全路径，而数据库连接配置的4个信息，可以直接用javax.sql包中的DataSource类进行存储，mapper.xml文件的全路径我们通过Map的形式来存储，这个Map中key通过statementId来进行标识，在第一章节中分析的由mapper.xml的namespace.id组成，value是封装好的MappedStatement对象

MappedStatement映射配置文件类：主要用于存储mapper.xml配置文件中每一条SQL语句的id、resultType、paramterType、sql语句信息

以便后面的方法中解析出两个配置文件，并封装到这两个javaBean中

首先我们先来创建MappedStatement类

package study.lagou.com.pojo;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 21:58
 */
public class MappedStatement {
    /**
     * mapper.xml文件为SQL对应的id属性
     */
    private String id;
    /**
     * 返回值类型
     */
    private String resultType;
    /**
     * 参数类型
     */
    private String paramterType;
    /**
     * sql语句
     */
    private String sql;

    public String getId() {
        return id;
    }

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

    public String getResultType() {
        return resultType;
    }

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

    public String getParamterType() {
        return paramterType;
    }

    public void setParamterType(String paramterType) {
        this.paramterType = paramterType;
    }

    public String getSql() {
        return sql;
    }

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

再创建Configuration类

package study.lagou.com.pojo;

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

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 22:03
 */
public class Configuration {

    /**
     * 数据库连接配置信息
     */
    private DataSource dataSource;

    /**
     * key：通过statementId来进行标识，在第一章节中分析的由mapper.xml的namespace.id组成
     * value：封装好的MappedStatement对象
     */
    private Map mappedStatementMap = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

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

    public Map getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}

三、通过dom4j解析配置文件

1、解析sqlMapConfig.xml配置文件

(1)、由于解析配置文件，需要使用到dom4j，将数据库连接解析到数据库连接池并放到java.sql包的DataSource对象中，我们先在持久层框架中引入相应的依赖包

    4.0.0

    study.lagou.com
    persistence
    1.0-SNAPSHOT

    
        UTF-8
        UTF-8
        1.8
        1.8
        1.8
    

    
        
            mysql
            mysql-connector-java
            8.0.18
        

        
            c3p0
            c3p0
            0.9.1.2
        

        
            log4j
            log4j
            1.2.12
        

        
            junit
            junit
            4.10
        

        
            dom4j
            dom4j
            1.6.1
        

        
            jaxen
            jaxen
            1.1.6
        
    

（2）、创建SqlSessionFactoryBuilder对象

package study.lagou.com.sqlSession;

import study.lagou.com.config.XMLConfigBuilder;

import java.io.InputStream;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 22:49
 */
public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream inputStream){
        //1、解析配置文件，将配置文件封装到Configuration对象当中
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();


        //2、创建sqlSessionFactory
        return null;
    }
}

SqlSessionFactory接口

package study.lagou.com.sqlSession;

public interface SqlSessionFactory {
}

XMLConfigBuilder类

package study.lagou.com.config;

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

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

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 22:56
 */
public class XMLConfigBuilder {

    private Configuration configuration;

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

    /**
     * 该方法就是使用dom4j对配置文件进行解析，然后将配置文件信息封装到Configuration类中
     * @param inputStream
     * @return
     * @throws DocumentException
     */
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
        //通过dom4j包中的SAXReader类对读取出来字节输入流进行解析
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        //通过//这种表示方法，不论property属性在xml文件中的哪一些都可以直接读取到,通过rootElement.selectNodes方法
        //可以获取到对应配置文件中属性为property的所有Element
        List list = rootElement.selectNodes("//property");
        //这里我们定义一个Properties对象来存储配置文件中读取出来的元素，可以存储key和value的对象还可以是Map，但是我们
        //这里使用Properties来存储，因为后面创建数据库连接池会使用到
        Properties properties = new Properties();
        for (Element element : list) {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            properties.put(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对象中的DataSource属性
        configuration.setDataSource(comboPooledDataSource);

        //解析mapper.xml文件,首先获取到路径，然后通过路径将配置文件加载成字节输入流再用dom4j进行解析
        List mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            String mapperPath = element.attributeValue("resource");
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            InputStream resourceAsStream = Resources.getResourceAsStream(mapperPath);
            xmlMapperBuilder.parse(resourceAsStream);
        }

        return configuration;
    }
}

XMLMapperBuilder类

package study.lagou.com.config;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import study.lagou.com.pojo.Configuration;
import study.lagou.com.pojo.MappedStatement;

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

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 23:32
 */
public class XMLMapperBuilder {

    private Configuration configuration;

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

    public void parse(InputStream inputStream) throws DocumentException {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");

        List list = rootElement.selectNodes("//select");
        for (Element element : list) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String paramterType = element.attributeValue("paramterType");
            String sqlText = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParamterType(paramterType);
            mappedStatement.setSql(sqlText);
            String statementId = namespace+"."+id;
            configuration.getMappedStatementMap().put(statementId,mappedStatement);
        }
    }
}

四、创建SqlSessionFactory及SqlSessionFactory实现类，生产SqlSession

前面部分代码我们将解析sqlMapConfig.xml文本解析封装到Configuration对象的工作我处理完成，接下我们开始第二步操作，创建SqlSessionFactory及实现类DefaultSqlSessionFactory，生产SqlSession，在编写SqlSessionFactory接口的openSession方法之前，我们先定义一个空的SqlSession接口及SqlSession的实现类DefaultSqlSession，因为openSession方法需要返回一个SqlSession对象

SqlSession接口

package study.lagou.com.sqlSession;

public interface SqlSession {

}

SqlSession接口实现类

package study.lagou.com.sqlSession;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-2-22 21:24
 */
public class DefaultSqlSession implements SqlSession {
}

接着编写SqlSessionFactory接口的openSession方法
SqlSessionFactory接口

package study.lagou.com.sqlSession;
public interface SqlSessionFactory {
    SqlSession openSession();
}

再下一步编写SqlSessonFactory实现类，DefaultSqlSessionFactory

package study.lagou.com.sqlSession;

import study.lagou.com.pojo.Configuration;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-2-22 21:23
 */
public class DefaultSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

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

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession();
    }
}

SqlSessionFactory接口方法编写完成后，注意将SqlSessionFactoryBuilder类进行完善

package study.lagou.com.sqlSession;

import org.dom4j.DocumentException;
import study.lagou.com.config.XMLConfigBuilder;
import study.lagou.com.pojo.Configuration;

import java.beans.PropertyVetoException;
import java.io.InputStream;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-1-28 22:49
 */
public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {
        //1、解析配置文件，将配置文件封装到Configuration对象当中
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(inputStream);

        //2、创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new DefaultSessionFactory(configuration);
        return sqlSessionFactory;
    }
}

五、在SqlSession接口中定义对数据库的CRUD操作方法selectList、selectOne、update、delete

1、先在SqlSession接口中定义对应的方法

package study.lagou.com.sqlSession;

import java.util.List;

public interface SqlSession {

    /**
     * 查询列表信息
     * @param statementId
     * @param params
     * @param 
     * @return
     */
     List selectList(String statementId, Object... params);

    /**
     * 查询单个数据信息
     * @param statementId
     * @param params
     * @param 
     * @return
     */
     T selectOne(String statementId,Object... params);

    /**
     * 删除信息
     * @param statementId
     * @param params
     */
    void delete(String statementId,Object... params);

    /**
     * 更新数据信息
     * @param statementId
     * @param params
     */
    void update(String statementId,Object... params);
}

2、在对应的DefaultSqlSession中实现对应的方法，在DefaultSqlSession中可以直接通过JDBC代码进行数据操作，但是我们此处先不这么做，我们将操作JDBC的代码封装到下层级中进行处理，在Executor接口的实现类SimpleExecutor中进行处理

package study.lagou.com.sqlSession;

import java.util.List;

/**
 * @Description: 功能描述
 * @Author houjh
 * @Email: [email protected]
 * @Date: 2021-2-22 21:24
 */
public class DefaultSqlSession implements SqlSession {
    @Override
    public  List selectList(String statementId, Object... params) {
        return null;
    }

    @Override
    public  T selectOne(String statementId, Object... params) {
        //selectOne方法和selectList方法操作数据库的方式一致，所以我们此处直接调用selectList方法即可
        List