封面 ： 洛小汐
作者 ： 潘潘
自毕业以后，自己先创业后上班，浮沉了近 8 年，内心着实焦躁，虽一直是走科班路线，但在技术道路上却始终没静下心来研究、思考、梳理，机会来了，便抓牢。
希望自己记录下来的知识内容，对后来的学习之人，能有些许帮助。
对文章内容有任何建议或意见，或对互联网开发有希望交流学习，或单纯热爱生活，都欢迎随时微信我：panshenlian。
第一个系列的文章主要围绕「架构师（Java）技术条线」展开聊，不定时更新。
第一篇我以《手写一套持久层框架》先来打个样，本篇文章我们先不介绍 MyBatis，也不会分析源码，我们先聊一个 Java API：JDBC。
JDBC 是 Java 的老朋友，我们再一次认识他吧，挑挑他的毛病，站在 Java 资老朋友的角度，给他提点优化意见，并送他一套《自定义持久层框架》。
温馨提示：
如果大家在阅读过程中，对某些解决思路存在疑问，我建议大家先带着疑问阅读完，消化理解，因为导师们确实是通过研究 Mybatis 等持久层框架源码之后，反过来剖析的。
简单来说 “ 大厂都这么写，我们且这么跟随吧 ”。
Mybaits 系列全解 (持续更新)
Mybatis 系列全解（一）：手写一套持久层框架
Mybatis 系列全解（二）：Mybatis 简介与环境搭建
Mybatis 系列全解（三）：Mybatis 简单 CRUD 使用介绍
Mybatis 系列全解（四）：全网最全！Mybatis 配置文件 XML 全貌详解
Mybatis 系列全解（五）：全网最全！详解 Mybatis 的 Mapper 映射文件
Mybatis 系列全解（六）：Mybatis 最硬核的 API 你知道几个？
Mybatis 系列全解（七）：全息视角看 Dao 层两种实现方式之传统方式与代理方式
Mybatis 系列全解（八）：Mybatis 的动态 SQL
Mybatis 系列全解（九）：Mybatis 的复杂映射
Mybatis 系列全解（十）：Mybatis 注解开发
Mybatis 系列全解（十一）：Mybatis 缓存全解
Mybatis 系列全解（十二）：Mybatis 插件开发
Mybatis 系列全解（十三）：Mybatis 代码生成器
Mybatis 系列全解（十四）：Spring 集成 Mybatis
Mybatis 系列全解（十五）：SpringBoot 集成 Mybatis
Mybatis 系列全解（十六）：Mybatis 源码剖析
一、JDBC 是谁？
JDBC 是谁？干啥的？到底有多能打？看看网络上的朋友们怎么说。
Java 数据库连接，（Java Database Connectivity，简称 JDBC）是 Java 语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。
-- 来自百度百科
JDBC(Java DataBase Connectivity,java 数据库连接)是一种用于执行 SQL 语句的 Java API，可以为多种关系数据库提供统一访问，它由一组用 Java 语言编写的类和接口组成。JDBC 提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
-- 来自 360 百科
... 无法访问此网站
-- 来自维基百科
以上基本就是 JDBC 的大致介绍，官方且严谨的说辞，That's It ， 我们往下看看，它曾经的高光时刻。
自从 Java 语言于 1995 年 5 月正式公布以来，Java 风靡全球。出现大量的用 java 语言编写的程序，其中也包括数据库应用程序。由于没有一个 Java 语言的 API，编程人员不得不在 Java 程序中加入 C 语言的 ODBC 函数调用。这就使很多 Java 的优秀特性无法充分发挥，比如平台无关性、面向对象特性等。随着越来越多的编程人员对 Java 语言的日益喜爱，越来越多的公司在 Java 程序开发上投入的精力日益增加，对 java 语言接口的访问数据库的 API 的要求越来越强烈。也由于 ODBC 的有其不足之处，比如它并不容易使用，没有面向对象的特性等等，SUN 公司决定开发一 Java 语言为接口的数据库应用程序开发接口。在 JDK1.x 版本中，JDBC 只是一个可选部件，到了 JDK1.1 公布时，SQL 类包(也就是 JDBCAPI)就成为 Java 语言的标准部件。
后面从 JDBC1.0 到 JDBC4.0，一路发展。
-- 来自网络
结合介绍说明加深我们对 JDBC 的了解。
不过，我想知道他平时是如何工作的？一张图 《 JDBC 基本架构 》 了解一下：
有了 JDBC，向各种关系数据库发送 SQL 语句就是一件很容易的事。
换言之，有了 JDBC API，就不必为访问 Sybase 数据库专门写一个程序，为访问 Oracle 数据库又专门写一个程序，或为访问 Mysql 数据库又编写另一个程序等等，程序员只需用 JDBC API 写一个程序就够了，它可向相应数据库发送 SQL 调用。
同时，将 Java 语言和 JDBC 结合起来使程序员不必为不同的平台编写不同的应用程序，只须写一遍程序就可以让它在任何平台上运行，这也是 Java 语言"编写一次，处处运行"的优势。
我们再来看看他工作的细节。
毕竟，曾有人说过：想了解一个人，就得先仔细了解 Ta 的工作。
二、JDBC 如何工作？
JDBC API 允许应用程序访问任何形式的表格数据，特别是存储在关系数据库中的数据。
执行流程主要分三步：
连接数据源。
为数据库传递查询和更新指令。
处理数据库响应并返回的结果。
但实际上，每步流程都特别细节：
使用流程 （详细说明）
1.加载数据库驱动：
程序中使用 Class.forName('驱动')加载驱动，JVM 会寻找并加载指定驱动类，同时执行驱动类的静态代码段，在 JDK1.6 之前 JDBC 规范中明确要求各家在实现 Driver 类时必须在静态代码段中向 DriverManager 注册实例，JDK1.6 之后各家实现的 Driver 类则不再需要主动注册实例，因为 DriverManager 已经在初始化阶段对所有 jar 包中实现了 java.sql.Driver 的类进行扫描并进行初始化。
2. 创建数据库连接：
DriverManager 通过遍历所有已注册的驱动来尝试获取连接，第一个匹配上就会直接返回，并使用对应驱动建立起客户端与数据库服务器的网络连接（物理连接 Socket 了解一下）。
3. 创建编译对象：
数据库连接 connection 成功之后，我们会向数据库发送一次请求（statement），执行一条 sql 语句，一个连接可以执行多次 statement，除非你关闭连接，其中还有一个概念就是事务 transaction，事务和请求可以是一对一，也可以是一对多，这取决于你是想把多个请求 statement 作为同一个事务提交，还是一个请求提交一次事务，JDBC 默认是事务是自动提交，即 auto-commit 是打开的，所以默认是一对一。
4. 设置入参执行 SQL：
为了防止 SQL 注入，我们使用预处理在 sql 中使用?作为输入参数的占位符，sql 在编译后成为安全的 sql 语句再进行查询（有缘我们可以聊聊为何预处理机制能防止 SQL 注入）。
5. 封装返回结果集：
SQL 执行之后会把结果集封装到 ResultSet 类，ResultSet 类本身的迭代器初始行数的位置是 1，所以我们会发现与 java.util.Iterator 接口的迭代初始行数为 0 有差异，同时 ResultSet 类本身没有提供 hasNext 方法，所以我们会不断的 while(rs.next())往后定位，再通过不同的类型的访问器读取数据（例如 getString,getInteger 等）。
6. 释放数据库连接资源：
考虑到数据库连接占用了数据库服务器的内存资源，所以不可能无限制建立连接，用完就释放，养成好习惯，目前很多成熟的数据连接池技术，很好的优化管理的数据连接问题。
我们通过一段简单的例子来演示一下使用流程，本例子使用 JDBC 操作 mysql 数据库，先看看我们最终的项目结构与 JDBC API 在 JDK 中 rt.jar 的结构：
默认已具备 java 开发环境、mysql 数据库
创建 mave 工程，并且引入 mysql 驱动依赖
<dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.25</version> </dependency></dependencies>
复制代码
创建 java 测试类
package com.panshenlian.jdbc;
import com.panshenlian.po.User;
import java.sql.*;
/** * @Author: panshenlian * @Description: 演示通过JDBC连接mysql数据库 * @Date: Create in 20:11 2020/11/10 */public class Test01 {
public static void main(String[] args) { User user = new User(); Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { // 加载数据库驱动 Class.forName("com.mysql.jdbc.Driver"); // 通过驱动管理类获取数据库连接 connection = DriverManager.getConnection( "jdbc:mysql://localhost:3306/mybatis"+ "?characterEncoding=utf-8", "root","123456"); // 定义SQL语句 ？ 表示占位符 String sql = " select * from user where username = ? "; // 获取预处理statement对象 preparedStatement = connection.prepareStatement(sql); // 设置参数 // 第一个参数sql语句中参数的序号（从1开始） // 第二个参数为设置的参数值 preparedStatement.setString(1,"panshenlian"); // 向数据库发出sql执行查询，查询出结果集 resultSet = preparedStatement.executeQuery(); // 遍历查询结果集 while(resultSet.next()){ int id = resultSet.getInt("id"); String name = resultSet.getString("username"); // 封装User user.setId(id); user.setUserName(name); System.out.println(user); } } catch (Exception e) { e.printStackTrace(); } finally { // 释放资源 if(resultSet!=null){ try { resultSet.close(); } catch (SQLException e) { e.printStackTrace(); } } if(preparedStatement!=null){ try { preparedStatement.close(); } catch (SQLException e) { e.printStackTrace(); } } if(connection!=null){ try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } }}
复制代码
创建 User 类
package com.panshenlian.po;
/** * @Author: panshenlian * @Description: 用户实体 * @Date: Create in 20:10 2020/11/10 */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; }
@Override public String toString() { return "User{" + "id=" + id + ", userName='" + userName + '\'' + '}'; }}
复制代码
创建 sql 语句
-- ------------------------------ Table structure for user-- ----------------------------DROP TABLE IF EXISTS `user`;CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(50) DEFAULT NULL, `password` varchar(50) DEFAULT NULL, `birthday` varchar(50) DEFAULT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
-- ------------------------------ Records of user-- ----------------------------INSERT INTO `user` VALUES ('1', 'senly', '123', '2020-11-10');INSERT INTO `user` VALUES ('2', 'panshenlian', '123456', '2020-11-10');
复制代码
执行结果，nice , 成功。
User{id=2, userName='panshenlian'}
复制代码
看完这段演示，大家是否发现一个问题？就是整个 JDBC 操作数据库的使用过程繁琐而尴尬，就如这场对话：
额… JDBC 你确实挺烦的。
我懂你需要和数据库建立连接、执行 SQL 语句、处理查询结果集...
但是，这整个过程，能不能优化一下呢？
三、JDBC 存在哪些待优化的地方？
我们平时瘦身增肌，工作更得提质增效，来，我们剖开代码，逐个分析：
// 加载数据库驱动Class.forName("com.mysql.jdbc.Driver");// 通过驱动管理类获取数据库链接connection = DriverManager.getConnection( "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root","123456");
复制代码
优化思路：使用配置文件！
优化思路：使用数据连接池！
// 定义SQL语句 ？ 表示占位符 String sql = " select * from user where username = ? "; // 获取预处理statement对象 preparedStatement = connection.prepareStatement(sql); // 设置参数，第一个参数sql语句中参数的序号（从1开始），第二个参数为设置的参数值 preparedStatement.setString(1,"tom"); // 向数据库发出sql执行查询，查询出结果集 resultSet = preparedStatement.executeQuery();
复制代码
优化思路：使用配置文件！
// 遍历查询结果集while(resultSet.next()){ int id = resultSet.getInt("id"); String userName = resultSet.getString("username"); // 封装User user.setId(id); user.setUserName(userName); System.out.println(user);}
复制代码
优化思路：使用 Java 反射、自省！
针对 JDBC 各个环节中存在的不足，现在，我们整理出对应的优化思路，统一汇总：
假如让你来优化，你会根据这些优化思路如何设计一套持久层框架呢？
四、自定义持久层框架：思路
JDBC 是个人作战，凡事亲力亲为，低效而高险，自己加载驱动，自己建连接，自己 ...
而持久层框架好比是多工种协作，分工明确，执行高效，有专门负责解析注册驱动建立连接的，有专门管理数据连接池的，有专门执行 sql 语句的，有专门做预处理参数的，有专门装配结果集的 ...
框架的作用，就是为了帮助我们减去繁重开发细节与冗余代码，使我们能更加专注于业务应用开发。
复制代码
来，我们一起看看使用 JDBC 和使用持久层框架有什么区别？
使用框架对于我们使用者（主要是研发人员），是有多舒爽呢？
是不是发现，拥有这么一套持久层框架是如此舒适，我们仅仅需要干两件事：
- 配置数据源（地址/数据名/用户名/密码）
- 编写 SQL 与参数准备（SQL 语句/参数类型/返回值类型）
框架，除了思考本身的工程设计，还需要考虑到实际项目端的使用场景，干系方涉及两端：
以上两步，我们通过一张架构图《 手写持久层框架基本思路 》来梳理清楚：
正常来说项目只对应一套数据库环境，一般对应一个 SqlSessionFactory 实例对象，我们使用单例模式只创建一个 SqlSessionFactory 实例。
如果需要配置多套数据库环境，那需要做一些拓展，例如 Mybatis 中通过 environments 等配置就可以支持多套测试/生产数据库环境进行切换。
梳理完持久层框架的基本思路，明确了框架各角色分工，我们开始梳理详细方案：
A、项目使用端，调用框架 API，除了引入持久层框架的 jar 包之外，还需额外提供两部分配置信息：
1. sqlMapConfig.xml : 数据库配置信息（地址/数据名/用户名/密码），以及 mapper.xml 的全路径。
2. mapper.xml : SQL 配置信息，存放 SQL 语句、参数类型、返回值类型相关信息。
B、框架本身，实质上就是对 JDBC 代码进行封装，基本 6 步：
加载配置文件：根据配置文件的路径，加载配置文件成字节输入流，存储在内存中。
创建 Resource 类，提供加载流方法：InputStream getResourceAsStream(String path)
创建两个 javaBean（容器对象）：存放配置文件解析出来的内容
Configuration（核心配置类）：存放 sqlMapConfig.xml 解析出来的内容。
MappedStatement（映射配置类）：存放 mapper.xml 解析出来的内容。
解析配置文件（使用 dom4j） ，并创建 SqlSession 会话对象
创建类：SqlSessionFactoryBuilder 方法：build(InputStream in)
使用 dom4j 解析配置文件，将解析出来的内容封装到容器对象中
创建 SqlSessionFactory 对象，生产 sqlSession 会话对象（工厂模式）
创建 SqlSessionFactory 接口以及实现类 DefaultSqlSessionFactory
创建 openSession()接口方法，生产 sqlSession
创建 SqlSession 接口以及实现类 DefaultSqlSession
定义对数据库的 CRUD 操作：
selectList();
selectOne();
update();
delete();
创建 Executor 接口以及实现类 SimpleExecutor
创建 query(Configuration conf,MappedStatement ms,Object... params)
实际执行的就是 JDBC 代码。
基本过程我们已经清晰，我们再细化一下类图，更好的助于我们实际编码：
简约版
详细版
最终手写的持久层框架结构参考：
五、自定义持久层框架：编码
结合 UML 图和项目结构图，脑海里开始有点东西了，烧脑且枯燥的编码过程，我们开始吧。
框架依赖 pom.xml
<?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.panshenlian</groupId> <artifactId>MyPersistence</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>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.17</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.10</version> </dependency> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> <groupId>jaxen</groupId> <artifactId>jaxen</artifactId> <version>1.1.6</version> </dependency> </dependencies>
</project>
复制代码
config 包下 BoundSql 类
package com.panshenlian.config;
import com.panshenlian.utils.ParameterMapping;
import java.util.ArrayList;import java.util.List;
/** * @Author: panshenlian * @Description: SQL通配类 * @Date: Create in 16:12 2020/11/12 */public class BoundSql {
/** * 解析过的sql语句 */ private String sqlText;
private List<ParameterMapping> parameterMappingList = new ArrayList<ParameterMapping>();
public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) { this.sqlText = sqlText; this.parameterMappingList = parameterMappingList; }
public String getSqlText() { return sqlText; }
public void setSqlText(String sqlText) { this.sqlText = sqlText; }
public List<ParameterMapping> getParameterMappingList() { return parameterMappingList; }
public void setParameterMappingList(List<ParameterMapping> parameterMappingList) { this.parameterMappingList = parameterMappingList; }}
复制代码
config 包下 XMLConfigBuilder 类
package com.panshenlian.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;import com.panshenlian.io.Resource;import com.panshenlian.pojo.Configuration;import com.sun.javafx.scene.control.skin.EmbeddedTextContextMenuContent;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;import java.util.Properties;
/** * @Author: panshenlian * @Description: 数据库配置信息解析类 * @Date: Create in 13:56 2020/11/12 */public class XMLConfigBuilder {
private Configuration configuration;
public XMLConfigBuilder() { this.configuration = new Configuration(); }
public Configuration parseConfig(InputStream inputStream) throws Exception {
Document document = new SAXReader().read(inputStream); Element configurationRootElement = document.getRootElement();
// 解析数据源配置dataSource下的参数信息 List<Element> elementList = configurationRootElement.selectNodes("//property"); Properties properties = new Properties(); for (Element element : elementList){ String name = element.attributeValue("name"); String value = element.attributeValue("value"); properties.put(name,value); }
// 使用c3p0数据源 ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass(properties.getProperty("driverClass")); dataSource.setJdbcUrl(properties.getProperty("jdbcUrl")); dataSource.setUser(properties.getProperty("userName")); dataSource.setPassword(properties.getProperty("password"));
// 设置数据源 configuration.setDataSource(dataSource);
// 解析mapper.xml，根据路径读取字节输入流，使用dom4j进行解析 List<Element> mapperElementList = configurationRootElement.selectNodes("//mapper"); for (Element element : mapperElementList) { String mapperPath = element.attributeValue("resource"); InputStream resourceAsStream = Resource.getResourceAsStream(mapperPath); XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration); xmlMapperBuilder.parseMapper(resourceAsStream); }
return configuration; }}
复制代码
config 包下 XMLMapperBuilder 类
package com.panshenlian.config;
import com.panshenlian.pojo.Configuration;import com.panshenlian.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;
/** * @Author: panshenlian * @Description: SQL配置信息解析类 * @Date: Create in 14:28 2020/11/12 */public class XMLMapperBuilder {
private Configuration configuration;
public XMLMapperBuilder(Configuration configuration) { this.configuration = configuration; }
public void parseMapper(InputStream inputStream) throws DocumentException {
Document mapperDocument = new SAXReader().read(inputStream); Element rootElement = mapperDocument.getRootElement(); String namespace = rootElement.attributeValue("namespace");
// 解析每一个select节点 List<Element> selectNodes = mapperDocument.selectNodes("//select"); for (Element element : selectNodes) { String id = element.attributeValue("id"); String resultType = element.attributeValue("resultType"); String parameterType = element.attributeValue("parameterType"); String sql = element.getTextTrim();
// 解析封装进入MapperdStatement对象 MappedStatement mappedStatement = new MappedStatement(); mappedStatement.setId(id); mappedStatement.setResultType(resultType); mappedStatement.setParameterType(parameterType); mappedStatement.setSql(sql); String statementId = namespace + "." + id; configuration.getMappedStatementMap().put(statementId,mappedStatement); }
}}
复制代码
io 包下 Resource 工具类
package com.panshenlian.io;
import java.io.InputStream;
/** * @Author: panshenlian * @Description: 资源类 * @Date: Create in 9:22 2020/11/12 */public class Resource {
/** * 根据配置文件路径，将配置文件加载成字节输入流，存储在内存中 * @param path * @return */ public static InputStream getResourceAsStream(String path){ InputStream inputStream = Resource.class.getClassLoader().getResourceAsStream(path); return inputStream; }
}
复制代码
pojo 包下 Configuration
package com.panshenlian.pojo;
import javax.sql.DataSource;import java.util.HashMap;import java.util.Map;
/** * @Author: panshenlian * @Description: 数据库配置类 * @Date: Create in 13:58 2020/11/12 */public class Configuration {
private DataSource dataSource;
/** * key:statementId * value:封装好的mappedStatement对象 */ private Map<String,MappedStatement> mappedStatementMap = new HashMap<String, MappedStatement>();
public DataSource getDataSource() { return dataSource; }
public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; }
public Map<String, MappedStatement> getMappedStatementMap() { return mappedStatementMap; }
public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) { this.mappedStatementMap = mappedStatementMap; }}
复制代码
pojo 包下 MappedStatement
package com.panshenlian.pojo;
/** * @Author: panshenlian * @Description: SQL与结果集资源类 （负责存储SQL映射定义、存储结果集映射定义） * @Date: Create in 14:17 2020/11/12 */public class MappedStatement {
/** * id标识 */ private String id;
/** * 返回值类型 */ private String resultType;
/** * 参数值类型 */ private String parameterType;
/** * sql语句 */ private String sql;
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getResultType() { return resultType; }
public void setResultType(String resultType) { this.resultType = resultType; }
public String getParameterType() { return parameterType; }
public void setParameterType(String parameterType) { this.parameterType = parameterType; }
public String getSql() { return sql; }
public void setSql(String sql) { this.sql = sql; }}
复制代码
sqlSession 包下 DefaultSqlSession
package com.panshenlian.sqlSession;
import com.panshenlian.pojo.Configuration;import com.panshenlian.pojo.MappedStatement;
import java.lang.reflect.*;import java.util.List;
/** * @Author: panshenlian * @Description: sql会话实现类 * @Date: Create in 14:43 2020/11/12 */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 {
// 1、构建sql执行器 SimpleExecutor simpleExecutor = new SimpleExecutor();
// 2、获取最终执行sql对象 MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
// 3、执行sql，返回结果集 List<Object> queryResultList = simpleExecutor.query(configuration, mappedStatement, params); return (List<E>)queryResultList; }
@Override public <T> T selectOne(String statementId, Object... params) throws Exception { List<Object> objects = selectList(statementId, params); if (null != objects && objects.size() == 1){ return (T)objects.get(0); } else { throw new RuntimeException("查询结果为空或者返回结果多于1条"); } }
@Override public int update(String statementId, Object... params) { return 0; }
@Override public int delete(String statementId, Object... params) { return 0; }
@Override public <T> T getMapper(Class<?> mapperClass) {
//使用JDK动态代理来为Dao接口生成代理对象，并返回调用结果 Object proxyInstance = 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 = sql 语句的唯一标识： namespace.id =接口全限定名.方法名 String methodName = method.getName(); String className = method.getDeclaringClass().getName(); String statementId = className + "." + methodName;
// 2.准备参数 params 即args // 获取被调用方法的返回值类型 Type genericReturnType = method.getGenericReturnType(); // 判断是否进行了 泛型类型参数化 if ( genericReturnType instanceof ParameterizedType){ List<Object> objects = selectList(statementId, args); return objects; }
return selectOne(statementId,args); } }); return (T)proxyInstance;
}}
复制代码
sqlSession 包下 DefaultSqlSessionFactory
package com.panshenlian.sqlSession;
import com.panshenlian.pojo.Configuration;
/** * @Author: panshenlian * @Description: 默认SqlSession工厂实现类 * @Date: Create in 14:41 2020/11/12 */public class DefaultSqlSessionFactory implements SqlSessionFactory{
private Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) { this.configuration = configuration; }
@Override public SqlSession openSession() { return new DefaultSqlSession(configuration); }}
复制代码
sqlSession 包下 Executor
package com.panshenlian.sqlSession;
import com.panshenlian.pojo.Configuration;import com.panshenlian.pojo.MappedStatement;
import java.beans.IntrospectionException;import java.lang.reflect.InvocationTargetException;import java.sql.SQLException;import java.util.List;
/** * @Author: panshenlian * @Description: sql执行器接口 * @Date: Create in 15:02 2020/11/12 */public interface Executor {
public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception;
}
复制代码
sqlSession 包下 SimpleExecutor
package com.panshenlian.sqlSession;
import com.mysql.jdbc.StringUtils;import com.panshenlian.config.BoundSql;import com.panshenlian.pojo.Configuration;import com.panshenlian.pojo.MappedStatement;import com.panshenlian.utils.GenericTokenParser;import com.panshenlian.utils.ParameterMapping;import com.panshenlian.utils.ParameterMappingTokenHandler;
import java.beans.ExceptionListener;import java.beans.IntrospectionException;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.util.List;
/** * @Author: panshenlian * @Description: sql执行器接口简单实现类 * @Date: Create in 15:55 2020/11/12 */public class SimpleExecutor implements Executor {
@Override public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
// 1、注册驱动 , 获取数据库连接 Connection connection = configuration.getDataSource().getConnection();
// 2、获取sql语句： select * from user where id = #{id} // 转换sql语句： select * from user where id = ? // 转换的过程，还需要对#{}里面的值进行解析存储 String sql = mappedStatement.getSql(); BoundSql bounSql = getBoundSql(sql);
// 3、获取预处理对象: preparedStatement PreparedStatement preparedStatement = connection.prepareStatement(bounSql.getSqlText());
// 4、设置参数，通过反射机制获取到参数 String parameterType = mappedStatement.getParameterType(); Class<?> parameterTypeClass = getClassType(parameterType);
List<ParameterMapping> parameterMappingList = bounSql.getParameterMappingList(); for (int i = 0; i < parameterMappingList.size(); i++) { ParameterMapping parameterMapping = parameterMappingList.get(i); String filedName = parameterMapping.getContent();
// 反射 Field declaredField = parameterTypeClass.getDeclaredField(filedName); // 暴力访问 declaredField.setAccessible(true); Object declaredFieldValue = declaredField.get(params[0]); // params[0] 是对象 preparedStatement.setObject(i+1,declaredFieldValue); }
// 5、执行SQL ResultSet resultSet = preparedStatement.executeQuery(); String resultType = mappedStatement.getResultType(); Class<?> resultTypeClass = getClassType(resultType); List<Object> objects = new ArrayList<Object>();
// 6、封装返回结果集 while (resultSet.next()){ Object o = resultTypeClass.newInstance(); // 元数据 ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 1; i <= metaData.getColumnCount(); i++) { // 字段名 String columnName = metaData.getColumnName(i); // 字段值 Object columnValue = resultSet.getObject(columnName);
// 使用内省（反射），根据数据库表和实体的对应关系，完成封装 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass); Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(o,columnValue); } objects.add(o); } return (List<E>)objects; }
/** * 根据参数的全路径反射获取类 * @param parameterType * @return */ private Class<?> getClassType(String parameterType) throws ClassNotFoundException { if (StringUtils.isNullOrEmpty(parameterType)) { return null; } Class<?> clazz = Class.forName(parameterType); return clazz; }
/** * 完成对#{}的解析工作：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();
// 封装成为通配sql返回结果 BoundSql boundSql = new BoundSql(parseSql, parameterMappings); return boundSql; }}
复制代码
sqlSession 包下 SqlSession
package com.panshenlian.sqlSession;
import java.util.List;
/** * @Author: panshenlian * @Description: Sql会话接口 * @Date: Create in 14:40 2020/11/12 */public interface SqlSession {
/** * 查询所有 * @param statementId * @param params * @param <E> * @return */ public <E> List<E> selectList(String statementId , Object ... params) throws Exception;
/** * 根据条件查询单个 * @param statementId * @param params * @param <T> * @return */ public <T> T selectOne(String statementId , Object ... params) throws Exception;
/** * 根据条件更新 * @param statementId * @param params * @return */ public int update(String statementId , Object ... params);
/** * 根据条件删除 * @param statementId * @param params * @return */ public int delete(String statementId , Object ... params);
/** * 为Dao接口生成代理实现类 * @param mapperClass * @param <T> * @return */ public <T> T getMapper(Class<?> mapperClass);
}
复制代码
sqlSession 包下 SqlSessionFactory
package com.panshenlian.sqlSession;
/** * @Author: panshenlian * @Description: SqlSession工厂接口 * @Date: Create in 13:51 2020/11/12 */public interface SqlSessionFactory {
public SqlSession openSession();}
复制代码
sqlSession 包下 SqlSessionFactoryBuilder
package com.panshenlian.sqlSession;
import com.panshenlian.config.XMLConfigBuilder;import com.panshenlian.pojo.Configuration;
import java.io.InputStream;
/** * @Author: panshenlian * @Description: SqlSession会话工厂构建类 * @Date: Create in 13:48 2020/11/12 */public class SqlSessionFactoryBuilder {
public SqlSessionFactory build(InputStream inputStream) throws Exception {
// 第一步：用dom4j解析配置文件，将解析出来的内容封装到Configuration中 XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder(); Configuration configuration = xmlConfigBuilder.parseConfig(inputStream);
// 第二步：创建SqlSessionFactory对象，生产sqlSession会话对象（工厂模式） DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
return defaultSqlSessionFactory; }}
复制代码
utils 包下 GenericTokenParser
/** * Copyright 2009-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package com.panshenlian.utils;
/** * 通用标记解析器，标记#{与}开始结束处理 * @author Clinton Begin */public class GenericTokenParser {
private final String openToken; //开始标记 private final String closeToken; //结束标记 private final TokenHandler handler; //标记处理器
public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) { this.openToken = openToken; this.closeToken = closeToken; this.handler = handler; }
/** * 解析${}和#{} * @param text * @return * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。 * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现 */ public String parse(String text) { // 验证参数问题，如果是null，就返回空字符串。 if (text == null || text.isEmpty()) { return ""; }
// 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。 int start = text.indexOf(openToken, 0); if (start == -1) { return text; }
// 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder， // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码 char[] src = text.toCharArray(); int offset = 0; final StringBuilder builder = new StringBuilder(); StringBuilder expression = null; while (start > -1) { // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理 if (start > 0 && src[start - 1] == '\\') { builder.append(src, offset, start - offset - 1).append(openToken); offset = start + openToken.length(); } else { //重置expression变量，避免空指针或者老数据干扰。 if (expression == null) { expression = new StringBuilder(); } else { expression.setLength(0); } builder.append(src, offset, start - offset); offset = start + openToken.length(); int end = text.indexOf(closeToken, offset); while (end > -1) {////存在结束标记时 if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时 // this close token is escaped. remove the backslash and continue. expression.append(src, offset, end - offset - 1).append(closeToken); offset = end + closeToken.length(); end = text.indexOf(closeToken, offset); } else {//不存在转义字符，即需要作为参数进行处理 expression.append(src, offset, end - offset); offset = end + closeToken.length(); break; } } if (end == -1) { // close token was not found. builder.append(src, start, src.length - start); offset = src.length; } else { //首先根据参数的key（即expression）进行参数处理，返回?作为占位符 builder.append(handler.handleToken(expression.toString())); offset = end + closeToken.length(); } } start = text.indexOf(openToken, offset); } if (offset < src.length) { builder.append(src, offset, src.length - offset); } return builder.toString(); }}
复制代码
utils 包下 ParameterMapping
package com.panshenlian.utils;
/** * @Author: panshenlian * @Description: 参数映射类（SQL参数映射类，存储#{}、${}中的参数名） * @Date: Create in 16:14 2020/11/12 */public class ParameterMapping {
private String content;
public ParameterMapping(String content) { this.content = content; }
public String getContent() { return content; }
public void setContent(String content) { this.content = content; }}
复制代码
utils 包下 ParameterMappingTokenHandler
package com.panshenlian.utils;
import java.util.ArrayList;import java.util.List;
/** * 标记处理器实现类，解析#{}、${}成为? */public class ParameterMappingTokenHandler implements TokenHandler { private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
// context是参数名称 #{id} #{username}
public String handleToken(String content) { parameterMappings.add(buildParameterMapping(content)); return "?"; }
private ParameterMapping buildParameterMapping(String content) { ParameterMapping parameterMapping = new ParameterMapping(content); return parameterMapping; }
public List<ParameterMapping> getParameterMappings() { return parameterMappings; }
public void setParameterMappings(List<ParameterMapping> parameterMappings) { this.parameterMappings = parameterMappings; }
}
复制代码
utils 包下 TokenHandler
/** * Copyright 2009-2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package com.panshenlian.utils;
/** * 标记处理器接口 * @author Clinton Begin */public interface TokenHandler { String handleToken(String content);}
复制代码
框架书写好了，我们写一个测试工程验证一下框架，我们在现有框架下新加一个测试项目（以 module 模块的方式创建）保证测试工程和框架项目在一个工作组下面：
由于我已经写好了测试工程，我直接引入即可，效果都一样，创建和引入都以 module 方式就可以：
测试工程基本流程也说明一下：
1、引入依赖 pom.xml
<?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.panshenlian</groupId> <artifactId>MyPersistenceTest</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.panshenlian</groupId> <artifactId>MyPersistence</artifactId> <version>1.0-SNAPSHOT</version> </dependency> </dependencies>
</project>
复制代码
2、配置数据源 sqlMapConfig.xml
<configuration>
<!-- 数据库配置信息 --> <dataSource> <property name="driverClass" value="com.mysql.jdbc.Driver" ></property> <property name="jdbcUrl" value="jdbc:mysql:///mybatis" ></property> <property name="userName" value="root" ></property> <property name="password" value="123456" ></property> </dataSource>
<!-- 应用到的mapper.xml全路径 --> <mapper resource="userMapper.xml"></mapper> <mapper resource="orderMapper.xml"></mapper>
</configuration>
复制代码
3、我们以用户表为例子，建立用户 sql 配置 userMapper.xml
<mapper namespace="com.panshenlian.dao.IUserDao">
<!-- sql的唯一标识：namespace.id 来组成：statementId --> <select id="findAll" resultType="com.panshenlian.pojo.User"> select * from user </select>
<!-- User user = new User(); user.setId(1); user.setUsername("panshenlian"); --> <select id="findByCondition" resultType="com.panshenlian.pojo.User" parameterType="com.panshenlian.pojo.User"> select * from user where id= #{id} and username = #{username} and password= #{password} and birthday = #{birthday} </select>
</mapper>
复制代码
4、用户 dao 接口
package com.panshenlian.dao;
import com.panshenlian.pojo.User;
import java.util.List;
/** * @Author: panshenlian * @Description: * @Date: Create in 21:35 2020/11/12 */public interface IUserDao {
/** * 查询所有用户 * @return * @throws Exception */ public List<User> findAll() throws Exception;
/** * 根据条件进行用户查询 * @return * @throws Exception */ public User findByCondition(User user) throws Exception;
}
复制代码
5、用户 dao 的实体类
package com.panshenlian.pojo;
/** * @Author: panshenlian * @Description: 用户实体 * @Date: Create in 9:20 2020/11/12 */public class User {
private Integer id; private String username; private String password; private String birthday;
public String getPassword() { return password; }
public void setPassword(String password) { this.password = password; }
public String getBirthday() { return birthday; }
public void setBirthday(String birthday) { this.birthday = birthday; }
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; }
@Override public String toString() { return "User{" + "id=" + id + ", username='" + username + '\'' + ", password='" + password + '\'' + ", birthday='" + birthday + '\'' + '}'; }}
复制代码
注意：用户 sql 配置文件 userMapper.xml 中的 namespace 需要和用户 dao 的全限定名一致，这是我们框架默认规则：namespace="com.panshenlian.dao.IUserDao" 同时 select 标签的 id 和用户 dao 接口的方法名保持一致，也是框架默认的规则，例如 id="findAll"
6、最终我们创建测试类：MyPersistenceTest
package com.panshenlian.test;
import com.panshenlian.dao.IUserDao;import com.panshenlian.io.Resource;import com.panshenlian.pojo.User;import com.panshenlian.sqlSession.SqlSession;import com.panshenlian.sqlSession.SqlSessionFactory;import com.panshenlian.sqlSession.SqlSessionFactoryBuilder;import org.junit.Test;
import java.io.InputStream;import java.util.List;
/** * @Author: panshenlian * @Description: 持久层框架测试类 * @Date: Create in 9:24 2020/11/12 */public class MyPersistenceTest {
@Test public void test() throws Exception { InputStream resourceAsStream = Resource.getResourceAsStream("sqlMapConfig.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream); SqlSession sqlSession = sqlSessionFactory.openSession();
// 一、传统DAO方式调用 User user = new User(); user.setId(3); user.setUsername("panshenlian"); user.setBirthday("2020-11-12"); user.setPassword("123456"); User dbUser = sqlSession.selectOne("com.panshenlian.dao.IUserDao.findByCondition",user); System.out.println(dbUser); List<User> userList = sqlSession.selectList("com.panshenlian.dao.IUserDao.findAll", user); for (User db : userList) { System.out.println(db); }
// 二、代理模式调用 IUserDao userDao = sqlSession.getMapper(IUserDao.class); List<User> users = userDao.findAll(); for (User db : users) { System.out.println("代理调用=" + db); }
}}
复制代码
7、运行测试类，结果符合预期
框架和测试验证我们基本完成，其实以上主要是对于持久层框架的一个简单框架介绍，方面我们以后学习分析 Mybatis 框架，基本我们做到了一个模拟雏形，流程大致是这样。
编码实现过程中涉及到几个有意思的知识点，我们后续找时间聊聊，包括：
- 内省机制
- 反射机制
- JDK 动态代理
- 设计模式
- 泛型
总结
如今大型项目一般都不会直接使用 JDBC，要么采用市面上成熟的持久层方案，要么自研持久层框架，说到底，还是单纯的 JDBC 无法保证高效高稳定性能的数据层访问与应用，而越来越多持久层框架方案，不仅消除了大量的 JDBC 冗余代码，还提供极低的学习曲线，既能保证协同传统的数据库还接受 SQL 语句，也为其他框架提供了拓展集成支持，包括连接池、缓存、性能等都做了极大的优化与提升，所以框架大行其道是必然趋势。
JDBC 在 90 年代诞生之初也是高光而伟大，只不过随着技术水平的跃迁和业务场景的迭代更新，旧技术满足不了现有的诉求，所有事物都会轮换更新，我们仅仅是站在伟人的肩膀上，顺势变迁。
好，本篇完。下一篇，我们或许会聊聊 Mybatis 基础和架构 。
/ End.
BIU ~ 文章持续更新，微信搜索「潘潘和他的朋友们」第一时间阅读，随时有惊喜。本文会在 GitHub https://github.com/JavaWorld 收录，热腾腾的技术、框架、面经、解决方案，我们都会以最美的姿势第一时间送达，欢迎 Star。
评论