Mybatis学习之自定义持久层框架（六） 自定义持久层框架：完善CRUD方法并进行测试

前言

没想到会等到半年以后才来写这篇文章，我已经不记得当初自己想要在这篇文章中写什么了，还好有一些零散的笔记留着，就对照着上一篇文章及零散的笔记，把内容给补充完吧。

完善CRUD方法

完善DefaultSqlSession类实现查询单个及查询多个的接口

package com.hardy.sqlSession;

import com.hardy.pojo.Configuration;
import com.hardy.pojo.MappedStatement;
import java.sql.SQLException;
import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

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

    // 处理器对象
    private Executor simpleExcutor = new SimpleExecutor();

    @Override
    public <E> List<E> selectList(String statementId, Object... params) throws Exception {
        // 对SimpleExecutor里的query方法的调用
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);

        return (List<E>) list;
    }

    @Override
    public <T> T selectOne(String statementId, Object... params) throws Exception {
        List<Object> objects = selectList(statementId, params);
        if (objects.size() == 1) {
            return (T) objects.get(0);
        } else {
            throw new RuntimeException("查询结果过多或返回结果过多");
        }

    }

    public void close() throws SQLException {
        simpleExcutor.close();
    }

}

这里实现了单条记录查询即列表查询的方法。

编写User实体类

package com.hardy.pojo;

/*
* 实体类，对应数据库的user表
* */
public class User {

    private Integer id;

    private String username;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

创建Executor接口及SimpleExecutor实现类

package com.hardy.sqlSession;

import com.hardy.pojo.Configuration;
import com.hardy.pojo.MappedStatement;

import java.sql.SQLException;
import java.util.List;

public interface Executor {

    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception;

    void close() throws SQLException;

}

package com.hardy.sqlSession;

import com.hardy.pojo.Configuration;
import com.hardy.pojo.MappedStatement;
import com.hardy.utils.GenericTokenParser;
import com.hardy.utils.ParameterMapping;
import com.hardy.utils.ParameterMappingTokenHandler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.beans.IntrospectionException;
import java.util.List;

public class SimpleExecutor implements Executor {

    private Connection connection = null;

    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement,Object[] params) throws SQLException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, NoSuchFieldException, IntrospectionException, InvocationTargetException  {
        // 1、注册驱动，获取连接
        connection = configuration.getDataSource().getConnection();

        // 2、获取sql语句：select * from user where id = #{id} and username = #{username}（解析前）
        String sql = mappedStatement.getSql();

        // 3、对sql进行处理
        BoundSql boundSql = getBoundSql(sql);

        // 4、获取转换后的sql语句：// select * from where id = ? and username = ? （解析后）
        String finalSql = boundSql.getSqlText();

        // 5、获取预编译preparedStatement对象
        PreparedStatement preparedStatement = connection.prepareStatement(finalSql);

        // 6、设置参数，获取参数全路径
        String parameterType = mappedStatement.getParamterType();
        Class<?> paramterTypeClass = getClassType(parameterType);



        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();

        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String name = parameterMapping.getName();

            // 反射
            Field declaredField = paramterTypeClass.getDeclaredField(name);
            declaredField.setAccessible(true);

            // 参数的值
            Object o = declaredField.get(params[0]);

            // 给占位符赋值
            preparedStatement.setObject(i+1, o);
        }

        ResultSet resultSet = preparedStatement.executeQuery();
        String resultType = mappedStatement.getResultType();
        Class<?> resultTypeClass = getClassType(resultType);
        ArrayList<E> results = new ArrayList<E>();
        while (resultSet.next()) {
            ResultSetMetaData metaData = resultSet.getMetaData();
            E o = (E) resultTypeClass.newInstance();
            int columnCount = metaData.getColumnCount();
            for (int i = 1; i <= columnCount; i++) {
                // 字段名
                String columnName = metaData.getColumnName(i);

                // 字段值
                Object value = resultSet.getObject(columnName);

                // 创建字段描述器，为属性生成读写方法
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);

                // 获取写方法
                Method writeMethod = propertyDescriptor.getWriteMethod();

                // 向类中写入值
                writeMethod.invoke(o, value);
            }

            results.add(o);
        }

        return results;

    }

    private Class<?> getClassType(String parameterType) throws ClassNotFoundException {
        if (parameterType != null) {
            Class<?> aClass = Class.forName(parameterType);
            return aClass;
        }

        return null;
    }

    @Override
    public void close() throws SQLException {
        connection.close();
    }

    private BoundSql getBoundSql(String sql) {
        // 标记处理类：主要是配合通用标记解析器GenericTokenParser类完成对配置文件等的解析工作，其中TokenHandler主要完成对占位符的解析工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        // GenericTokenParser:通用的标记解析器，完成了代码片段中的占位符的解析，然后再根据给定的标记处理器（TokenHandler）来进行表达式的处理
        // GenericTokenParser类 构造函数三个参数分别为openToken（开始标记）、closeToken（结束标记）、handler（标记处理器）
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        String parse = genericTokenParser.parse(sql);

        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();

        BoundSql boundSql = new BoundSql(parse, parameterMappings);

        return boundSql;
    }

}

测试自定义持久层框架

新建一个IPersistence_test项目，在IPersistence_test项目的pom.xml文件中引入相关依赖（注意：这里需要引入自定义好的持久层框架IPersistence，因此需要先将IPersistence进行maven install 打包）：

<?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_test</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>com.hardy</groupId>
            <artifactId>IPersistence</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

编写测试类：

package com.hardy.test;

import com.hardy.io.Resources;
import com.hardy.pojo.User;
import com.hardy.sqlSession.SqlSession;
import com.hardy.sqlSession.SqlSessionFactory;
import com.hardy.sqlSession.SqlSessionFactoryBuilder;
import org.junit.Test;

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

public class IPersistenceTest {

    @Test
    public void test() throws Exception {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().builder(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        System.out.println("自定义持久层框架，GO！");
        // 调用
        User user = new User();
        user.setId(1);
        user.setUsername("hardy");
        User user2 = sqlSession.selectOne("User.selectOne", user);
        System.out.println("查询单条记录："+ user2);

        System.out.println("-----------------------------------------");

        List<User> users = sqlSession.selectList("User.selectList");
        System.out.println("查询多条记录：");
        for (User user1 : users) {
            System.out.println(user1);
        }

    }
}

执行测试类，结果如下所示：