自定义持久层框架 -- Mybatis阉割版

一、分析JDBC操作问题

public class Test {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 通过驱动管理类获取数据库链接
            connection =
                    DriverManager.getConnection(
                            "jdbc:mysql://localhost:3306/mybatis? characterEncoding = utf - 8", " root", " root");
            // 定义sql语句？表示占位符
            String sql = "select * from user where username = ?";
            // 获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数，第⼀个参数为sql语句中参数的序号(从1开始)，第⼆个参数为设置的参数值
            preparedStatement.setString(1, "tom");
            // 向数据库发出sql执⾏查询，查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 遍历查询结果集
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                // 封装User
                user.setId(id);
                user.setUsername(username);
            }
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 数据库配置信息存在硬编码问题
  解决方案：利用配置文件
• 频繁创建释放数据库链接
  解决方案：连接池
• sql语句，设置参数，获取结果集参数 均存在硬编码问题
  解决方案：利用配置文件，但是由于这几项信息是频繁改动的内容，所以不应该和数据库配置信息放在同一份配置文件中，应该分开存放
• 手动封装返回结果集，较为繁琐
  解决方案：反射、内省

二、自定义框架设计思路分析

• 使用端（项目）
  1. 引入自定义持久层框架的jar包
  2. 提供两部分配置信息
     • sqlMapConfig.xml : 存放数据源信息
     • Mapper.xml : sql 语句的配置文件信息
• 自定义持久层框架本身（工程）
  1. 加载配置文件
     根据配置文件的路劲，加载配置文件成字节输入流，存入内存中
     创建 Resources 类，方法：InputSteam getResourceAsSteam(String path)
  2. 创建两个javaBean（容器对象）
     存放对配置文件解析出来的内容
     Configuration（核心配置类） : 存放 sqlMapConfig.xml 解析出来的内容
     MappedStatement（映射配置类）：存放 Mapper.xml 解析出来的内容
  3. 使用dom4j解析配置文件
     创建 sqlSessionFactoryBuilder 类，方法：build(InputSteam in)
     创建 SqlSessionFactory 对象，生产 SqlSession
  4. 创建 SqlSessionFactory 接口及实现类 DefaultSqlSessionFactory
     方法：openSession生产SqlSession
  5. 创建SqlSession接口及实现类DefaultSession
     定义对数据库的CRUD操作
  6. 创建Executor接口及实现类SimpleExecutor
     方法：query(Configuration c, MappedStatement m, Object...params)执行JDBC代码

三、使用端代码编写

sqlMapConfig.xml 定义数据源信息

UserMapper.xml 定义 sql 信息
SQL唯一标识（StatementId）由 namespace.id 来组成
例如：com.wujun.dao.IUserDao.findAll

    
        select * from user
    

    
        select * from user where id = #{id} and username = #{username}
    

四、自定义持久层框架代码编写

1. 创建 Resources 类，加载配置文件

package com.wujun.io;

import java.io.InputStream;

public class Resources {

    // 借助类加载器，将指定路劲的配置文件加载成字节输入流，存储在内存中
    public static InputStream getResourceAsSteam(String path) {
       return Resources.class.getClassLoader().getResourceAsStream(path);
    }
}

2. 创建两个 javaBean（容器对象）用来存放配置文件解析出来的信息

/**
 * 存放解析出来的数据源对象 以及 封装 MappedStatement
 * 以便于后续作为参数层层传递，最后进行JDBC操作
 */
@Data
public class Configuration {

    private DataSource dataSource;

    /**
     * key:StatementId（由 namespace.id 组成）
     */
    private Map mappedStatementMap = new HashMap<>();
}

/**
 * 针对SQL语句配置文件解析之后，用来存放的对象
 * 通俗的来说，有几个select标签，就会生成几个MappedStatement对象
 */
@Data
public class MappedStatement {

    /**
     * id标识
     */
    private String id;

    /**
     * 返回值类型
     */
    private String resultType;

    /**
     * 参数值类型
     */
    private String parameterType;

    /**
     * SQL语句
     */
    private String sql;
}

3. 使用 dom4j 解析配置文件

/**
 * XML解析
 */
public class XMLConfigBuilder {

    private Configuration configuration;

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

    /**
     * 使用dom4j对配置文件进行解析，封装成 Configuration 对象
     */
    public Configuration parseConfig(InputStream in) throws DocumentException, PropertyVetoException {
        Document document = new SAXReader().read(in);

        // 拿到配置文件的根对象 
        Element rootElement = document.getRootElement();
        // 查找所有的 property 标签
        List elementList = rootElement.selectNodes("//property");
        // 遍历 elementList
        Properties properties = new Properties();
        for (Element element : elementList) {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            properties.setProperty(name, value);
        }
        // 使用c3p0数据库连接池存放数据源信息
        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.setDataSource(comboPooledDataSource);

        // 解析sql配置文件信息，存入 configuration 中
        List mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            String mapperPath = element.attributeValue("resource");
            InputStream mapperResource = Resources.getResourceAsSteam(mapperPath);
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(mapperResource);
        }

        return configuration;
    }
}

/**
 * Mapper XML解析
 */
public class XMLMapperBuilder {

    private Configuration configuration;

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

    /**
     * 使用dom4j对 mapper.xml 配置文件进行解析，放入 Configuration 对象
     */
    public void parse(InputStream in) throws DocumentException, PropertyVetoException {
        Document document = new SAXReader().read(in);

        // 拿到配置文件的根对象 
        Element rootElement = document.getRootElement();
        // 获取 namespace
        String namespace = rootElement.attributeValue("namespace");
        // 查找所有的 select 标签
        List elementList = rootElement.selectNodes("//select");
        // 遍历 elementList
        for (Element element : elementList) {
            String selectId = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String parameterType = element.attributeValue("parameterType");
            String sql = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(selectId);
            mappedStatement.setParameterType(parameterType);
            mappedStatement.setResultType(resultType);
            mappedStatement.setSql(sql);
            configuration.getMappedStatementMap().put(namespace + "." + selectId, mappedStatement);
        }
    }
}

4. 创建SqlSession

public class SqlSessionFactoryBuild {

    /**
     * 解析配置文件，创建 SqlSession
     */
    public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {
        // 1、使用dom4j解析配置文件，将解析出来的内容封装到 Configuration 中
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        // 2、创建SqlFactory对象
        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return defaultSqlSessionFactory;

    }
}

5. 定义对数据库的CRUD操作

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

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

    @Override
    public  List selectList(String statementId, Object... params) throws Exception {
        SimpleExecutor simpleExecutor = new SimpleExecutor(configuration);
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        List