自己動手寫一個持久層框架-有解無憂

0. 前言 and Flag
1. JDBC問題分析
- 問題分析：
- 解決思路：
2. 自定義框架思路分析
- 使用端（專案）：
- 自定義持久層框架（工程）：
3. 創建表并撰寫測驗類
- 1. 創建一個Maven專案—— Ipersistence_test
- 2. 在resource中創建sqlMapConfig.xml 和 UserMapper.xml
4. 開始撰寫持久層框架
- 自定義持久層框架（工程）：
- 1. 加載組態檔
- 2. 創建JavaBean（容器物件）
- 3.決議xml檔案
- 4. 創建SqlSessionFacetory介面和實作類
- 5.創建SqlSession介面以及它的實作類
- 6.創建Executor介面及實作類SimpleExecutor實作類
- 7.結束
- 8.測驗類
- 最終的目錄結構：
5. 自定義持久層框架的優化
- 問題分析：
- 解決思路：
- 測驗：

0. 前言 and Flag

不得不說我又買課了，之前買課都花了大幾百了，但是這次又沒躲過去，買了拉鉤教育的【java高薪訓練營】，主要看到那個課程目錄有點牛逼，基本上把我聽說過的技術都包括了，不過真偽不太確定，之后就是知乎百度谷歌一頓搜索，沒查到什么負面資訊，B站也有一部分視頻，我看了幾節，不錯，加上拉鉤的背書，所以半信半疑的就報名了，

我這是第十期，11月5號開班的，課程的第一模塊是講mybatis，所以剛開始講了一個簡單的持久層框架該怎么寫（也就是下面我做的這些筆記），這一部分確實讓我茅塞頓開，例如框架是如可讀取組態檔的，為什么我們只需要呼叫dao層的介面就能夠執行sql、**Mapper.xml中為什么要有namespace，namespace和id為什么要與被呼叫方法所在類的全類名和方法名一致，一下子就通了，原來如此簡單~ 在使用mybatis的時候有一些不明所以的必要步驟也知道為什么如此了，

這才是任務一，這周還要完成兩個任務————mybatis使用方式回顧、原始碼分析，重頭戲馬上到來有點期待，

當一個技術人"知其所以然"了一個使用好久但"只知其然"的技術，然后脫口而出的“原來如此”時那種喜悅感！完全不亞于5殺逆風翻盤把？

最后立個Flag，今后每周都會把我在java高薪訓練營的學習筆記發表上來，風雨無阻！

1. JDBC問題分析

我們來看一段JDBC的代碼：

public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //1. 加載資料庫驅動
            Class.forName("com.mysql.jdbc.Drive");
            //2. 通過驅動管理類獲取資料庫鏈接
            connection = DriverManager.getConnection("jdbc:mysql://hocalhost:3306/mybatis?characterEncoding=utf-8",
                    "root","root");
            //3. 定義SQL陳述句 ？表示占位符
            String sql = "SELECT * FROM user WHERE username = ?";
            //4. 獲取預處理物件Statement
            preparedStatement = connection.prepareStatement(sql);
            //5. 設定引數，第一個引數為SQL陳述句中引數的序號（從1開始），第二個引數為設定的引數值
            preparedStatement.setString(1,"tom");
            //6. 向資料庫發出SQL執行查詢，查詢出結果集
            resultSet = preparedStatement.executeQuery();
            //7. 遍歷查詢結果集
            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 (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

可以看到，直接使用JDBC開發是存在一些問題的，我們來分析下：

問題分析：

資料庫配置資訊存在硬編碼問題
頻繁創建、釋放資料庫鏈接

//1. 加載資料庫驅動
Class.forName("com.mysql.jdbc.Drive");
//2. 通過驅動管理類獲取資料庫鏈接
connection = DriverManager.getConnection("jdbc:mysql://hocalhost:3306/mybatis?characterEncoding=utf-8","root","root");

sql陳述句、設定引數、獲取結果集均存在硬編碼問題

//3. 定義SQL陳述句 ？表示占位符
String sql = "SELECT * FROM user WHERE username = ?";
//4. 獲取預處理物件Statement
preparedStatement = connection.prepareStatement(sql);
//5. 設定引數，第一個引數為SQL陳述句中引數的序號（從1開始），第二個引數為設定的引數值
 preparedStatement.setString(1,"tom");
 //6. 向資料庫發出SQL執行查詢，查詢出結果集
 resultSet = preparedStatement.executeQuery();

      int id = resultSet.getInt("id");
      String userName = resultSet.getString("username");

手動封裝回傳結果集較為繁瑣

//7. 遍歷查詢結果集
while (resultSet.next()){
    int id = resultSet.getInt("id");
    String userName = resultSet.getString("username");
    //封裝User
    user.setId(id);
    user.setUserName(userName);
 }
 System.out.println(user);

解決思路：

寫在組態檔中
連接池（c3p0、dbcp、德魯伊...）
組態檔（和1放一起嗎？ No，經常變動和不經常變動的不要放在一起）
反射、內省

下面根據這個解決思路，自己動手寫一個持久層框架，寫框架之前分析這個框架需要做什么

2. 自定義框架思路分析

使用端（專案）：

引入自定義持久層框架的jar包
提供兩部分配置資訊：

資料庫配置資訊
SQL配置資訊(SQL陳述句)

使用組態檔來提供這些資訊：
1. sqlMapConfig.xml ：存放資料庫的配置資訊
2. mapper.xml ：存放SQL配置資訊

自定義持久層框架（工程）：

持久層框架的本質就是對JDBC代碼進行了封裝

加載組態檔：根據組態檔的路徑加載組態檔成位元組輸入流，存盤記憶體中
1. 創建Resources類方法：getResourceAsStream(String path)
Q： getResourceAsStearm方法需要執行兩次分別加載sqlMapConfig額和mapper嗎？

A：可以但沒必要，我們可以在sqlMapConfig.xml中寫入mapper.xml的全路徑即可
創建兩個javaBean：（容器物件）：存放的就是組態檔決議出來的內容
1. Configuration：核心配置類：存放sqlMapConfig.xml決議出來的內容
2. MappedStatement：映射配置類：存放mapper.xml決議出來的內容
決議組態檔：使用dom4j
1. 創建類：SqlSessionFactoryBuilder 方法：build(InputStream in) 這個流就是剛才存在記憶體中的
2. 使用dom4j決議組態檔，將決議出來的內容封裝到容器物件中
3. 創建SqlSessionFactory物件；生產sqlSession：會話物件（工廠模式 降低耦合，根據不同需求生產不同狀態的物件）
創建sqlSessionFactory介面及實作類DefaultSqlSessionFactory
1. openSession(); 生產sqlSession
創建SqlSession介面及實作類DefaultSession
1. 定義對資料庫的CRUD操作，例如：
  1. selectList()
  2. selectOne()
  3. update()
  4. delete()
  5. ...
創建Executor介面及實作類SimpleExecutor實作類
1. query(Configuration con,MappedStatement ms,Object ...param)；執行JDBC代碼,Object ...param具體的引數值，可變參；

3. 創建表并撰寫測驗類

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'lucy');
INSERT INTO `user` VALUES (2, 'tom');
INSERT INTO `user` VALUES (3, 'jack');

SET FOREIGN_KEY_CHECKS = 1;

1. 創建一個Maven專案—— Ipersistence_test

2. 在resource中創建sqlMapConfig.xml 和 UserMapper.xml

UserMapper.xml

<mapper namespace="user">
    <!--sql的唯一標識：namespace.id來組成 ：statementId-->
    <select id="selectList" resultType="com.dxh.pojo.User">
        select * from user
    </select>
    <select id="selectOne" resultType="com.dxh.pojo.User" paramterType="com.dxh.pojo.User">
        select * from user where id = #{id} and username = #{userName}
    </select>
</mapper>

Q:
為什么要有namespace和id ?
A:
當一個*Mapper.xml中有多條sql時，無法區分具體是哪一條所以增加 id
如果有UserMapper.xml和ProductMapper.xml，假設他們的查詢的id都為”selectList“，那么將無法區分具體是查詢user還是查詢product的，
所以增加 namespace
namespace.id 組成sql的唯一標識，也稱為statementId

sqlMapConfig.xml

<configuration>
    <!--資料庫配置資訊 -->
    <dataSource>
        <property name="driverClass" value="https://www.cnblogs.com/isdxh/p/com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="https://www.cnblogs.com/isdxh/p/jdbc:mysql:///zdy_mybatis"></property>
        <property name="username" value="https://www.cnblogs.com/isdxh/p/root"></property>
        <property name="password" value="https://www.cnblogs.com/isdxh/p/root"></property>
    </dataSource>
    <!--存放mapper.xml全路徑-->
    <mapper resource="UserMapper.xml"></mapper>
</configuration>

4. 開始撰寫持久層框架

自定義持久層框架（工程）：

本質就是對JDBC代碼進行了封裝

加載組態檔：根據組態檔的路徑加載組態檔成位元組輸入流，存盤記憶體中

創建Resources類方法：getResourceAsStream(String path)

創建兩個javaBean：（容器物件）：存放的就是組態檔決議出來的內容

Configuration：核心配置類：存放sqlMapConfig.xml決議出來的內容

MappedStatement：映射配置類：存放mapper.xml決議出來的內容

決議組態檔：使用dom4j

創建類：SqlSessionFactoryBuilder 方法：build(InputStream in) 這個流就是剛才存在記憶體中的

使用dom4j決議組態檔，將決議出來的內容封裝到容器物件中

創建SqlSessionFactory物件；生產sqlSession：會話物件（工廠模式 降低耦合，根據不同需求生產不同狀態的物件）

創建sqlSessionFactory介面及實作類DefaultSqlSessionFactory

openSession(); 生產sqlSession

創建SqlSession介面及實作類DefaultSession

定義對資料庫的CRUD操作

創建Executor介面及實作類SimpleExecutor實作類

query(Configuration con,MappedStatement ms,Object ...param)；執行JDBC代碼,Object ...param具體的引數值，可變參；

我們之前已經對持久層框架進行了分析，需要做6部分組成，如下：

1. 加載組態檔

我們要把用戶端的組態檔成位元組輸入流并存到記憶體中：

新建Resource類，提供一個static InputStream getResourceAsStream(String path)方法，并回傳inputstream

package com.dxh.io;
import java.io.InputStream;

public class Resource {
    //根據組態檔的路徑，將組態檔加載成位元組輸入流，存盤在記憶體中
    public static InputStream getResourceAsStream(String path){
        InputStream resourceAsStream = Resource.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }
}

2. 創建JavaBean（容器物件）

之前我們說到，要把決議出來的組態檔封裝成物件，

MappedStatement (存放SQL資訊)
Configuration （存放資料庫配置資訊）

// MappedStatement，我們存放SQL的資訊 
package com.dxh.pojo;
public class MappedStatement {
    // id標識
    private String id;
    //回傳值型別
    private String resultType;
    //引數值型別
    private String paramterType;
    //sql陳述句
    private String sql;
    
 	getset省略...
}

這里我們把封裝好的MappedStatement物件也放在Configuration中，同時我們不存放資料庫的url、username...了，直接存放DataSource

package com.dxh.pojo;

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

public class Configuration {
    private DataSource dataSource;
    /**
     * key statementId  (就是namespace.id)
     * value:封裝好的MappedStatement物件
     */
    Map<String,MappedStatement> mappedStatementMap = new HashMap<>();
	
    getset省略...
}

3.決議xml檔案

這一步我們決議兩個xml檔案sqlMapConfig.xml、mapper.xml

我們首先把決議的程序封裝起來：新建XMLConfigBuild.java

package com.dxh.config;

import com.dxh.io.Resource;
import com.dxh.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 XMLConfigBuild {
    private Configuration configuration;

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

    /**
     * 該方法就是將組態檔進行決議(dom4j)，封裝Configuration
     */
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
        Document document = new SAXReader().read(inputStream);
        //<configuration>
        Element rootElement = document.getRootElement();
        List<Element> list = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element element : list) {
            String name = element.attributeValue("name");
            String value = https://www.cnblogs.com/isdxh/p/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);

        //mapper.xml決議 ：拿到路徑--位元組輸入流---dom4j決議
        List<Element> mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            //拿到路徑
            String mapperPath = element.attributeValue("resource");
            //位元組輸入流
            InputStream resourceAsStream = Resource.getResourceAsStream(mapperPath);
            //dom4j決議
            //  因為決議完成后的MappedStatement要放在Configuration里，所以傳入一個configuration進去
            XMLMapperBuild xmlMapperBuild = new XMLMapperBuild(configuration);
            xmlMapperBuild.parse(resourceAsStream);
        }
        return configuration;
    }
}

3.1 決議Mapper.xml檔案：

package com.dxh.config;

import com.dxh.pojo.Configuration;
import com.dxh.pojo.MappedStatement;
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 XMLMapperBuild {
    private Configuration configuration;

    public XMLMapperBuild(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<Element> 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.setParamterType(paramterType);
            mappedStatement.setResultType(resultType);
            mappedStatement.setSql(sqlText);
            String key = namespace+"."+id;
            configuration.getMappedStatementMap().put(key,mappedStatement);
        }
    }
}

很容易理解，因為我們決議后要回傳Configuration物件，所以我們需要宣告一個Configuration 并初始化，

我們把加載檔案后的流傳入，通過dom4j決議，并通過ComboPooledDataSource（C3P0連接池）生成我們需要的DataSource，并存入Configuration物件中，

Mapper.xml決議方式同理，

3.2 創建SqlSessionFactoryBuilder類：
有了上述兩個決議方法后，我們創建一個類，用來呼叫這個方法，同時這個類回傳SqlSessionFacetory

SqlSessionFacetory：用來生產sqlSession：sqlSession就是會話物件（工廠模式 降低耦合，根據不同需求生產不同狀態的物件）

package com.dxh.sqlSession;

import com.dxh.config.XMLConfigBuild;
import com.dxh.pojo.Configuration;
import org.dom4j.DocumentException;

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

public class SqlSessionFacetoryBuild {
    public SqlSessionFacetory build(InputStream in) throws DocumentException, PropertyVetoException {
        //1. 使用dom4j決議組態檔，將決議出來的內容封裝到configuration中
        XMLConfigBuild xmlConfigBuild = new XMLConfigBuild();
        Configuration configuration = xmlConfigBuild.parseConfig(in);

        //2. 創建sqlSessionFactory物件 工廠類：生產sqlSession：會話物件，與資料庫互動的增刪改查都封裝在sqlSession中
        DefaultSqlSessionFactory sqlSessionFacetory = new DefaultSqlSessionFactory(configuration);
        return sqlSessionFacetory;
    }

}

4. 創建SqlSessionFacetory介面和實作類

基于開閉原則我們創建SqlSessionFacetory介面和實作類DefaultSqlSessionFactory

介面中我們定義openSession()方法，用于生產SqlSession

package com.dxh.sqlSession;

public interface SqlSessionFacetory {
    public SqlSession openSession();
}

package com.dxh.sqlSession;
import com.dxh.pojo.Configuration;

public class DefaultSqlSessionFactory implements SqlSessionFacetory{
    private Configuration configuration;

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

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

同樣我們在DefaultSqlSessionFactory中傳入Configuration，Configuration需要我們一直往下傳遞

5.創建SqlSession介面以及它的實作類

在介面中，我定義兩個方法：

因為引數型別和個數我們都不知道，所以我們使用泛型，同時，傳入statementId（namespace、. 、id 組成）

package com.dxh.sqlSession;
import java.util.List;

public interface SqlSession {
    //查詢多條
    public <E> List<E> selectList(String statementId,Object... params) throws Exception;
    //根據條件查詢單個
    public <T> T selectOne(String statementId,Object... params) throws Exception;
}

package com.dxh.sqlSession;
import com.dxh.pojo.Configuration;
import java.util.List;

public class DefaultSqlSession implements SqlSession {
    private Configuration configuration;

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

    @Override
    public <E> List<E> selectList(String statementId, Object... params) throws Exception {
        //將要完成對simpleExecutor里的query方法呼叫
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        List<Object> list = simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementId), 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("查詢結果為慷訓者回傳結果過多");
        }
    }
}

這里selectOne方法和selectList方法的引數結構都是一樣的，所以我們可以通過selectList.get(0)的方式得到一個回傳結果，而selectList中則是重點，我們需要創建一個物件SimpleExecutor并在其中執行SQL

6.創建Executor介面及實作類SimpleExecutor實作類

package com.dxh.sqlSession;

import com.dxh.pojo.Configuration;
import com.dxh.pojo.MappedStatement;

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

public interface Executor {
    /**
     *
     * @param configuration 資料庫配置資訊
     * @param mappedStatement SQL配置資訊
     * @param params 可變參
     * @return
     */
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, Exception;
}

package com.dxh.sqlSession;

import com.dxh.config.BoundSql;
import com.dxh.pojo.Configuration;
import com.dxh.pojo.MappedStatement;
import com.dxh.utils.GenericTokenParser;
import com.dxh.utils.ParameterMapping;
import com.dxh.utils.ParameterMappingTokenHandler;

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

/**
 * @author https://github.com/CoderXiaohui
 * @Description
 * @Date 2020-11-07 22:27
 */
public class SimpleExecutor implements Executor{
    /**
     *  就是在執行JDBC的代碼
     */
    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
        //1. 注冊驅動，獲取鏈接
        Connection connection = configuration.getDataSource().getConnection();
        //2. 獲取SQL陳述句
        //假設獲取的SQL是 : select * from user where id = #{id} and username = #{userName} JDBC是無法識別的，
        // 所以要轉換sql ： select * from user where id = ？ and username = ? ，轉換程序中還需要對#{}中的值進行決議存盤
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        //3. 獲取預處理物件：preparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
        //4. 設定引數
            //獲取到引數的全路徑
        String paramterType = mappedStatement.getParamterType();
        Class<?>  paramterTypeClass = getClassType(paramterType);
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            //反射
            Field declaredField = paramterTypeClass.getDeclaredField(content);
            //暴力訪問，防止它是私有的
            declaredField.setAccessible(true);
            Object o = declaredField.get(params[0]);
            //下標從1開始
            preparedStatement.setObject(i+1,o);
        }
        //5. 執行sql
        ResultSet resultSet = preparedStatement.executeQuery();
        String resultType = mappedStatement.getResultType();
        Class<?> resultTypeClass = getClassType(resultType);

        ArrayList<Object> objects = new ArrayList<>();
        //6. 封裝回傳結果集
        while (resultSet.next()){
            Object o = resultTypeClass.newInstance();
            //元資料
            ResultSetMetaData metaData = https://www.cnblogs.com/isdxh/p/resultSet.getMetaData();
            //metaData.getColumnCount() :查詢結果的總列數
            for (int i = 1; i <= metaData.getColumnCount(); i++) {
                //欄位名
                String columnName = metaData.getColumnName(i);
                //欄位的值
                Object value = resultSet.getObject(columnName);
                //使用反射或者內省，根據資料庫表和物體的對應關系，完成封裝
                //PropertyDescriptor 內省庫中的一個類，就是把resultTypeClass中的columnName屬性來生產讀寫方法
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
                Method writeMethod = propertyDescriptor.getWriteMethod();
                //把具體的值封裝到o這個物件中
                writeMethod.invoke(o,value);
            }
            objects.add(o);
        }
        return (List) objects;
    }

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

    /**
     * 完成對#{}決議作業：
     * 1. 將#{}使用?進行替換
     * 2. 決議出#{}里面的值進行存盤
     * @param sql
     * @return
     */
    private BoundSql getBoundSql(String sql) {
        //標記處理類：配置標記決議器來完成對占位符的處理作業
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        //回傳決議后的sql
        String parseSql = genericTokenParser.parse(sql);
        //#{}里面決議出來的引數名稱
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        BoundSql boundSql = new BoundSql(parseSql,parameterMappings);
        return boundSql;
    }
}

package com.dxh.config;
import com.dxh.utils.ParameterMapping;
import java.util.ArrayList;
import java.util.List;
/**
* 該方法的作用下面講解
*/
public class BoundSql {
    private String sqlText;//決議后的sql
    private List<ParameterMapping> parameterMappingList = new ArrayList<>();

    public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {
        this.sqlText = sqlText;
        this.parameterMappingList = parameterMappingList;
    }
}

這里的實作大致可分為6部分：

注冊驅動，獲取鏈接：通過傳入的configuration得到datasource，然后呼叫getConnection()得到鏈接
獲取SQL陳述句
我們mapper.xml的SQL陳述句是這樣的select * from user where id = #{id} and username = #{username},需要轉換為select * from user where id = ? and username =? 這樣JDBC才能認，同時我們需要把#{}中的引數賦值到?這個占位符處，
這里我們定義了一個getBoundSql方法，通過標記處理類（配置標記決議器來完成對占位符的處理作業）決議成帶有?的sql，同時把#{}里面的內容傳入ParameterMapping中，
通過connection.prepareStatement(boundSql.getSqlText())得到預處理物件
設定引數，我們在mapper.xml檔案中已經寫了paramterType，有了入參型別的全路徑我們可以通過反射獲取其物件，
根據ParameterMapping中存入的的#{}中的內容，通過反射獲取其值，然后與下標系結，
執行SQL
封裝回傳結果集這里使用內省
回傳(List<E>) objects

7.結束

此時我們框架中的代碼已經寫完了，

8.測驗類

package com.dxh.test;

import com.dxh.io.Resource;
import com.dxh.pojo.User;
import com.dxh.sqlSession.SqlSession;
import com.dxh.sqlSession.SqlSessionFacetory;
import com.dxh.sqlSession.SqlSessionFacetoryBuild;
import org.dom4j.DocumentException;
import org.junit.Test;

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

public class IPersistenceTest {

    @Test
    public void test() throws Exception {
        InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFacetory.openSession();
        User user = new User();
        user.setId(1);
        user.setUsername("lucy");

        User user2 = sqlSession.selectOne("user.selectOne",user);
        System.out.println(user2.toString());
//        List<User> userList = sqlSession.selectList("user.selectList");
//        for (User user1 : userList) {
//            System.out.println(user1);
//        }
    }
}

執行結果：

User{id=1, username='lucy'}

最終的目錄結構：

5. 自定義持久層框架的優化

我們的自定義持久層框架已經完成了，下面我們分析下這個框架，看看還有沒有明顯的弊端，

首先，我們先模仿正常的專案，創建一個Dao層

package com.dxh.dao;
import com.dxh.pojo.User;
import java.util.List;

public interface IUserDao {
    //查詢所有用戶
    public List<User> findAll() throws Exception;
    //根據條件進行查詢
    public User findByCondition(User user) throws Exception;
}

package com.dxh.dao;

import com.dxh.io.Resource;
import com.dxh.pojo.User;
import com.dxh.sqlSession.SqlSession;
import com.dxh.sqlSession.SqlSessionFacetory;
import com.dxh.sqlSession.SqlSessionFacetoryBuild;

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

public class IUserDaoImpl implements IUserDao {
    @Override
    public List<User> findAll() throws Exception {
        InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFacetory.openSession();
        List<User> userList = sqlSession.selectList("user.selectList");
        return userList;
    }

    @Override
    public User findByCondition(User user) throws Exception {
        InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFacetory.openSession();
        User user2 = sqlSession.selectOne("user.selectOne",user);
        return user2;
    }
}

問題分析：

很明顯存在代碼重復的問題，他們的前三句話都一樣(加載組態檔、創建SqlSessionFacetory、生產SqlSeesion)

 InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
 SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
 SqlSession sqlSession = sqlSessionFacetory.openSession();

statementId存在硬編碼問題

 List<User> userList = sqlSession.selectList("user.selectList");
 
 User user2 = sqlSession.selectOne("user.selectOne",user);

解決思路：

使用代理模式生成Dao層代理實作類，

在SqlSession介面中增加一個方法并實作：

//為Dao介面生產代理實作類
public <T> T getMapper(Class<?> mapperClass);

    @Override
    public <T> T getMapper(Class<?> mapperClass) {
        //使用JDK動態代理來為Dao介面生成代理物件，并回傳
        Object o = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });
        return (T) o;
    }

我們使用Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)方法來生產代理物件，一會我們再來實作invoke方法，

那么此時我們如果再想執行方法應該這樣做：

IUserDao iUserDao = sqlSession.getMapper(IUserDao.class);
List<User> all = iUserDao.findAll();

lll

通過sqlSession.getMapper()方法獲得代理物件
通過代理物件呼叫findAll()方法
執行invoke方法

我們來看看invoke方法：

Object proxy ：當前代理物件的參考
Method method ：當前被呼叫方法的引用
比如我們當前的代理物件iUserDao呼叫的是findAll()方法，而method就是findAll方法的參考
Object[] args ：傳遞的引數，比如我們想要根據條件查詢

撰寫invoke()方法：

我們要首先明確一點，不論如何封裝，底層都還是執行JDBC代碼，那么我們就要根據不同情況呼叫selectList或者selectOne，

此時就有一個疑問了：selectList和selectOne都需要一個引數——statementId，而此時我們是拿不到statementId的，

但是我們可以根據method物件得到方法名，和方法所在類的全類名，

因此我們需要規范下statementId的組成：

statementId = namespace.id = 方法所在類的全類名.方法名

修改UserMapper.xml

    @Override
    public <T> T getMapper(Class<?> mapperClass) {
        //使用JDK動態代理來為Dao介面生成代理物件，并回傳
        Object o = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(),
                new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //底層都還是執行JDBC代碼  //根據不同情況 呼叫selectList或者selectOne
                //準備引數： 1. statementId
                /**
                 * **此時就有一個疑問了：`selectList`和`selectOne`都需要一個引數——`statementId`，
                 * 而此時我們是拿不到`statementId`的，
                 * 但是我們可以根據`method`物件得到方法名，和方法所在類的全類名，
                 * 因此我們需要規范下statementId的組成：
                 * **statementId  =  namespace.id  =  方法所在類的全類名.方法名
                 */
                String methodName = method.getName();
                String className = method.getDeclaringClass().getName();
                String statementId = className+"."+methodName;
                //準備引數：2. args
                //獲取被呼叫方法的回傳值型別
                Type genericReturnType = method.getGenericReturnType();
                //判斷是否進行了泛型型別引數化 就是判斷當前的回傳值型別是否有泛型
                if (genericReturnType instanceof ParameterizedType){
                    List<Object> selectList = selectList(statementId, args);
                    return selectList;
                }
                return selectOne(statementId,args);
            }
        });
        return (T) o;
    }

測驗：

package com.dxh.test;

import com.dxh.dao.IUserDao;
import com.dxh.io.Resource;
import com.dxh.pojo.User;
import com.dxh.sqlSession.SqlSession;
import com.dxh.sqlSession.SqlSessionFacetory;
import com.dxh.sqlSession.SqlSessionFacetoryBuild;
import org.dom4j.DocumentException;
import org.junit.Test;

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

public class IPersistenceTest {

    @Test
    public void test() throws Exception {
        InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFacetory.openSession();
        IUserDao iUserDao = sqlSession.getMapper(IUserDao.class);
        List<User> all = iUserDao.findAll();
        System.out.println(all);
        //列印結果：[User{id=1, username='lucy'}, User{id=2, username='李四'}, User{id=3, username='null'}]
        User user1 = iUserDao.findByCondition(user);
        System.out.println(user1);
       //User{id=1, username='lucy'}
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/209832.html

標籤：Java

上一篇：C語言基礎知識：幾種特殊的函式宏封裝方式

下一篇：有符號數與無符號數