源码分析（6）---纯手写MyBatis注解版本框架
MyBatis相关理论介绍
-
接口层和数据库交互的方式：
Mybatis和数据库交互的方式有两种：（1）使用传统的MyBatis提供的API（2）使用Mapper接口 -
使用Mapper接口实现访问数据库：
- MyBatis将配置文件中的每一个< mapper>节点抽象为一个Mapper接口：这个接口中声明的方法和< mapper>节点中的< select|update|delete|insert> 节点的id值为Mapper接口中的方法名称，parameterType为Mapper对应方法的入参类型，而resultMap值则对应了Mapper接口表示的返回值类型或者返回结果的元素类型。
- 根据MyBatis的配置规范配置好之后 ，通过SqlSession.getMapper（XXXXMapper.class）方法，MyBatis会根据相应的接口声明的方法信息，通过动态代理机制生成一个Mapper实例，我们使用Mapper接口的某一个方法的时候，MyBatis会根据这个方法的方法名和参数类型，确定Statement ID，底层还是通过SqlSession.select/update(“statementId”, parameterObject);等操作实现对数据库的操作。
- Mybatis引用Mapper接口这种调用方式，纯粹是为了满足面向接口编程的需要，而且我们的sql可以利用注解@Select等直接写在接口的方法上。实现脱离XML配置。
1. 数据处理层
- 数据处理层可以说是Mybatis的核心，从大的方面上讲，他要完成 两个功能：
（1）通过传入参数构建动态的sql语句
（2）sql语句的执行以及封装查询结果集成List< E>
2. 框架支撑层
2.1 事务管理机制
- 事务管理机制对于ORM框架而言是不可缺少的一部分，事务管理机制的质量也是考量一个ORM框架是否优秀的一个标准。
2.2 连接池管理机制
- 由于创建一个数据库连接所占用的资源比较大，对于数据吞吐量大和访问量非常大的应用而言，连接池的设计就很重要。
2.3 sql语句的配置方式
- 传统的MyBatis配置SQL语句方式就是使用XML文件进行配置，但是这种方式不能很好的支持面向接口编程的理念，为了支持面向接口的编程，Mybatis引入了Mapper接口的概念，面向接口的引入，对使用注解来配置sql语句成为可能，用户只需要在接口上添加必要的注解即可，不用再去配置XML文件了。但是，目前的MyBatis只是对注解配置的SQL语句提供简单的支持，某些高级功能还是要依赖xml配置文件配置sql。
3. 引导层
- 引导层是配置和启动MyBatis配置信息的方式。MyBatis提供了两种方式来引导MyBatis：基于XML配置文件的方式和基于JavaAPI的方式。
主要构件以及相互关系
- 从MyBatis的代码实现的角度来看，MyBatis的主要的核心有以下几个部分：
- sqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库的增删改查的操作。
- Executor：MyBatis的执行器，是MyBatis调度的核心，负责SQL语句的生成和查询缓存的维护。
- StatementHandler：封装了JDBC Statement操作，负责对JDBC statement的操作，如设置参数，将Statement结果集转换成List集合
- ParameterHandler：负责对用户传递的参数转换成JDBC Statement所需要的参数
- ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
- TypeHandler：负责java数据类型和jdbc数据类型之间的映射和转换
- MappedStatement：MappedStatement维护了一条< select|update|delete|insert>节点的封装
- SqlSource：负责根据用户传递parameterObject，动态生成sql语句，将信息封装到BoundSql中，并返回
- BoundSql：表示动态生成的SQL语句以及相应的参数信息
- Configuration：MyBatis所有的配置信息都维护在Configuration对象之中
- 接口无法被实例化，反射或者new都不能进行创建。
- 我们的mapper也是接口，为什么可以今次那个初始化。原因是我们使用了动态代理
自定义实现MyBatis
- MyBatis中的占位符是#{}，要想让JDBC执行，必须将其改为？，因为jdbc中的占位符是？。
- 手写MyBatis的难点在于：
（1）Mapper接口方法需要和sql语句进行绑定，但是接口如何被实例化，进行接口方法的调用呢？
- Mapper接口既然不能进行实例化，我们提供以下思路：
（1）使用字节码技术创建虚拟子类
（2）使用匿名内部类
（3）使用动态代理创建代理对象（我们用的就是这种方法。）
-
@ExtInsert（自定义@insert注解）实现思路
（1）判断方法上是否存在@ExtInsert注解
（2）若存在，获取该注解属性，即定义的sql语句
（3）获取方法的参数和SQL参数进行匹配
----- (3.1) 定义一个Map集合，key是@ExtParam的value值，value是对应的形参
（4）替换参数为？，因为JDBC中识别的占位符是？
（5）调用JDBC执行sql -
@ExtSelect（自定义@select注解）实现思路：与@ExtInsert类似。不同的是执行完sql之后，我们需要使用反射机制实例对象，获取方法的返回类型，进行实例化，因为MyBatis查询的结果返回的是一个List.
-
获取返回值思路：
（1）使用反射机制获取方法的返回值类型
（2）判断是否有结果集，如果有，进行初始化
（3）使用反射机制，给对象赋值 -
代码实现：
（1）整体架构：
（2）pom文件
<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.0modelVersion>
<groupId>com.xiyougroupId>
<artifactId>my-mybatisartifactId>
<version>1.0-SNAPSHOTversion>
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.5version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<version>3.0.6.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>3.0.6.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aopartifactId>
<version>3.0.6.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-ormartifactId>
<version>3.0.6.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjrtartifactId>
<version>1.6.1version>
dependency>
<dependency>
<groupId>aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.5.3version>
dependency>
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>2.1_2version>
dependency>
<dependency>
<groupId>com.mchangegroupId>
<artifactId>c3p0artifactId>
<version>0.9.5.2version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.37version>
dependency>
<dependency>
<groupId>asmgroupId>
<artifactId>asmartifactId>
<version>3.3.1version>
dependency>
dependencies>
project>
（3）工具类，JDBC工具类负责连接数据库，SQL工具类负责拆分注解中的sql，提取参数，改变占位符等
- SQLUtils:
package com.xiyou.utils;
import java.util.ArrayList;
import java.util.List;
/**
* SQL拼接
* 作者: 每特教育-余胜军
* 联系方式:QQ644064779|WWW.itmayiedu.com
*/
public class SQLUtils {
/**
*
* 获取Insert语句后面values 参数信息
* 作者: 每特教育-余胜军
* 联系方式:QQ644064779|WWW.itmayiedu.com
*
* @param sql
* @return
*/
public static String[] sqlInsertParameter(String sql) {
int startIndex = sql.indexOf("values");
int endIndex = sql.length();
String substring = sql.substring(startIndex + 6, endIndex).replace("(", "").replace(")", "").replace("#{", "")
.replace("}", "");
String[] split = substring.split(",");
return split;
}
/**
*
* 获取select 后面where语句 作者: 每特教育-余胜军
* 联系方式:QQ644064779|WWW.itmayiedu.com
*
* @param sql
* @return
*/
public static List<String> sqlSelectParameter(String sql) {
int startIndex = sql.indexOf("where");
int endIndex = sql.length();
String substring = sql.substring(startIndex + 5, endIndex);
String[] split = substring.split("and");
List<String> listArr = new ArrayList<>();
for (String string : split) {
String[] sp2 = string.split("=");
listArr.add(sp2[0].trim());
}
return listArr;
}
/**
* 将SQL语句的参数替换变为?
* 作者: 每特教育-余胜军
* 联系方式:QQ644064779|WWW.itmayiedu.com
*
* @param sql
* @param parameterName
* @return
*/
public static String parameQuestion(String sql, String[] parameterName) {
for (int i = 0; i < parameterName.length; i++) {
String string = parameterName[i];
sql = sql.replace("#{" + string + "}", "?");
}
return sql;
}
public static String parameQuestion(String sql, List<String> parameterName) {
for (int i = 0; i < parameterName.size(); i++) {
String string = parameterName.get(i);
sql = sql.replace("#{" + string + "}", "?");
}
return sql;
}
public static void main(String[] args) {
// String[] sqlParameter = sqlInsertParameter(sql);
// for (String string : sqlParameter) {
// System.out.println(string);
// }
}
}
- JDBCUtils
package com.xiyou.utils;
import java.sql.*;
import java.util.List;
public final class JDBCUtils {
private static String connect;
private static String driverClassName;
private static String URL;
private static String username;
private static String password;
private static boolean autoCommit;
/** 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象 */
private static Connection conn;
static {
config();
}
/**
* 开头配置自己的数据库信息
*/
private static void config() {
/*
* 获取驱动
*/
driverClassName = "com.mysql.jdbc.Driver";
/*
* 获取URL
*/
URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
/*
* 获取用户名
*/
username = "root";
/*
* 获取密码
*/
password = "05131004";
/*
* 设置是否自动提交，一般为false不用改
*/
autoCommit = false;
}
/**
* 载入数据库驱动类
*/
private static boolean load() {
try {
Class.forName(driverClassName);
return true;
} catch (ClassNotFoundException e) {
System.out.println("驱动类 " + driverClassName + " 加载失败");
}
return false;
}
/**
* 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
*/
private static boolean invalid() {
if (conn != null) {
try {
if (conn.isClosed() || !conn.isValid(3)) {
return true;
/*
* isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
*/
}
} catch (SQLException e) {
e.printStackTrace();
}
/*
* conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
*/
return false;
} else {
return true;
}
}
/**
* 建立数据库连接
*/
public static Connection connect() {
if (invalid()) { /* invalid为true时，说明连接是失败的 */
/* 加载驱动 */
load();
try {
/* 建立连接 */
conn = DriverManager.getConnection(URL, username, password);
} catch (SQLException e) {
System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
}
}
return conn;
}
/**
* 设置是否自动提交事务
**/
public static void transaction() {
try {
conn.setAutoCommit(autoCommit);
} catch (SQLException e) {
System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
}
}
/**
* 创建 Statement 对象
*/
public static Statement statement() {
Statement st = null;
connect();
/* 如果连接是无效的就重新连接 */
transaction();
/* 设置事务的提交方式 */
try {
st = conn.createStatement();
} catch (SQLException e) {
System.out.println("创建 Statement 对象失败: " + e.getMessage());
}
return st;
}
/**
* 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
*
* @param SQL
* 带参数占位符的SQL语句
* @return 返回相应的 PreparedStatement 对象
*/
private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {
PreparedStatement ps = null;
connect();
/* 如果连接是无效的就重新连接 */
transaction();
/* 设置事务的提交方式 */
try {
if (autoGeneratedKeys) {
ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
} else {
ps = conn.prepareStatement(SQL);
}
} catch (SQLException e) {
System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
}
return ps;
}
public static ResultSet query(String SQL, List<Object> params) {
if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
throw new RuntimeException("你的SQL语句为空或不是查询语句");
}
ResultSet rs = null;
if (params.size() > 0) {
/* 说明 有参数 传入，就需要处理参数 */
PreparedStatement ps = prepare(SQL, false);
try {
for (int i = 0; i < params.size(); i++) {
ps.setObject(i + 1, params.get(i));
}
rs = ps.executeQuery();
} catch (SQLException e) {
System.out.println("执行SQL失败: " + e.getMessage());
}
} else {
/* 说明没有传入任何参数 */
Statement st = statement();
try {
rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
} catch (SQLException e) {
System.out.println("执行SQL失败: " + e.getMessage());
}
}
return rs;
}
private static Object typeof(Object o) {
Object r = o;
if (o instanceof java.sql.Timestamp) {
return r;
}
// 将 java.util.Date 转成 java.sql.Date
if (o instanceof java.util.Date) {
java.util.Date d = (java.util.Date) o;
r = new java.sql.Date(d.getTime());
return r;
}
// 将 Character 或 char 变成 String
if (o instanceof Character || o.getClass() == char.class) {
r = String.valueOf(o);
return r;
}
return r;
}
public static boolean execute(String SQL, Object... params) {
if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
throw new RuntimeException("你的SQL语句为空或有错");
}
boolean r = false;
/* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */
/* 获得 被执行的 SQL 语句的 前缀 */
SQL = SQL.trim();
SQL = SQL.toLowerCase();
String prefix = SQL.substring(0, SQL.indexOf(" "));
String operation = ""; // 用来保存操作类型的 变量
// 根据前缀 确定操作
switch (prefix) {
case "create":
operation = "create table";
break;
case "alter":
operation = "update table";
break;
case "drop":
operation = "drop table";
break;
case "truncate":
operation = "truncate table";
break;
case "insert":
operation = "insert :";
break;
case "update":
operation = "update :";
break;
case "delete":
operation = "delete :";
break;
}
if (params.length > 0) { // 说明有参数
PreparedStatement ps = prepare(SQL, false);
Connection c = null;
try {
c = ps.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
try {
for (int i = 0; i < params.length; i++) {
Object p = params[i];
p = typeof(p);
ps.setObject(i + 1, p);
}
ps.executeUpdate();
commit(c);
r = true;
} catch (SQLException e) {
System.out.println(operation + " 失败: " + e.getMessage());
rollback(c);
}
} else { // 说明没有参数
Statement st = statement();
Connection c = null;
try {
c = st.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
// 执行 DDL 或 DML 语句，并返回执行结果
try {
st.executeUpdate(SQL);
commit(c); // 提交事务
r = true;
} catch (SQLException e) {
System.out.println(operation + " 失败: " + e.getMessage());
rollback(c); // 回滚事务
}
}
return r;
}
/*
*
* @param SQL 需要执行的 INSERT 语句
*
* @param autoGeneratedKeys 指示是否需要返回由数据库产生的键
*
* @param params 将要执行的SQL语句中包含的参数占位符的 参数值
*
* @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys
* 为 false 则返回受当前SQL影响的记录数目
*/
public static int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) {
int var = -1;
if (SQL == null || SQL.trim().isEmpty()) {
throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
}
// 如果不是 insert 开头开头的语句
if (!SQL.trim().toLowerCase().startsWith("insert")) {
System.out.println(SQL.toLowerCase());
throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
}
// 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
SQL = SQL.trim();
SQL = SQL.toLowerCase();
if (params.size() > 0) { // 说明有参数
PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
Connection c = null;
try {
c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
} catch (SQLException e) {
e.printStackTrace();
}
try {
for (int i = 0; i < params.size(); i++) {
Object p = params.get(i);
p = typeof(p);
ps.setObject(i + 1, p);
}
int count = ps.executeUpdate();
if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
var = rs.getInt(1); // 获得值并赋值给 var 变量
}
} else {
var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
}
commit(c);
} catch (SQLException e) {
System.out.println("数据保存失败: " + e.getMessage());
rollback(c);
}
} else { // 说明没有参数
Statement st = statement();
Connection c = null;
try {
c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
} catch (SQLException e) {
e.printStackTrace();
}
// 执行 DDL 或 DML 语句，并返回执行结果
try {
int count = st.executeUpdate(SQL);
if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
var = rs.getInt(1); // 获得值并赋值给 var 变量
}
} else {
var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
}
commit(c); // 提交事务
} catch (SQLException e) {
System.out.println("数据保存失败: " + e.getMessage());
rollback(c); // 回滚事务
}
}
return var;
}
/** 提交事务 */
private static void commit(Connection c) {
if (c != null && !autoCommit) {
try {
c.commit();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/** 回滚事务 */
private static void rollback(Connection c) {
if (c != null && !autoCommit) {
try {
c.rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 释放资源
**/
public static void release(Object cloaseable) {
if (cloaseable != null) {
if (cloaseable instanceof ResultSet) {
ResultSet rs = (ResultSet) cloaseable;
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (cloaseable instanceof Statement) {
Statement st = (Statement) cloaseable;
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (cloaseable instanceof Connection) {
Connection c = (Connection) cloaseable;
try {
c.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
（4）自定义三个注解
- ExInsert，作用@Insert
package com.xiyou.annotation;
import java.lang.annotation.*;
/**
* 自定义注解@insert
* @Author
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
// 表示只能写在方法上
@Target(ElementType.METHOD)
public @interface ExInsert {
String value();
}
- ExSelect，作用是@Select
package com.xiyou.annotation;
import java.lang.annotation.*;
/**
* 自定义注解@Select
* @author zyf
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
// 写在方法上
@Target(ElementType.METHOD)
public @interface ExSelect {
String value();
}
- ExParam，作用是@Param
package com.xiyou.annotation;
import java.lang.annotation.*;
/**
* 自定义注解@Param
* @Author
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
// 写在参数上
@Target(ElementType.PARAMETER)
public @interface ExParam {
String value();
}
（5）实体类User
package com.xiyou.entity;
public class User {
private Integer id;
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
（6）UserMapper
package com.xiyou.mapper;
import com.xiyou.annotation.ExInsert;
import com.xiyou.annotation.ExParam;
import com.xiyou.annotation.ExSelect;
import com.xiyou.entity.User;
public interface UserMapper {
@ExInsert("insert into t_users(name, age) values(#{name},#{age})")
public int insertUser(@ExParam("name") String name, @ExParam("age") Integer age);
@ExSelect("select * from t_users where name = #{name} and age = #{age} ")
User selectUser(@ExParam("name") String name, @ExParam("age") Integer age);
}
（7）自定义sqlSession，其实是利用动态代理实现，传入Mapper的class文件，返回的是一个代理的对象（重要）
package com.xiyou.sql;
import com.xiyou.invocationHandler.MyInvocationHandlerMbatis;
import java.lang.reflect.Proxy;
/**
* @author
* 自定义sqlSession，负责调用Mapper接口
*/
public class SqlSession {
/**
* 传入被代理的mapper,调用其代理方法，这个就是我们能直接调用接口的原因
* @param clazz
* @param
* @return
*/
public static <T> T getMapper(Class clazz){
// 三个参数 1. 类加载器 2. 接口 3. 自定义的代理类（传入的参数是目标对象）
// 执行mapper中的方法会先执行代理类的invoke方法
return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new MyInvocationHandlerMbatis(clazz));
}
}
（8）实现代理类逻辑，sqlSession中的getMapper实际返回的就是该对象
package com.xiyou.invocationHandler;
import com.xiyou.annotation.ExInsert;
import com.xiyou.annotation.ExParam;
import com.xiyou.annotation.ExSelect;
import com.xiyou.utils.JDBCUtils;
import com.xiyou.utils.SQLUtils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author
* 代理类
*/
public class MyInvocationHandlerMbatis implements InvocationHandler {
/**
* 代理的目标对象
*/
private Object object;
/**
* 构造函数
*/
public MyInvocationHandlerMbatis (Object object) {
this.object = object;
}
/**
* 代理方法，我们执行自己的方法的时候，会执行invoke方法
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始使用代理。。。");
// 1. 判断方法上是否存在@ExtInsert
ExInsert exInsert = method.getDeclaredAnnotation(ExInsert.class);
if (exInsert != null) {
// 处理insert逻辑
return exInsert(exInsert, proxy, method, args);
}
// 2. 判断查询的逻辑
ExSelect exSelect = method.getDeclaredAnnotation(ExSelect.class);
if (exSelect != null) {
// 处理select逻辑
return exSelect(exSelect, proxy, method, args);
}
return null;
}
/**
* 处理select的逻辑
* @param exSelect
* @param proxy
* @param method
* @param args
* @return
*/
private Object exSelect(ExSelect exSelect, Object proxy, Method method, Object[] args) throws SQLException, IllegalAccessException, InstantiationException {
// 1. 获取注解上的select语句
String selectSQL = exSelect.value();
// 2. 获取方法上的参数，将其变量名和变量值进行绑定
ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
// 3. 获取sql中的要被替换的参数的名字
List<String> sqlSelectParameter = SQLUtils.sqlSelectParameter(selectSQL);
// 4. 根据参数名拼装参数值列表
List<Object> sqlParams = new ArrayList<>();
for (String parameterName : sqlSelectParameter) {
Object parameterValue = paramsMap.get(parameterName);
sqlParams.add(parameterValue);
}
// 5. 将select中的sql的#{}占位符替换成？
String newSql = SQLUtils.parameQuestion(selectSQL, sqlSelectParameter);
System.out.println("newSQL:" + newSql + ",sqlParams:" + sqlParams.toString());
// 6. 执行sql语句
ResultSet res = JDBCUtils.query(newSql, sqlParams);
// 7. 判断是否有返回值
if (!res.next()) {
return null;
}
// 8. 下标往上移动，因为next的时候，下标移动到下面了
res.previous();
// 9. 使用反射机制获取方法返回值类型
Class<?> returnType = method.getReturnType();
// 10. 创建返回值类型的对象
Object object = returnType.newInstance();
// 11. 循环遍历结果，将每一个结果按照字段赋值给返回值类型的对象，将jdbc的返回值，拼装成List
while (res.next()) {
// 获取当前的所有的属性
Field[] declaredFields = returnType.getDeclaredFields();
// 遍历所有的属性名，将查询结果赋值进去
for (Field field : declaredFields) {
String fieldName = field.getName();
Object fieldValue = res.getObject(fieldName);
// 设置反射对象的子端可以访问，因为要进行赋值
field.setAccessible(true);
field.set(object, fieldValue);
}
}
return object;
}
/**
* 用来处理insert的逻辑实现
* @param exInsert insert的注解对象，用来获得注解属性
* @param proxy 被代理的对象
* @param method 被代理的方法
* @param args 方法的参数
* @return
*/
private Object exInsert(ExInsert exInsert, Object proxy, Method method, Object[] args) {
// 进入到这里就证明了该方法上是存在@ExInsert注解的
// 1. 获取sql语句
String insertSql = exInsert.value();
// 2. 获取方法的参数和SQL参数进行匹配
ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
// 3. 开始切分sql，找到需要替换的参数的名字
String[] sqlInsertParameter = SQLUtils.sqlInsertParameter(insertSql);
// 4. 根据sql中的#{}的参数，抽取出所有变量名对应的变量的值
List<Object> sqlParams = sqlParams(sqlInsertParameter, paramsMap);
// 5. 将sql中的#{}占位符变为？，使得JDBC识别
String newSql = SQLUtils.parameQuestion(insertSql, sqlInsertParameter);
System.out.println("newSQL: " + newSql + " params: " + sqlParams.toString());
// 6. 执行insert语句
return JDBCUtils.insert(newSql, false, sqlParams);
}
/**
* 根据sql中的#{}中的参数，抽取出变量名对应的变量的值
* @param sqlInsertParameter sql中的变量名
* @param paramsMap 变量名和变量值
* @return
*/
private List<Object> sqlParams(String[] sqlInsertParameter, ConcurrentHashMap<Object, Object> paramsMap) {
List<Object> sqlParams = new ArrayList<>();
for (String paramName : sqlInsertParameter) {
Object paramValue = paramsMap.get(paramName);
sqlParams.add(paramValue);
}
return sqlParams;
}
/**
* 获取参数里的注解的值，将其进行替换到sql中
* @param proxy
* @param method
* @param args
*/
private ConcurrentHashMap<Object, Object> paramsMap(Object proxy, Method method, Object[] args) {
// 用来保存参数名称和参数值，key是@ExParam的value属性值，name是形参的参数值
ConcurrentHashMap<Object, Object> paramsMap = new ConcurrentHashMap<>();
// 获取所有的方法上的参数
Parameter[] parameters = method.getParameters();
// 遍历所有的参数，看该参数中是否有@ExParam注解
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
ExParam extParam = parameter.getDeclaredAnnotation(ExParam.class);
// 如果有这个@ExParam注解
if (extParam != null) {
// 获得@Exparam的value值，里面是参数的名字
String paramName = extParam.value();
// 该name对应的参数值是
Object paramValue = args[i];
paramsMap.put(paramName, paramValue);
}
}
return paramsMap;
}
}
（9）测试类
package com.xiyou;
import com.xiyou.entity.User;
import com.xiyou.mapper.UserMapper;
import com.xiyou.sql.SqlSession;
public class Test {
public static void main(String[] args) {
// insert测试
UserMapper mapper = SqlSession.getMapper(UserMapper.class);
System.out.println(mapper);
int i = mapper.insertUser("张三", 1234);
System.out.println("插入结果: " + i);
User user = mapper.selectUser("张三", 1234);
System.out.println("查询结果: " + user.getId() + ", " + user.getName() + ", " + user.getAge());
}
}