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

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. 資料庫配置資訊存在硬編碼問題
  2. 頻繁建立、釋放資料庫連結
//1. 載入資料庫驅動
Class.forName("com.mysql.jdbc.Drive");
//2. 通過驅動管理類獲取資料庫連結
connection = DriverManager.getConnection("jdbc:mysql://hocalhost:3306/mybatis?characterEncoding=utf-8","root","root");
  1. 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");
  1. 手動封裝返回結果集 較為繁瑣
//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);

解決思路:

  1. 寫在配置檔案中
  2. 連線池(c3p0、dbcp、德魯伊...)
  3. 配置檔案 (和1放一起嗎? No,經常變動和不經常變動的不要放在一起)
  4. 反射、內省

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


2. 自定義框架思路分析

使用端(專案):

  1. 引入自定義持久層框架的jar包

  2. 提供兩部分配置資訊:

  • 資料庫配置資訊
  • SQL配置資訊(SQL語句)
  1. 使用配置檔案來提供這些資訊:
    1. sqlMapConfig.xml :存放資料庫的配置資訊
    2. mapper.xml :存放SQL配置資訊

自定義持久層框架(工程):

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

  1. 載入配置檔案:根據配置檔案的路徑載入配置檔案成位元組輸入流,儲存記憶體中

    1. 建立Resources類 方法:getResourceAsStream(String path)

    Q: getResourceAsStearm方法需要執行兩次分別載入sqlMapConfig額和mapper嗎?

    A:可以但沒必要,我們可以在sqlMapConfig.xml中寫入mapper.xml的全路徑即可

  2. 建立兩個javaBean:(容器物件):存放的就是配置檔案解析出來的內容

    1. Configuration:核心配置類:存放sqlMapConfig.xml解析出來的內容
    2. MappedStatement:對映配置類:存放mapper.xml解析出來的內容
  3. 解析配置檔案:使用dom4j

    1. 建立類:SqlSessionFactoryBuilder 方法:build(InputStream in) 這個流就是剛才存在記憶體中的
    2. 使用dom4j解析配置檔案,將解析出來的內容封裝到容器物件中
    3. 建立SqlSessionFactory物件;生產sqlSession:會話物件(工廠模式 降低耦合,根據不同需求生產不同狀態的物件)
  4. 建立sqlSessionFactory介面及實現類DefaultSqlSessionFactory

    1. openSession(); 生產sqlSession
  5. 建立SqlSession介面及實現類DefaultSession

    1. 定義對資料庫的CRUD操作,例如:
      1. selectList()
      2. selectOne()
      3. update()
      4. delete()
      5. ...
  6. 建立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.xmlProductMapper.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程式碼進行了封裝

  1. 載入配置檔案:根據配置檔案的路徑載入配置檔案成位元組輸入流,儲存記憶體中

    1. 建立Resources類 方法:getResourceAsStream(String path)
  2. 建立兩個javaBean:(容器物件):存放的就是配置檔案解析出來的內容

    1. Configuration:核心配置類:存放sqlMapConfig.xml解析出來的內容
    2. MappedStatement:對映配置類:存放mapper.xml解析出來的內容
  3. 解析配置檔案:使用dom4j

    1. 建立類:SqlSessionFactoryBuilder 方法:build(InputStream in) 這個流就是剛才存在記憶體中的
    2. 使用dom4j解析配置檔案,將解析出來的內容封裝到容器物件中
    3. 建立SqlSessionFactory物件;生產sqlSession:會話物件(工廠模式 降低耦合,根據不同需求生產不同狀態的物件)
  4. 建立sqlSessionFactory介面及實現類DefaultSqlSessionFactory

    1. openSession(); 生產sqlSession
  5. 建立SqlSession介面及實現類DefaultSession

    1. 定義對資料庫的CRUD操作
  6. 建立Executor介面及實現類SimpleExecutor實現類

    1. 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.xmlmapper.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部分:

  1. 註冊驅動,獲取連結:通過傳入的configuration得到datasource,然後呼叫getConnection()得到連結
  2. 獲取SQL語句
    我們mapper.xml的SQL語句是這樣的select * from user where id = #{id} and username = #{username},需要轉換為select * from user where id = ? and username =? 這樣JDBC才能認。同時我們需要把#{}中的引數賦值到?這個佔位符處。
    這裡我們定義了一個getBoundSql方法,通過標記處理類(配置標記解析器來完成對佔位符的處理工作)解析成帶有?的sql,同時把#{}裡面的內容傳入ParameterMapping中。
  3. 通過connection.prepareStatement(boundSql.getSqlText())得到預處理物件
  4. 設定引數,我們在mapper.xml檔案中已經寫了paramterType,有了入參型別的全路徑我們可以通過反射獲取其物件。
    根據ParameterMapping中存入的的#{}中的內容,通過反射獲取其值,然後與下標繫結。
  5. 執行SQL
  6. 封裝返回結果集 這裡使用內省
  7. 返回(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'}

最終的目錄結構:

image-20201108015103475

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;
    }
}

問題分析:

  1. 很明視訊記憶體在程式碼重複的問題,他們的前三句話都一樣(載入配置檔案、建立SqlSessionFacetory、生產SqlSeesion)

     InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml");
     SqlSessionFacetory sqlSessionFacetory = new SqlSessionFacetoryBuild().build(resourceAsStream);
     SqlSession sqlSession = sqlSessionFacetory.openSession();
    
  2. 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

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

我們來看看invoke方法:

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

編寫invoke()方法:

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

此時就有一個疑問了:selectListselectOne都需要一個引數——statementId,而此時我們是拿不到statementId的。

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

因此我們需要規範下statementId的組成:

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

修改UserMapper.xml

image-20201108144050013

    @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'}
    }
}

相關文章