自己動手寫一個持久層框架

IsDxh發表於2020-11-10

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="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///zdy_mybatis"></property>
        <property name="username" value="root"></property>
        <property name="password" value="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 = 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 = 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<E>) 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'}
    }
}

自己手寫一個SpringMVC框架(簡化)
2021-09-09
SpringMVC框架
自己動手實現一個EventBus框架
2018-04-24
框架
自己寫一個mvc框架吧（一）
2019-02-01
MVC框架
自己動手寫Android資料庫框架
2021-09-09
Android資料庫框架
閉關修煉180天--手寫持久層框架（mybatis簡易版）
2020-12-23
框架MyBatis
自己寫一個mvc框架吧（五）
2019-02-13
MVC框架
自己寫一個mvc框架吧（四）
2019-02-11
MVC框架
自己寫一個mvc框架吧（二）
2019-02-01
MVC框架
自己寫一個mvc框架吧（三）
2019-02-01
MVC框架
手寫一個自己的Promise
2018-07-29
Promise
淺析MyBatis（二）：手寫一個自己的MyBatis簡單框架
2021-03-16
MyBatis框架
自己動手寫個 Android客戶端
2018-04-26
Android客戶端
手寫自己的MyBatis框架-SqlSession
2020-12-14
MyBatis框架SQLSession
自己動手寫一個能操作redis的客戶端
2018-08-01
Redis客戶端
自己動手寫Promise
2018-08-24
Promise
自己動手寫basic直譯器一
2018-11-13
Java 持久層框架之 MyBatis
2020-12-22
Java框架MyBatis
仿照dubbo手寫一個RPC框架
2020-11-11
RPC框架
模仿vue自己動手寫響應式框架(三) - dom解析
2020-07-19
Vue框架
自己動手寫Impala UDF
2018-05-09
RxJava:自己動手擼一個RxBinding(一)。
2018-05-04
RxJava
河青的持久層框架hqbatis
2020-06-09
框架BAT
Java持久層框架Mybatis入門
2021-06-19
Java框架MyBatis
自己動手編寫一個Mybatis外掛：Mybatis脫敏外掛
2020-08-11
MyBatis
模仿vue自己動手寫響應式框架(二) - Vue物件建立
2020-07-16
Vue框架物件
自己動手實現一個前端路由
2018-11-18
前端路由
RxJava:自己動手擼一個RxBinding(二)。
2018-05-04
RxJava
自己寫一個Provider
2020-06-11
IDE
手動自己寫了一個波場（Tron）本地網頁版錢包
2023-04-15
網頁
MyBatis--優秀的持久層框架
2018-07-16
MyBatis框架
模仿vue自己動手寫響應式框架(四) - Vue物件構建
2020-07-22
Vue框架物件
react 知識梳理（二）：手寫一個自己的 redux
2018-05-24
ReactRedux
自己動手寫SQL執行引擎
2020-09-25
SQL
自己動手實現一個阻塞佇列
2021-04-21
佇列
Spring Boot 動手寫一個 Start
2019-03-08
Spring Boot
手寫一個 React 動畫元件
2022-12-15
React動畫元件
核心技術靠化緣是要不來的——自己動手寫ORM框架
2018-04-28
ORM框架
RxCache 整合 Android 的持久層框架 greenDAO、Room
2019-03-04
Android框架OOM

自己動手寫一個持久層框架

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. 自定義持久層框架的優化

問題分析：

解決思路：

測試：

相關文章