手写MyBatis ORM框架

末蓝、 2023-07-21 13:28 160阅读 0赞

手写MyBatis ORM框架

  • 目标：
  • 实现：
      • 思路：
    • 一、前期准备
      • 1、加入依赖
      • 2、自定义插入注解
      • 3、自定义删除注解
      • 4、自定义更新注解
      • 5、自定义查询注解
      • 6、自定义参数注解
      • 7、定义和数据库对应的实体类
      • 8、定义对数据库的操作接口
      • 9、自定义动态代理方法
      • 10、自定义动态代理
      • 11、自定义测试类
    • 二、自定义代理完善
      • 1、JDBC工具类
      • 2、SQL语句处理类
      • 3、完成拦截类
  • 总结
    • 概括
    • 流程图
    • 重点及易错点
      • 1、返回值
      • 2、res.next()

目标：

  实现MyBatis的基本功能。主要包括在方法中加入以下自定义注解、则获得相应的功能：

  • ChenInsert 实现添加数据的功能
  • ChenQuery 实现查询数据的功能，如果有多条数据只返回第一条数据
  • ChenQueryList 实现查询数据的功能，如果有多条数据返回全部数据
  • ChenDelete 实现删除数据的功能
  • ChenUpdate 实现更新数据的功能，返回更新后的对象
  • ChenUpdateInt 实现更新数据的功能，返回更新的记录数
  • ChenParam 定义参数注解，获取变量名称

实现：

思路：

  自定义SqlSession，完成动态代理拦截接口方法的功能。大致步骤如下：

  • 首先判断方法上是否存在自定义注解。
  • 如果没有自定义注解则直接结束，否则获取注解上的SQL语句。
  • 然后获取方法上的参数,将参数名称和参数值绑定在一起。
  • 然后将mybatis语法的SQL语句替换成jdbc的SQL语句。
  • 接着调用jdbc代码底层执行sql语句。
  • 如果是基本类型则直接返回，如果是引用对象则使用反射机制实例对象，获取方法返回的类型，进行实例化返回给调用者。

一、前期准备

  根据测试先行的敏捷方法，我们先搭好业务应用场景、实现自定义注解，并用自定义注解模拟对数据库的增删改查。先实现空方法，再对具体需求进行开发。

1、加入依赖

  本项目MyBatisORM是对数据库的操作，所以需要引入MySQL驱动包、数据库连接池等jar包。源码如下：

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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">
  3.     <parent>
  4.         <artifactId>handwritingproject</artifactId>
  5.         <groupId>com.njust</groupId>
  6.         <version>1.0-SNAPSHOT</version>
  7.     </parent>
  8.     <modelVersion>4.0.0</modelVersion>
  10.     <artifactId>mybatischen</artifactId>
  12.     <dependencies>
  13.         <!-- mybatis核心包 -->
  14.         <dependency>
  15.             <groupId>org.mybatis</groupId>
  16.             <artifactId>mybatis</artifactId>
  17.             <version>3.4.5</version>
  18.         </dependency>
  20.         <!-- 引入Spring-AOP等相关Jar -->
  21.         <dependency>
  22.             <groupId>org.springframework</groupId>
  23.             <artifactId>spring-core</artifactId>
  24.             <version>3.0.6.RELEASE</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework</groupId>
  28.             <artifactId>spring-context</artifactId>
  29.             <version>3.0.6.RELEASE</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework</groupId>
  33.             <artifactId>spring-aop</artifactId>
  34.             <version>3.0.6.RELEASE</version>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.springframework</groupId>
  38.             <artifactId>spring-orm</artifactId>
  39.             <version>3.0.6.RELEASE</version>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.aspectj</groupId>
  43.             <artifactId>aspectjrt</artifactId>
  44.             <version>1.6.1</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>aspectj</groupId>
  48.             <artifactId>aspectjweaver</artifactId>
  49.             <version>1.5.3</version>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>cglib</groupId>
  53.             <artifactId>cglib</artifactId>
  54.             <version>2.1_2</version>
  55.         </dependency>
  57.         <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
  58.         <dependency>
  59.             <groupId>com.mchange</groupId>
  60.             <artifactId>c3p0</artifactId>
  61.             <version>0.9.5.2</version>
  62.         </dependency>
  63.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  64.         <dependency>
  65.             <groupId>mysql</groupId>
  66.             <artifactId>mysql-connector-java</artifactId>
  67.             <version>5.1.37</version>
  68.         </dependency>
  69.         <!-- https://mvnrepository.com/artifact/asm/asm -->
  70.         <dependency>
  71.             <groupId>asm</groupId>
  72.             <artifactId>asm</artifactId>
  73.             <version>3.3.1</version>
  74.         </dependency>
  77.     </dependencies>
  78. </project>

2、自定义插入注解

  定义ChenInsert 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。源码如下：

ChenInsert .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. /** * @author Chen * @version 1.0 * @date 2020/4/2 8:37 * @description: */
  5. import java.lang.annotation.*;
  7. /** * 自定义插入注解 <br> */
  8. @Documented
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Target(ElementType.METHOD)
  11. public @interface ChenInsert { 
  12.     String value();
  13. }

3、自定义删除注解

  定义ChenDelete 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。源码如下：

ChenDelete .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义删除注解 <br> */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.METHOD)
  9. public @interface ChenDelete { 
  11.     String value();
  13. }

4、自定义更新注解

  定义ChenUpdate 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。注意：该注解使得注解方法更新的返回值是更新后的实体对象。源码如下：

ChenUpdate .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义更新注解 <br> */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.METHOD)
  9. public @interface ChenUpdate { 
  11.     String value();
  13. }

  定义ChenUpdateInt 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。注意：该注解使得注解方法更新的返回值是成功更新的记录数，注意和上面的注解区别。源码如下：

ChenUpdateInt.java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义更新注解 <br> * 返回更新数量 */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.METHOD)
  9. public @interface ChenUpdateInt { 
  11.     String value();
  13. }

5、自定义查询注解

  定义ChenQuery 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。注意：该注解使得注解方法，如果有查询结果则返回查询结果的第一个值，注意和下面的注解区别。源码如下：

ChenQuery .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义查询注解 <br> */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.METHOD)
  9. public @interface ChenQuery { 
  11.     String value();
  13. }

  定义ChenQueryList 类，使得该注解的作用范围在方法上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取SQL语句做准备。注意：该注解使得注解方法，如果有查询结果则返回全部查询结果，注意和上面的注解区别。源码如下：

ChenQueryList .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义查询注解 <br> * 返回多个参数 */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.METHOD)
  9. public @interface ChenQueryList { 
  11.     String value();
  13. }

6、自定义参数注解

  定义ChenParam 类，使得该注解的作用范围在参数上 。同时保证注解会在class字节码文件中存在，在运行时可以通过反射获取到。设置value属性值，为后面获取具体参数值做准备。源码如下：

ChenParam .java

  1. package com.njust.mybatisorm.orm.annotation;
  3. import java.lang.annotation.*;
  5. /** * 自定义参数注解<br> */
  6. @Documented
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Target(ElementType.PARAMETER)
  9. public @interface ChenParam { 
  10.     String value();
  11. }

7、定义和数据库对应的实体类

  定义User 类，和数据库属性对应，包括id,用户名,年龄等基本属性。提供get()和set()方法实现对对象的操作，tostring()方法可以不要，但是为了便于测试，我们此处将其加入进来。源码如下：

User .java

  1. package com.njust.mybatisorm.entity;
  3. public class User { 
  5.     private Integer id;
  6.     private String userName;
  7.     private Integer userAge;
  9.     public String getUserName() { 
  10.         return userName;
  11.     }
  13.     public void setUserName(String userName) { 
  14.         this.userName = userName;
  15.     }
  17.     public Integer getUserAge() { 
  18.         return userAge;
  19.     }
  21.     public void setUserAge(Integer userAge) { 
  22.         this.userAge = userAge;
  23.     }
  25.     public Integer getId() { 
  26.         return id;
  27.     }
  29.     public void setId(Integer id) { 
  30.         this.id = id;
  31.     }
  33.     @Override
  34.     public String toString() { 
  35.         return "User{" +
  36.                 "id=" + id +
  37.                 ", userName='" + userName + '\'' +
  38.                 ", userAge=" + userAge +
  39.                 '}';
  40.     }
  41. }

8、定义对数据库的操作接口

  定义UserMapper 类，模拟mybatis的操作方法，对数据库进行增删改查。源码如下：

UserMapper .java

  1. package com.njust.mybatisorm.mapper;
  4. import com.njust.mybatisorm.entity.User;
  5. import com.njust.mybatisorm.orm.annotation.*;
  7. import java.util.List;
  9. public interface UserMapper { 
  11.     @ChenInsert("insert into user(userName,userAge) values(#{userName1},#{userAge})")
  12.     public int insertUser(@ChenParam("userName1") String userName, @ChenParam("userAge") Integer userAge);
  14.     @ChenDelete("DELETE from user WHERE id=#{id}")
  15.     public int deleteUser(@ChenParam("id") Integer id);
  17.     @ChenQuery("select * from User where userName=#{userName} and userAge=#{userAge} ")
  18.     User selectUser(@ChenParam("userName") String name, @ChenParam("userAge") Integer userAge);
  20.     @ChenQueryList("select * from User where userName=#{userName} and userAge=#{userAge} ")
  21.     List<User> selectUserList(@ChenParam("userName") String name, @ChenParam("userAge") Integer userAge);
  23.     @ChenUpdate("UPDATE user set userName=#{userName} ,userAge=#{userAge} WHERE id=#{id} ")
  24.     User updateUser(@ChenParam("id") Integer id, @ChenParam("userName") String name, @ChenParam("userAge") Integer userAge);
  26.     @ChenUpdateInt("UPDATE user set userName=#{userName} ,userAge=#{userAge} WHERE id=#{id} ")
  27.     int updateUserInt(@ChenParam("id") Integer id, @ChenParam("userName") String name, @ChenParam("userAge") Integer userAge);
  29. }

9、自定义动态代理方法

  定义SqlSession 类，拦截代理接口，使用自定义ChenInvocationHandlerMybatis拦截器对方法实际处理。源码如下：

SqlSession .java

  1. package com.njust.mybatisorm.sql;
  4. import com.njust.mybatisorm.orm.aop.ChenInvocationHandlerMybatis;
  6. import java.lang.reflect.Proxy;
  8. public class SqlSession { 
  10.     // 加载Mapper接口
  11.     public static <T> T getMapper(Class classz) { 
  12.         //loader: 用哪个类加载器去加载代理对象
  13.         //interfaces:动态代理类需要实现的接口
  14.         //h:动态代理方法在执行时，会调用h里面的invoke方法去执行
  15.         return (T) Proxy.newProxyInstance(classz.getClassLoader(), new Class[]{ classz},
  16.                 new ChenInvocationHandlerMybatis(classz));
  17.     }
  19. }

10、自定义动态代理

  定义ChenInvocationHandlerMybatiss 类，继承InvocationHandler类，实现其代理拦截方法，这里我们要检测业务环境是否搭建成功，只是简单的拦截并输出。测试成功之后再实现具体的业务逻辑。源码如下：

ChenInvocationHandlerMybatiss .java

  1. package com.njust.mybatisorm.orm.aop;
  4. import com.njust.mybatisorm.orm.annotation.*;
  5. import com.njust.mybatisorm.utils.JDBCUtils;
  6. import com.njust.mybatisorm.utils.SQLUtils;
  7. import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;
  9. import java.lang.reflect.*;
  10. import java.sql.ResultSet;
  11. import java.sql.SQLException;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.concurrent.ConcurrentHashMap;
  16. import static com.njust.mybatisorm.utils.SQLUtils.getTableName;
  18. /** * 使用反射动态代理技术 拦截接口防范 */
  19. public class ChenInvocationHandlerMybatiss implements InvocationHandler { 
  20.     private Object object;
  22.     public ChenInvocationHandlerMybatiss(Object object) { 
  23.         this.object = object;
  24.     }
  26.     // proxy 代理对象 method拦截方法 args方法上的参数值
  27.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  28.         System.out.println("使用动态代理技术拦截接口方法开始");
  29.         // 使用白话问翻译,@ChenInsert封装过程
  30.         // 1. 判断方法上是否存在@ChenInsert
  31.         ChenInsert chenInsert = method.getDeclaredAnnotation(ChenInsert.class);
  32.         if (chenInsert != null) { 
  33.             System.out.println("拦截到ChenInsert注解");
  34.         }
  36.         // 1. 判断方法上是否存 在删除注解
  37.         ChenDelete chenDelete = method.getDeclaredAnnotation(ChenDelete.class);
  38.         if (chenDelete != null) { 
  39.             System.out.println("拦截到ChenDelete注解");
  40.         }
  42.         // 2.查询的思路
  43.         // 1. 判断方法上是否存 在查询注解
  44.         ChenQuery chenQuery = method.getDeclaredAnnotation(ChenQuery.class);
  45.         if (chenQuery != null) { 
  46.             System.out.println("拦截到ChenQuery注解");
  47.         }
  49.         // 1. 判断方法上是否存 在查询注解
  50.         ChenQueryList chenQueryList = method.getDeclaredAnnotation(ChenQueryList.class);
  51.         if (chenQueryList != null) { 
  52.             System.out.println("拦截到ChenQueryList注解");
  53.         }
  55.         /** * 更新 */
  56.         ChenUpdate chenUpdate = method.getDeclaredAnnotation(ChenUpdate.class);
  57.         if (chenUpdate != null) { 
  58.             System.out.println("拦截到ChenUpdate注解");
  59.         }
  61.         /** * 更新 返回更新数量 */
  62.         ChenUpdateInt chenUpdateInt = method.getDeclaredAnnotation(ChenUpdateInt.class);
  63.         if (chenUpdateInt != null) { 
  64.             System.out.println("拦截到ChenUpdateInt注解");
  65.         }
  67.         return new Object();
  68.     }
  71. }

11、自定义测试类

  定义TestOK 类，类似MyBatis般操作数据库，这里节约时间，我只测试了selectUserList()方法，其他方法类似。源码如下：

TestOK .java

  1. package com.njust.mybatisorm;
  3. import com.njust.mybatisorm.entity.User;
  4. import com.njust.mybatisorm.mapper.UserMapper;
  5. import com.njust.mybatisorm.sql.SqlSession;
  6. import org.junit.Test;
  8. import java.util.List;
  10. /** * @author Chen * @version 1.0 * @date 2020/4/2 14:49 * @description: */
  11. public class TestOK { 
  12.     @Test
  13.     public void test7(){ 
  15.         // 使用动态代理技术虚拟调用方法
  16.         UserMapper userMapper = SqlSession.getMapper(UserMapper.class);
  17.         List<User> users = userMapper.selectUserList("陈1", 20);
  18.         System.out.println(users);
  19.     }
  20. }

  控制台输出如下：

Console

  1. 使用动态代理技术拦截接口方法开始
  2. 拦截到ChenQueryList注解
  4. java.lang.ClassCastException: java.lang.Object cannot be cast to java.util.List
  6.     at com.sun.proxy.$Proxy4.selectUserList(Unknown Source)
  7.     at com.njust.mybatisorm.TestOK.test7(TestOK.java:22)
  8.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  9.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  10.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  11.     at java.lang.reflect.Method.invoke(Method.java:498)
  12.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
  13.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
  14.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
  15.     at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
  16.     at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
  17.     at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
  18.     at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
  19.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
  20.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
  21.     at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
  22.     at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
  23.     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
  24.     at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
  25.     at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
  26.     at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
  27.     at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
  28.     at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
  29.     at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
  30.     at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
  31.     at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
  32.     at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
  35. Process finished with exit code -1

  控制台成功输出我们的拦截信息。异常是因为我们还没有具体实现业务逻辑，这也是我们接下来要做的。至此，我们的业务环境已经搭建成功。

二、自定义代理完善

  完善实际对数据库的增删改查功能。

1、JDBC工具类

  定义JDBCUtils 类，封装JDBC对数据库的操作，便于我们在拦截类中直接调用。这里为了简单起见，直接将数据库相关信息写死，读者可以将其配置到配置文件中。源码如下：

JDBCUtils .java

  1. package com.njust.mybatisorm.utils;
  3. import java.sql.*;
  4. import java.util.List;
  6. public final class JDBCUtils { 
  8.     private static String connect;
  9.     private static String driverClassName;
  10.     private static String URL;
  11.     private static String username;
  12.     private static String password;
  13.     private static boolean autoCommit;
  15.     /** * 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象 */
  16.     private static Connection conn;
  18.     static { 
  19.         config();
  20.     }
  22.     /** * 开头配置自己的数据库信息 */
  23.     private static void config() { 
  24.         /* * 获取驱动 */
  25.         driverClassName = "com.mysql.jdbc.Driver";
  26.         /* * 获取URL */
  27.         URL = "jdbc:mysql://localhost:3306/mysql_learning?useUnicode=true&characterEncoding=utf8";
  28.         /* * 获取用户名 */
  29.         username = "root";
  30.         /* * 获取密码 */
  31.         password = "root";
  32.         /* * 设置是否自动提交，一般为false不用改 */
  33.         autoCommit = false;
  35.     }
  37.     /** * 载入数据库驱动类 */
  38.     private static boolean load() { 
  39.         try { 
  40.             Class.forName(driverClassName);
  41.             return true;
  42.         } catch (ClassNotFoundException e) { 
  43.             System.out.println("驱动类 " + driverClassName + " 加载失败");
  44.         }
  46.         return false;
  47.     }
  49.     /** * 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true */
  50.     private static boolean invalid() { 
  51.         if (conn != null) { 
  52.             try { 
  53.                 if (conn.isClosed() || !conn.isValid(3)) { 
  54.                     return true;
  55.                     /* * isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true */
  56.                 }
  57.             } catch (SQLException e) { 
  58.                 e.printStackTrace();
  59.             }
  60.             /* * conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false ) */
  61.             return false;
  62.         } else { 
  63.             return true;
  64.         }
  65.     }
  67.     /** * 建立数据库连接 */
  68.     public static Connection connect() { 
  69.         if (invalid()) {  /* invalid为true时，说明连接是失败的 */
  70.             /* 加载驱动 */
  71.             load();
  72.             try { 
  73.                 /* 建立连接 */
  74.                 conn = DriverManager.getConnection(URL, username, password);
  75.             } catch (SQLException e) { 
  76.                 System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
  77.             }
  78.         }
  79.         return conn;
  80.     }
  82.     /** * 设置是否自动提交事务 **/
  83.     public static void transaction() { 
  85.         try { 
  86.             conn.setAutoCommit(autoCommit);
  87.         } catch (SQLException e) { 
  88.             System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
  89.         }
  91.     }
  93.     /** * 创建 Statement 对象 */
  94.     public static Statement statement() { 
  95.         Statement st = null;
  96.         connect();
  97.         /* 如果连接是无效的就重新连接 */
  98.         transaction();
  99.         /* 设置事务的提交方式 */
  100.         try { 
  101.             st = conn.createStatement();
  102.         } catch (SQLException e) { 
  103.             System.out.println("创建 Statement 对象失败: " + e.getMessage());
  104.         }
  106.         return st;
  107.     }
  109.     /** * 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象 * * @param SQL 带参数占位符的SQL语句 * @return 返回相应的 PreparedStatement 对象 */
  110.     private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) { 
  112.         PreparedStatement ps = null;
  113.         connect();
  114.         /* 如果连接是无效的就重新连接 */
  115.         transaction();
  116.         /* 设置事务的提交方式 */
  117.         try { 
  118.             if (autoGeneratedKeys) { 
  119.                 ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
  120.             } else { 
  121.                 ps = conn.prepareStatement(SQL);
  122.             }
  123.         } catch (SQLException e) { 
  124.             System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
  125.         }
  127.         return ps;
  129.     }
  131.     public static ResultSet query(String SQL, List<Object> params) { 
  133.         if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) { 
  134.             throw new RuntimeException("你的SQL语句为空或不是查询语句");
  135.         }
  136.         ResultSet rs = null;
  137.         if (params.size() > 0) { 
  138.             /* 说明 有参数 传入，就需要处理参数 */
  139.             PreparedStatement ps = prepare(SQL, false);
  140.             try { 
  141.                 for (int i = 0; i < params.size(); i++) { 
  142.                     ps.setObject(i + 1, params.get(i));
  143.                 }
  144.                 rs = ps.executeQuery();
  145.             } catch (SQLException e) { 
  146.                 System.out.println("执行SQL失败: " + e.getMessage());
  147.             }
  148.         } else { 
  149.             /* 说明没有传入任何参数 */
  150.             Statement st = statement();
  151.             try { 
  152.                 rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
  153.             } catch (SQLException e) { 
  154.                 System.out.println("执行SQL失败: " + e.getMessage());
  155.             }
  156.         }
  158.         return rs;
  160.     }
  162.     private static Object typeof(Object o) { 
  163.         Object r = o;
  165.         if (o instanceof java.sql.Timestamp) { 
  166.             return r;
  167.         }
  168.         // 将 java.util.Date 转成 java.sql.Date
  169.         if (o instanceof java.util.Date) { 
  170.             java.util.Date d = (java.util.Date) o;
  171.             r = new java.sql.Date(d.getTime());
  172.             return r;
  173.         }
  174.         // 将 Character 或 char 变成 String
  175.         if (o instanceof Character || o.getClass() == char.class) { 
  176.             r = String.valueOf(o);
  177.             return r;
  178.         }
  179.         return r;
  180.     }
  182.     public static boolean execute(String SQL, Object... params) { 
  183.         if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) { 
  184.             throw new RuntimeException("你的SQL语句为空或有错");
  185.         }
  186.         boolean r = false;
  187.         /* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */
  189.         /* 获得 被执行的 SQL 语句的 前缀 */
  190.         SQL = SQL.trim();
  191.         SQL = SQL.toLowerCase();
  192.         String prefix = SQL.substring(0, SQL.indexOf(" "));
  193.         String operation = ""; // 用来保存操作类型的 变量
  194.         // 根据前缀 确定操作
  195.         switch (prefix) { 
  196.             case "create":
  197.                 operation = "create table";
  198.                 break;
  199.             case "alter":
  200.                 operation = "update table";
  201.                 break;
  202.             case "drop":
  203.                 operation = "drop table";
  204.                 break;
  205.             case "truncate":
  206.                 operation = "truncate table";
  207.                 break;
  208.             case "insert":
  209.                 operation = "insert :";
  210.                 break;
  211.             case "update":
  212.                 operation = "update :";
  213.                 break;
  214.             case "delete":
  215.                 operation = "delete :";
  216.                 break;
  217.         }
  218.         if (params.length > 0) {  // 说明有参数
  219.             PreparedStatement ps = prepare(SQL, false);
  220.             Connection c = null;
  221.             try { 
  222.                 c = ps.getConnection();
  223.             } catch (SQLException e) { 
  224.                 e.printStackTrace();
  225.             }
  226.             try { 
  227.                 for (int i = 0; i < params.length; i++) { 
  228.                     Object p = params[i];
  229.                     p = typeof(p);
  230.                     ps.setObject(i + 1, p);
  231.                 }
  232.                 ps.executeUpdate();
  233.                 commit(c);
  234.                 r = true;
  235.             } catch (SQLException e) { 
  236.                 System.out.println(operation + " 失败: " + e.getMessage());
  237.                 rollback(c);
  238.             }
  240.         } else {  // 说明没有参数
  242.             Statement st = statement();
  243.             Connection c = null;
  244.             try { 
  245.                 c = st.getConnection();
  246.             } catch (SQLException e) { 
  247.                 e.printStackTrace();
  248.             }
  249.             // 执行 DDL 或 DML 语句，并返回执行结果
  250.             try { 
  251.                 st.executeUpdate(SQL);
  252.                 commit(c); // 提交事务
  253.                 r = true;
  254.             } catch (SQLException e) { 
  255.                 System.out.println(operation + " 失败: " + e.getMessage());
  256.                 rollback(c); // 回滚事务
  257.             }
  258.         }
  259.         return r;
  260.     }
  262.     /* * * @param SQL 需要执行的 INSERT 语句 * * @param autoGeneratedKeys 指示是否需要返回由数据库产生的键 * * @param params 将要执行的SQL语句中包含的参数占位符的 参数值 * * @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys * 为 false 则返回受当前SQL影响的记录数目 */
  263.     public static int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) { 
  264.         int var = -1;
  265.         if (SQL == null || SQL.trim().isEmpty()) { 
  266.             throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
  267.         }
  268.         // 如果不是 insert 开头开头的语句
  269.         if (!SQL.trim().toLowerCase().startsWith("insert")) { 
  270.             System.out.println(SQL.toLowerCase());
  271.             throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
  272.         }
  273.         // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
  274.         SQL = SQL.trim();
  275.         SQL = SQL.toLowerCase();
  276.         if (params.size() > 0) {  // 说明有参数
  277.             PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
  278.             Connection c = null;
  279.             try { 
  280.                 c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
  281.             } catch (SQLException e) { 
  282.                 e.printStackTrace();
  283.             }
  284.             try { 
  285.                 for (int i = 0; i < params.size(); i++) { 
  286.                     Object p = params.get(i);
  287.                     p = typeof(p);
  288.                     ps.setObject(i + 1, p);
  289.                 }
  290.                 int count = ps.executeUpdate();
  291.                 if (autoGeneratedKeys) {  // 如果希望获得数据库产生的键
  292.                     ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
  293.                     if (rs.next()) {  // 因为是保存的是单条记录，因此至多返回一个键
  294.                         var = rs.getInt(1); // 获得值并赋值给 var 变量
  295.                     }
  296.                 } else { 
  297.                     var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  298.                 }
  299.                 commit(c);
  300.             } catch (SQLException e) { 
  301.                 System.out.println("数据保存失败: " + e.getMessage());
  302.                 rollback(c);
  303.             }
  304.         } else {  // 说明没有参数
  305.             Statement st = statement();
  306.             Connection c = null;
  307.             try { 
  308.                 c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
  309.             } catch (SQLException e) { 
  310.                 e.printStackTrace();
  311.             }
  312.             // 执行 DDL 或 DML 语句，并返回执行结果
  313.             try { 
  314.                 int count = st.executeUpdate(SQL);
  315.                 if (autoGeneratedKeys) {  // 如果企望获得数据库产生的键
  316.                     ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
  317.                     if (rs.next()) {  // 因为是保存的是单条记录，因此至多返回一个键
  318.                         var = rs.getInt(1); // 获得值并赋值给 var 变量
  319.                     }
  320.                 } else { 
  321.                     var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  322.                 }
  323.                 commit(c); // 提交事务
  324.             } catch (SQLException e) { 
  325.                 System.out.println("数据保存失败: " + e.getMessage());
  326.                 rollback(c); // 回滚事务
  327.             }
  328.         }
  329.         return var;
  330.     }
  332.     public static int delete(String SQL, List<Object> params) { 
  333.         int var = -1;
  334.         if (SQL == null || SQL.trim().isEmpty()) { 
  335.             throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
  336.         }
  337.         // 如果不是 insert 开头开头的语句
  338.         if (!SQL.trim().toLowerCase().startsWith("delete")) { 
  339.             System.out.println(SQL.toLowerCase());
  340.             throw new RuntimeException("你指定的SQL语句不是删除语句，请检查你的SQL语句");
  341.         }
  342.         // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
  343.         SQL = SQL.trim();
  344.         SQL = SQL.toLowerCase();
  345.         if (params.size() > 0) {  // 说明有参数
  346.             PreparedStatement ps = prepare(SQL, false);
  347.             Connection c = null;
  348.             try { 
  349.                 c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
  350.             } catch (SQLException e) { 
  351.                 e.printStackTrace();
  352.             }
  353.             try { 
  354.                 for (int i = 0; i < params.size(); i++) { 
  355.                     Object p = params.get(i);
  356.                     p = typeof(p);
  357.                     ps.setObject(i + 1, p);
  358.                 }
  359.                 int count = ps.executeUpdate();
  360.                 var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  361.                 commit(c);
  362.             } catch (SQLException e) { 
  363.                 System.out.println("数据删除失败: " + e.getMessage());
  364.                 rollback(c);
  365.             }
  366.         } else {  // 说明没有参数
  367.             Statement st = statement();
  368.             Connection c = null;
  369.             try { 
  370.                 c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
  371.             } catch (SQLException e) { 
  372.                 e.printStackTrace();
  373.             }
  374.             // 执行 DDL 或 DML 语句，并返回执行结果
  375.             try { 
  376.                 int count = st.executeUpdate(SQL);
  377.                 var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  378.                 commit(c); // 提交事务
  379.             } catch (SQLException e) { 
  380.                 System.out.println("数据删除失败: " + e.getMessage());
  381.                 rollback(c); // 回滚事务
  382.             }
  383.         }
  384.         return var;
  385.     }
  386.     public static int update(String SQL, List<Object> params) { 
  387.         int var = -1;
  388.         if (SQL == null || SQL.trim().isEmpty()) { 
  389.             throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
  390.         }
  391.         // 如果不是 insert 开头开头的语句
  392.         if (!SQL.trim().toLowerCase().startsWith("update")) { 
  393.             System.out.println(SQL.toLowerCase());
  394.             throw new RuntimeException("你指定的SQL语句不是更新语句，请检查你的SQL语句");
  395.         }
  396.         // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
  397.         SQL = SQL.trim();
  398.         SQL = SQL.toLowerCase();
  399.         if (params.size() > 0) {  // 说明有参数
  400.             PreparedStatement ps = prepare(SQL, false);
  401.             Connection c = null;
  402.             try { 
  403.                 c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
  404.             } catch (SQLException e) { 
  405.                 e.printStackTrace();
  406.             }
  407.             try { 
  408.                 for (int i = 0; i < params.size(); i++) { 
  409.                     Object p = params.get(i);
  410.                     p = typeof(p);
  411.                     ps.setObject(i + 1, p);
  412.                 }
  413.                 int count = ps.executeUpdate();
  414.                 var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  415.                 commit(c);
  416.             } catch (SQLException e) { 
  417.                 System.out.println("数据更新失败: " + e.getMessage());
  418.                 rollback(c);
  419.             }
  420.         } else {  // 说明没有参数
  421.             Statement st = statement();
  422.             Connection c = null;
  423.             try { 
  424.                 c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
  425.             } catch (SQLException e) { 
  426.                 e.printStackTrace();
  427.             }
  428.             // 执行 DDL 或 DML 语句，并返回执行结果
  429.             try { 
  430.                 int count = st.executeUpdate(SQL);
  431.                 var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
  432.                 commit(c); // 提交事务
  433.             } catch (SQLException e) { 
  434.                 System.out.println("数据更新失败: " + e.getMessage());
  435.                 rollback(c); // 回滚事务
  436.             }
  437.         }
  438.         return var;
  439.     }
  441.     /** * 提交事务 */
  442.     private static void commit(Connection c) { 
  443.         if (c != null && !autoCommit) { 
  444.             try { 
  445.                 c.commit();
  446.             } catch (SQLException e) { 
  447.                 e.printStackTrace();
  448.             }
  449.         }
  450.     }
  452.     /** * 回滚事务 */
  453.     private static void rollback(Connection c) { 
  454.         if (c != null && !autoCommit) { 
  455.             try { 
  456.                 c.rollback();
  457.             } catch (SQLException e) { 
  458.                 e.printStackTrace();
  459.             }
  460.         }
  461.     }
  463.     /** * 释放资源 **/
  464.     public static void release(Object cloaseable) { 
  466.         if (cloaseable != null) { 
  468.             if (cloaseable instanceof ResultSet) { 
  469.                 ResultSet rs = (ResultSet) cloaseable;
  470.                 try { 
  471.                     rs.close();
  472.                 } catch (SQLException e) { 
  473.                     e.printStackTrace();
  474.                 }
  475.             }
  477.             if (cloaseable instanceof Statement) { 
  478.                 Statement st = (Statement) cloaseable;
  479.                 try { 
  480.                     st.close();
  481.                 } catch (SQLException e) { 
  482.                     e.printStackTrace();
  483.                 }
  484.             }
  486.             if (cloaseable instanceof Connection) { 
  487.                 Connection c = (Connection) cloaseable;
  488.                 try { 
  489.                     c.close();
  490.                 } catch (SQLException e) { 
  491.                     e.printStackTrace();
  492.                 }
  493.             }
  495.         }
  497.     }
  499. }

2、SQL语句处理类

  定义SQLUtils 类，封装Mybatis语句到JDBC语句的转化。由于mybatis的底层是JDBC，所以会出现Mybatis语法和JDBC语法的转换，所以我们将这些公共方法封装起来，便于拦截类调用。源码如下：

SQLUtils .java

  1. package com.njust.mybatisorm.utils;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /** * SQL拼接<br> */
  7. public class SQLUtils { 
  8.     /** * * 获取Insert语句后面values 参数信息<br> * @param sql * @return */
  9.     public static String[] sqlInsertParameter(String sql) { 
  10.         int startIndex = sql.indexOf("values");
  11.         int endIndex = sql.length();
  12.         String substring = sql.substring(startIndex + 6, endIndex).replace("(", "").replace(")", "").replace("#{", "")
  13.                 .replace("}", "");
  14.         String[] split = substring.split(",");
  15.         return split;
  16.     }
  18.     /** * * 获取select 后面where语句 * @param sql * @return */
  19.     public static List<String> sqlSelectParameter(String sql) { 
  20.         int startIndex = sql.indexOf("where");
  21.         int endIndex = sql.length();
  22.         String substring = sql.substring(startIndex + 5, endIndex);
  23.         String[] split = substring.split("and");
  24.         List<String> listArr = new ArrayList<>();
  25.         for (String string : split) { 
  26.             String[] sp2 = string.split("=");
  27.             listArr.add(sp2[0].trim());
  28.         }
  29.         return listArr;
  30.     }
  33.     public static String deal(StringBuilder sql) { 
  34.         String result = null;
  36.         int start = sql.indexOf("#{");
  37.         int end = sql.indexOf("}");
  39.         result = sql.substring(start + 2, end);
  41.         return result;
  42.     }
  44.     /** * 将SQL参数提取出来，并将最后生成的jdbc语句也放到list中 * @param sql * @return */
  45.     public static List<String> dealList(String sql) { 
  46.         StringBuilder stringBuilder = new StringBuilder(sql);
  47.         ArrayList<String> strings = new ArrayList<>();
  48.         while (stringBuilder.indexOf("#{") != -1) { 
  49.             strings.add(deal(stringBuilder));
  50.             stringBuilder = stringBuilder.replace(stringBuilder.indexOf("#{"),
  51.                     stringBuilder.indexOf("}") + 1, "?");
  52.         }
  53.         strings.add(String.valueOf(stringBuilder));
  54.         return strings;
  55.     }
  57.     public static String getTableName(String sql) { 
  58.         sql = sql.toLowerCase();
  59.         String name = null;
  60.         int start = sql.indexOf("update");
  61.         int end = sql.indexOf("set");
  62.         name = sql.substring(start+6, end);
  63.         name = name.trim();
  64.         return name;
  65.     }
  67.     /** * 将SQL语句的参数替换变为?<br> * @param sql * @param parameterName * @return */
  68.     public static String parameQuestion(String sql, String[] parameterName) { 
  69.         for (int i = 0; i < parameterName.length; i++) { 
  70.             String string = parameterName[i];
  71.             sql = sql.replace("#{" + string + "}", "?");
  72.         }
  73.         return sql;
  74.     }
  76.     public static String parameQuestion(String sql, List<String> parameterName) { 
  77.         for (int i = 0; i < parameterName.size(); i++) { 
  78.             String string = parameterName.get(i);
  79.             sql = sql.replace("#{" + string + "}", "?");
  80.         }
  81.         return sql;
  82.     }
  84. }

3、完成拦截类

  修改ChenInvocationHandlerMybatis 类，完成具体的业务逻辑处理。各个注解的处理流程类似，基本流程是首先判断方法上是否存在自定义注解。如果没有自定义注解则直接结束，否则获取注解上的SQL语句。然后获取方法上的参数,将参数名称和参数值绑定在一起。
然后将mybatis语法的SQL语句替换成jdbc的SQL语句。接着调用jdbc代码底层执行sql语句。如果是基本类型则直接返回，如果是引用对象则使用反射机制实例对象，获取方法返回的类型，进行实例化返回给调用者。源码如下：

ChenInvocationHandlerMybatis .java

  1. package com.njust.mybatisorm.orm.aop;
  4. import com.njust.mybatisorm.orm.annotation.*;
  5. import com.njust.mybatisorm.utils.JDBCUtils;
  6. import com.njust.mybatisorm.utils.SQLUtils;
  7. import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;
  9. import java.lang.reflect.*;
  10. import java.sql.ResultSet;
  11. import java.sql.SQLException;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.concurrent.ConcurrentHashMap;
  16. import static com.njust.mybatisorm.utils.SQLUtils.getTableName;
  18. /** * 使用反射动态代理技术 拦截接口防范 */
  19. public class ChenInvocationHandlerMybatis implements InvocationHandler { 
  20.     private Object object;
  22.     public ChenInvocationHandlerMybatis(Object object) { 
  23.         this.object = object;
  24.     }
  26.     // proxy 代理对象 method拦截方法 args方法上的参数值
  27.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  28.         System.out.println("使用动态代理技术拦截接口方法开始");
  29.         // 使用白话问翻译,@ChenInsert封装过程
  30.         // 1. 判断方法上是否存在@ChenInsert
  31.         ChenInsert chenInsert = method.getDeclaredAnnotation(ChenInsert.class);
  32.         if (chenInsert != null) { 
  33.             return chenInsert(chenInsert, proxy, method, args);
  34.         }
  36.         // 1. 判断方法上是否存 在删除注解
  37.         ChenDelete chenDelete = method.getDeclaredAnnotation(ChenDelete.class);
  38.         if (chenDelete != null) { 
  39.             return chenDelete(chenDelete, proxy, method, args);
  40.         }
  42.         // 2.查询的思路
  43.         // 1. 判断方法上是否存 在查询注解
  44.         ChenQuery chenQuery = method.getDeclaredAnnotation(ChenQuery.class);
  45.         if (chenQuery != null) { 
  46.             return chenQuery(chenQuery, proxy, method, args);
  47.         }
  49.         // 1. 判断方法上是否存 在查询注解
  50.         ChenQueryList chenQueryList = method.getDeclaredAnnotation(ChenQueryList.class);
  51.         if (chenQueryList != null) { 
  52.             return chenQueryList(chenQueryList, proxy, method, args);
  53.         }
  55.         /** * 更新 */
  56.         ChenUpdate chenUpdate = method.getDeclaredAnnotation(ChenUpdate.class);
  57.         if (chenUpdate != null) { 
  58.             return chenUpdate(chenUpdate, proxy, method, args);
  59.         }
  61.         /** * 更新 返回更新数量 */
  62.         ChenUpdateInt chenUpdateInt = method.getDeclaredAnnotation(ChenUpdateInt.class);
  63.         if (chenUpdateInt != null) { 
  64.             return chenUpdateInt(chenUpdateInt, proxy, method, args);
  65.         }
  67.         return null;
  68.     }
  70.     private Object chenQuery(ChenQuery chenQuery, Object proxy, Method method, Object[] args)
  71.             throws SQLException, IllegalAccessException, InstantiationException { 
  73.         // 2. 获取注解上查询的SQL语句
  74.         String selectSQL = chenQuery.value();
  75.         // 3. 获取方法上的参数,绑定在一起
  76.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  77.         // 4. 参数替换？传递方式
  78.         List<String> sqlSelectParameter = SQLUtils.sqlSelectParameter(selectSQL);
  79.         // 5.传递参数
  80.         List<Object> sqlParams = new ArrayList<>();
  81.         for (String parameterName : sqlSelectParameter) { 
  82.             Object parameterValue = paramsMap.get(parameterName);
  83.             sqlParams.add(parameterValue);
  84.         }
  85.         // 6.将sql语句替换成?
  86.         String newSql = SQLUtils.parameQuestion(selectSQL, sqlSelectParameter);
  87.         System.out.println("newSQL:" + newSql + ",sqlParams:" + sqlParams.toString());
  88.         return getObject(method, newSql, sqlParams);
  89.     }
  91.     private List<Object> chenQueryList(ChenQueryList chenQueryList, Object proxy, Method method, Object[] args)
  92.             throws SQLException, IllegalAccessException, InstantiationException { 
  94.         // 2. 获取注解上查询的SQL语句
  95.         String selectSQL = chenQueryList.value();
  96.         // 3. 获取方法上的参数,绑定在一起
  97.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  98.         // 4. 参数替换？传递方式
  99.         List<String> sqlSelectParameter = SQLUtils.sqlSelectParameter(selectSQL);
  100.         // 5.传递参数
  101.         List<Object> sqlParams = new ArrayList<>();
  102.         for (String parameterName : sqlSelectParameter) { 
  103.             Object parameterValue = paramsMap.get(parameterName);
  104.             sqlParams.add(parameterValue);
  105.         }
  106.         // 6.将sql语句替换成?
  107.         String newSql = SQLUtils.parameQuestion(selectSQL, sqlSelectParameter);
  108.         System.out.println("newSQL:" + newSql + ",sqlParams:" + sqlParams.toString());
  109.         return getObjectList(method, newSql, sqlParams);
  110.     }
  113.     /** * 5.调用jdbc代码底层执行sql语句 * 6.使用反射机制实例对象### 获取方法返回的类型，进行实例化 * 思路: * 1.使用反射机制获取方法的类型 * 2.判断是否有结果集,如果有结果集，在进行初始化 * 3.使用反射机制,给对象赋值 * * @param method * @param newSql * @param sqlParams * @return * @throws SQLException * @throws IllegalAccessException * @throws InstantiationException */
  114.     private Object getObject(Method method, String newSql, List<Object> sqlParams) throws SQLException, IllegalAccessException, InstantiationException { 
  115.         ResultSet res = JDBCUtils.query(newSql, sqlParams);
  116.         // 判断是否存在值
  117.         if (!res.next()) { 
  118.             return null;
  119.         }
  120.         // 下标往上移动移位
  121.         res.previous();
  122.         // 使用反射机制获取方法的类型
  123.         Class<?> returnType = method.getReturnType();
  124.         Object object = returnType.newInstance();
  125.         if (res.next()) { 
  126.             // 获取当前所有的属性
  127.             Field[] declaredFields = returnType.getDeclaredFields();
  128.             for (Field field : declaredFields) { 
  129.                 String fieldName = field.getName();
  130.                 Object fieldValue = res.getObject(fieldName);
  131.                 field.setAccessible(true);
  132.                 field.set(object, fieldValue);
  133.             }
  134.         }
  135.         return object;
  136.     }
  138.     private List<Object> getObjectList(Method method, String newSql, List<Object> sqlParams)
  139.             throws SQLException, IllegalAccessException, InstantiationException { 
  140.         ResultSet res = JDBCUtils.query(newSql, sqlParams);
  141.         // 判断是否存在值
  142.         if (!res.next()) { 
  143.             return null;
  144.         }
  145.         // 下标往上移动移位
  146.         res.previous();
  147.         // 使用反射机制获取方法的类型
  148.         Class<?> returnType = method.getReturnType();
  149. // 获取泛型返回值
  150.         Type genericReturnType = method.getGenericReturnType();
  151. // 获取list中泛型参数
  152.         Type[] actualTypeArguments = ((ParameterizedTypeImpl) genericReturnType).getActualTypeArguments();
  154.         ArrayList<Object> objects = new ArrayList<>();
  156.         while (res.next()) { 
  157.             Object object = ((Class)actualTypeArguments[0]).newInstance();
  158.             // 获取当前所有的属性
  159.             Field[] declaredFields = ((Class)actualTypeArguments[0]).getDeclaredFields();
  160.             for (Field field : declaredFields) { 
  161.                 String fieldName = field.getName();
  162.                 Object fieldValue = res.getObject(fieldName);
  163.                 field.setAccessible(true);
  164.                 field.set(object, fieldValue);
  165.             }
  166.             objects.add(object);
  167.         }
  168.         return objects;
  169.     }
  172.     private Object chenInsert(ChenInsert chenInsert, Object proxy, Method method, Object[] args) { 
  173.         // 方法上存在@ChenInsert,获取他的SQL语句
  174.         // 2. 获取SQL语句,获取注解Insert语句
  175.         String insertSql = chenInsert.value();
  176.         // System.out.println("insertSql:" + insertSql);
  177.         // 3. 获取方法的参数和SQL参数进行匹配
  178.         // 定一个一个Map集合 KEY为@ChenParamValue,Value 结果为参数值
  179.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  180.         // 存放sql执行的参数---参数绑定过程
  181.         String[] sqlInsertParameter = SQLUtils.sqlInsertParameter(insertSql);
  182.         List<Object> sqlParams = sqlParams(sqlInsertParameter, paramsMap);
  183.         // 4. 根据参数替换参数变为?
  184.         String newSQL = SQLUtils.parameQuestion(insertSql, sqlInsertParameter);
  185.         System.out.println("newSQL:" + newSQL + ",sqlParams:" + sqlParams.toString());
  186.         // 5. 调用jdbc底层代码执行语句
  187.         return JDBCUtils.insert(newSQL, false, sqlParams);
  188.     }
  190.     private Object chenDelete(ChenDelete chenDelete, Object proxy, Method method, Object[] args) { 
  191.         // 方法上存在@ChenInsert,获取他的SQL语句
  192.         // 2. 获取SQL语句,获取注解Insert语句
  193.         String deleteSql = chenDelete.value();
  194.         // System.out.println("insertSql:" + insertSql);
  195.         // 3. 获取方法的参数和SQL参数进行匹配
  196.         // 定一个一个Map集合 KEY为@ChenParamValue,Value 结果为参数值
  197.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  198.         // 4. 参数替换？传递方式
  199.         List<String> sqlSelectParameter = SQLUtils.dealList(deleteSql);
  200.         // 5.传递参数
  201.         List<Object> sqlParams = new ArrayList<>();
  203.         for (int i = 0; i < sqlSelectParameter.size() - 1; i++) { 
  204.             Object parameterValue = paramsMap.get(sqlSelectParameter.get(i));
  205.             sqlParams.add(parameterValue);
  206.         }
  208.         // 4. 根据参数替换参数变为?
  209.         String newSQL = sqlSelectParameter.get(sqlSelectParameter.size() - 1);
  210.         System.out.println("newSQL:" + newSQL + ",sqlParams:" + sqlParams.toString());
  211.         // 5. 调用jdbc底层代码执行语句
  212.         return JDBCUtils.delete(newSQL, sqlParams);
  213.     }
  215.     private Object chenUpdate(ChenUpdate chenUpdate, Object proxy, Method method, Object[] args) throws IllegalAccessException, SQLException, InstantiationException { 
  216.         // 方法上存在@ChenInsert,获取他的SQL语句
  217.         // 2. 获取SQL语句,获取注解Insert语句
  218.         String deleteSql = chenUpdate.value();
  219.         // System.out.println("insertSql:" + insertSql);
  220.         // 3. 获取方法的参数和SQL参数进行匹配
  221.         // 定一个一个Map集合 KEY为@ChenParamValue,Value 结果为参数值
  222.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  223.         // 4. 参数替换？传递方式
  224.         List<String> sqlSelectParameter = SQLUtils.dealList(deleteSql);
  225.         // 5.传递参数
  226.         List<Object> sqlParams = new ArrayList<>();
  228.         for (int i = 0; i < sqlSelectParameter.size() - 1; i++) { 
  229.             Object parameterValue = paramsMap.get(sqlSelectParameter.get(i));
  230.             sqlParams.add(parameterValue);
  231.         }
  233.         // 4. 根据参数替换参数变为?
  234.         String newSQL = sqlSelectParameter.get(sqlSelectParameter.size() - 1);
  235.         System.out.println("newSQL:" + newSQL + ",sqlParams:" + sqlParams.toString());
  236.         // 5. 调用jdbc底层代码执行语句
  237.         JDBCUtils.update(newSQL, sqlParams);
  239.         newSQL = "select * from " + getTableName(newSQL) + " where id=?";
  240.         ArrayList<Object> objects = new ArrayList<>();
  241.         objects.add(paramsMap.get("id"));
  242.         return getObject(method, newSQL, objects);
  243.     }
  244.     private Object chenUpdateInt(ChenUpdateInt chenUpdateInt, Object proxy, Method method, Object[] args) throws IllegalAccessException, SQLException, InstantiationException { 
  245.         // 方法上存在@ChenInsert,获取他的SQL语句
  246.         // 2. 获取SQL语句,获取注解Insert语句
  247.         String deleteSql = chenUpdateInt.value();
  248.         // System.out.println("insertSql:" + insertSql);
  249.         // 3. 获取方法的参数和SQL参数进行匹配
  250.         // 定一个一个Map集合 KEY为@ChenParamValue,Value 结果为参数值
  251.         ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
  252.         // 4. 参数替换？传递方式
  253.         List<String> sqlSelectParameter = SQLUtils.dealList(deleteSql);
  254.         // 5.传递参数
  255.         List<Object> sqlParams = new ArrayList<>();
  257.         for (int i = 0; i < sqlSelectParameter.size() - 1; i++) { 
  258.             Object parameterValue = paramsMap.get(sqlSelectParameter.get(i));
  259.             sqlParams.add(parameterValue);
  260.         }
  262.         // 4. 根据参数替换参数变为?
  263.         String newSQL = sqlSelectParameter.get(sqlSelectParameter.size() - 1);
  264.         System.out.println("newSQL:" + newSQL + ",sqlParams:" + sqlParams.toString());
  265.         // 5. 调用jdbc底层代码执行语句
  266.         return JDBCUtils.update(newSQL, sqlParams);
  267.     }
  269.     private List<Object> sqlParams(String[] sqlInsertParameter, ConcurrentHashMap<Object, Object> paramsMap) { 
  270.         List<Object> sqlParams = new ArrayList<>();
  271.         for (String paramName : sqlInsertParameter) { 
  272.             Object paramValue = paramsMap.get(paramName);
  273.             sqlParams.add(paramValue);
  274.         }
  275.         return sqlParams;
  276.     }
  278.     private ConcurrentHashMap<Object, Object> paramsMap(Object proxy, Method method, Object[] args) { 
  279.         ConcurrentHashMap<Object, Object> paramsMap = new ConcurrentHashMap<>();
  280.         // 获取方法上的参数
  281.         Parameter[] parameters = method.getParameters();
  282.         for (int i = 0; i < parameters.length; i++) { 
  283.             Parameter parameter = parameters[i];
  284.             ChenParam ChenParam = parameter.getDeclaredAnnotation(ChenParam.class);
  285.             if (ChenParam != null) { 
  286.                 // 参数名称
  287.                 String paramName = ChenParam.value();
  288.                 Object paramValue = args[i];
  289.                 // System.out.println(paramName + "," + paramValue);
  290.                 paramsMap.put(paramName, paramValue);
  291.             }
  292.         }
  293.         return paramsMap;
  294.     }
  296. }

总结

概括

  使用java动态代理拦截接口的调用，对不同注解分别处理对应的增删改查功能。

流程图

Created with Raphaël 2.2.0开始定义操作接口Mapper拦截器拦截接口方法调用首先判断方法上 是否存在自定义注解?获取注解上的SQL语句获取方法上的参数,将参数 名称和参数值绑定在一起将mybatis语法的SQL语句 替换成jdbc的SQL语句调用jdbc代码底层执行sql语句判断方法返回类型是否是基本类型结束是引用对象则使用反射机制实例对象， 获取方法返回的类型，进行实例化返回给调用者。yesnoyesno

重点及易错点

1、返回值

  代理方法的返回值一定要和接口一致，尤其是多结果的List类型，这里不能直接使用放射的返回结果创建实例，而是要取得泛型类型，在对对象一个个的属性赋值，手动添加到容器中再返回。

2、res.next()

  使用res.next()判断是否存在值后，如果存在在一定要调用res.previous();方法进行回滚。因为我们调用res.next()函数判断的时候指针已经向后移动了。
  有问题欢迎各位读者批评指正。

点个赞再走呗！欢迎留言哦！

发表评论

表情：
评论列表 （有 0 条评论，160人围观）

还没有评论，来说两句吧...

相关阅读

    相关 仿写简易 ORM 框架

    在前面的文章我们分析了 MyBatis 的底层执行原理，现在我们也来自己实现一个简易的 ORM 框架，在架构上去模仿 MyBatis。跟平时开发软件一样，我们首先要做的就是明确

    ﹏ヽ暗。殇╰゛Y﹏ヽ暗。殇╰゛Y/ 0 赞/ 320 阅读