• Mybatis学习笔记4 用javassist动态实现DAO接口基于接口的CRUD

    Mybatis学习笔记3 在Web中应用Mybatis_biubiubiu0706的博客-CSDN博客

    上篇最后在DAO实现类中,代码固定,没有业务逻辑,这篇笔记中对该实现类进行封装,就是说,以后不用写DAO实现类了

    我们不难发现，这个dao实现类中的⽅法代码很固定，基本上就是⼀⾏代码，通过SqlSession对象调⽤
    insert、delete、update、select等⽅法，这个类中的⽅法没有任何业务逻辑，既然是这样， 这个类我们
    能不能动态的⽣成 ，以后可以不写这个类吗？答案：可以。
    Javassist是⼀个开源的分析、编辑和创建Java字节码的类库。是由东京⼯业⼤学的数学和计算机科学
    系的 Shigeru Chiba （千叶 滋）所创建的。它已加⼊了开放源代码JBoss 应⽤服务器项⽬，通过使⽤
    Javassist对字节码操作为JBoss实现动态"AOP"框架。
    新建moudle测试javassist
    引入依赖 
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>org.example</groupId>
    8.     <artifactId>javassist</artifactId>
    9.     <version>1.0-SNAPSHOT</version>
    10.  
    11.     <properties>
    12.         <maven.compiler.source>8</maven.compiler.source>
    13.         <maven.compiler.target>8</maven.compiler.target>
    14.     </properties>
    15.  
    16.     <dependencies>
    17.         <!--javassist依赖-->
    18.         <dependency>
    19.             <groupId>org.javassist</groupId>
    20.             <artifactId>javassist</artifactId>
    21.             <version>3.29.1-GA</version>
    22.         </dependency>
    23.         <!--junit依赖-->
    24.         <dependency>
    25.             <groupId>junit</groupId>
    26.             <artifactId>junit</artifactId>
    27.             <version>4.13.2</version>
    28.             <scope>test</scope>
    29.         </dependency>
    30.     </dependencies>
    31. </project>

    下面是几个javassist基本使用的demo

    1. import javassist.*;
    2.  
    3. import java.io.File;
    4. import java.lang.reflect.Method;
    5. import java.net.URL;
    6. import java.net.URLClassLoader;
    7.  
    8. /**
    9.  * @author hrui
    10.  * @date 2023/9/17 18:05
    11.  */
    12. public class Test {
    13.  
    14.  
    15.     @org.junit.Test
    16.     public void test03() throws Exception {
    17.         // 获取类池,这个类池就是用来生成class的
    18.         ClassPool pool = ClassPool.getDefault();
    19.         // 制造类(需要告诉javassist,类名是啥)
    20.         CtClass ctClass = pool.makeClass("com.example.javassist.Test");//在内存中
    21.  
    22.         //制造方法
    23.         String methodCode="public void insert(){System.out.println(\"Hello World\");}";
    24.         CtMethod ctMethod=CtMethod.make(methodCode,ctClass);
    25.  
    26.         // 给类添加⽅法
    27.         ctClass.addMethod(ctMethod);
    28.         //写入磁盘
    29.         ctClass.writeFile("src/main/java/");
    30.  
    31.  
    32.         //还可以这样   下面是可以加载到的,加载不到原因可能是我当时没有放到测试目录
    33. //      Class<?> aClass = Class.forName("com.example.javassist.Test");//这样加载不到类
    34.         //用自定义类加载器
    35.         ClassLoader customClassLoader = new URLClassLoader(new URL[]{new File("src/main/java/").toURI().toURL()});
    36.         Class<?> aClass = customClassLoader.loadClass("com.example.javassist.Test");
    37.         Object instance = aClass.newInstance();
    38.         // 调用生成的方法
    39.         Method method = aClass.getDeclaredMethod("insert");
    40.         method.invoke(instance);
    41.  
    42.     }
    43.     @org.junit.Test
    44.     public void test02() throws Exception {
    45.         // 获取类池,这个类池就是用来生成class的
    46.         ClassPool pool = ClassPool.getDefault();
    47.         // 制造类(需要告诉javassist,类名是啥)
    48.         CtClass ctClass = pool.makeClass("com.example.javassist.Test");//在内存中
    49.         //制造方法
    50.         String methodCode="public void insert(){System.out.println(123);}";
    51.         CtMethod ctMethod=CtMethod.make(methodCode,ctClass);
    52.  
    53.         // 给类添加⽅法
    54.         ctClass.addMethod(ctMethod);
    55.  
    56.         // 用反射调⽤⽅法  这样是内存中直接调用
    57.         Class<?> aClass = ctClass.toClass();
    58.         Object o = aClass.newInstance();
    59.         Method method = aClass.getDeclaredMethod("insert");
    60.         method.invoke(o);
    61.     }
    62.  
    63.  
    64.     @org.junit.Test
    65.     public void test01() throws Exception {
    66.         // 获取类池,这个类池就是用来生成class的
    67.         ClassPool pool = ClassPool.getDefault();
    68.         // 制造类(需要告诉javassist,类名是啥)
    69.         CtClass ctClass = pool.makeClass("com.example.javassist.Test");//在内存中
    70.         // 制造⽅法
    71.         // 1.返回值类型 2.⽅法名 3.形式参数列表 4.所属类
    72.         CtMethod ctMethod = new CtMethod(CtClass.voidType, "insert", new
    73.                 CtClass[]{}, ctClass);
    74.         // 设置⽅法的修饰符列表
    75.         ctMethod.setModifiers(Modifier.PUBLIC);
    76.         // 设置⽅法体
    77.         ctMethod.setBody("{System.out.println(\"hello world\");}");
    78.  
    79.         // 给类添加⽅法
    80.         ctClass.addMethod(ctMethod);
    81.  
    82.         // 用反射调⽤⽅法  这样是内存中直接调用
    83.         Class<?> aClass = ctClass.toClass();
    84.         Object o = aClass.newInstance();
    85.         Method method = aClass.getDeclaredMethod("insert");
    86.         method.invoke(o);
    87.     }
    88. }

    因本机安装的是JDK8,没有报错,将高版本报错情况记录下来,以便以后用高版本JDK遇到类似问题,方便解决

    解决办法

    两个参数
    --add-opens java.base/java.lang=ALL-UNNAMED
    --add-opens java.base/sun.net.util=ALL-UNNAMED
    如果第一次用可能不能设置参数,如下点击设置
    高版本JDK遇到如上问题,记得仔细配置,可能第一次配置完还是有错,记得仔细检查,重新配置一次

    设想一个问题  既然这样的话,能不能用javassist动态设计一个类,然后实现DAO接口呢

    1. @org.junit.Test
    2.     public void testGenerateImpl() throws Exception {
    3.         //获取类池
    4.         ClassPool pool = ClassPool.getDefault();
    5.         //制造类
    6.         CtClass ctClassImpl = pool.makeClass("com.example.javassist.TestImpl");//在内存中
    7.         //制造接口
    8.         CtClass ctClassInterface = pool.makeInterface("com.example.javassist.Test1");//在内存中
    9.         //类去实现接口  又可以说是类去添加接口
    10.         ctClassImpl.addInterface(ctClassInterface);//TestImpl implements Test1
    11.         //去实现接口中的方法 这个相对比较复杂,这里我们假设接口里就一个方法
    12.  
    13.         //先制造方法
    14.         CtMethod ctMethod=CtMethod.make("public void delete(){System.out.println(\"删除成功!\");}",ctClassImpl);
    15.         //将方法添加到类中
    16.         ctClassImpl.addMethod(ctMethod);
    17.  
    18.         //在内存中生成类(这一步JVM已经将类加载到内存中)
    19.         Class<?> aClass = ctClassImpl.toClass();
    20.         Test1 test=(Test1)aClass.newInstance();
    21.         test.delete();
    22.  
    23.     }

    上面方法示例可见,我们是有办法动态生成接口实现类的

    上面方法演示过于简单

    比如说

    下面使用javassist动态生成实现类并实现接口中所有方法

    1.  @org.junit.Test
    2.     public void testGenerateImpl2(){
    3.         //获取类池
    4.         ClassPool pool = ClassPool.getDefault();
    5.         //制造类
    6.         CtClass ctClassImpl = pool.makeClass("com.example.javassist.TestImpl2");//在内存中
    7.         //制造接口
    8.         CtClass ctClassInterface = pool.makeInterface("com.example.javassist.Test1");//在内存中
    9.         //类去实现接口  又可以说是类去添加接口
    10.         ctClassImpl.addInterface(ctClassInterface);//TestImpl2 implements Test1
    11.         //实现接口中所有方法
    12.         //先获取接口中的所有方法
    13.         Method[] declaredMethods = Test1.class.getDeclaredMethods();
    14.         //System.out.println(declaredMethods.length);
    15.         //System.out.println(Arrays.toString(declaredMethods));
    16.         Arrays.stream(declaredMethods).forEach(method -> {
    17.             //method是接口中的抽象方法,我们需要把抽象方法实现了
    18.             try {
    19.                 //methodCode public void delete(){}
    20.                 //methodCode public int update(String actno,double balance)
    21.                 StringBuilder methodCode=new StringBuilder();
    22.                 methodCode.append("public ");
    23.                 methodCode.append(method.getReturnType().getName()+" ");//返回值类型
    24.                 methodCode.append(method.getName());//追加方法名
    25.                 methodCode.append("(");
    26.  
    27.                 Class<?>[] parameterTypes = method.getParameterTypes();//参数有可能1个也可能有多个
    28.                 for(int i=0;i<parameterTypes.length;i++){
    29.                     Class<?> parameterType = parameterTypes[i];//第一个参数的类型
    30.                     methodCode.append(parameterType.getName());//参数类型
    31.                     methodCode.append(" ");
    32.                     methodCode.append("arg"+i);//参数名
    33.  
    34.                     if(i!=(parameterTypes.length-1)) {
    35.                         methodCode.append(",");//如果不是最后一个参数
    36.                     }
    37.                 }
    38.  
    39.                 methodCode.append("){System.out.println(\"Hello World\");}");
    40.                 System.out.println(methodCode);
    41.  
    42.                 //CtMethod ctMethod=CtMethod.make(methodCode.toString(),ctClassImpl);
    43.                 //将方法添加到类中
    44.                 //ctClassImpl.addMethod(ctMethod);
    45.             } catch (Exception e) {
    46.                 e.printStackTrace();
    47.             }
    48.         });
    49.     }

    程序写到这部  先执行一下

    public int update(java.lang.String arg0,double arg1){System.out.println("Hello World");}
    public void delete(){System.out.println("Hello World");}
    public int insert(java.lang.String arg0){System.out.println("Hello World");}
    public java.lang.String selectByActno(java.lang.String arg0){System.out.println("Hello World");}

    接下来就是关于返回值的问题

    1.   @org.junit.Test
    2.     public void testGenerateImpl2() throws IllegalAccessException, InstantiationException, CannotCompileException {
    3.         //获取类池
    4.         ClassPool pool = ClassPool.getDefault();
    5.         //制造类
    6.         CtClass ctClassImpl = pool.makeClass("com.example.javassist.TestImpl2");//在内存中
    7.         //制造接口
    8.         CtClass ctClassInterface = pool.makeInterface("com.example.javassist.Test1");//在内存中
    9.         //类去实现接口  又可以说是类去添加接口
    10.         ctClassImpl.addInterface(ctClassInterface);//TestImpl2 implements Test1
    11.         //实现接口中所有方法
    12.         //先获取接口中的所有方法
    13.         Method[] declaredMethods = Test1.class.getDeclaredMethods();
    14.         //System.out.println(declaredMethods.length);
    15.         //System.out.println(Arrays.toString(declaredMethods));
    16.         Arrays.stream(declaredMethods).forEach(method -> {
    17.             //method是接口中的抽象方法,我们需要把抽象方法实现了
    18.             try {
    19.                 //methodCode public void delete(){}
    20.                 //methodCode public int update(String actno,double balance)
    21.                 StringBuilder methodCode=new StringBuilder();
    22.                 methodCode.append("public ");
    23.                 methodCode.append(method.getReturnType().getName()+" ");//返回值类型
    24.                 methodCode.append(method.getName());//追加方法名
    25.                 methodCode.append("(");
    26.  
    27.                 Class<?>[] parameterTypes = method.getParameterTypes();//参数有可能1个也可能有多个
    28.                 for(int i=0;i<parameterTypes.length;i++){
    29.                     Class<?> parameterType = parameterTypes[i];//第一个参数的类型
    30.                     methodCode.append(parameterType.getName());//参数类型
    31.                     methodCode.append(" ");
    32.                     methodCode.append("arg"+i);//参数名
    33.  
    34.                     if(i!=(parameterTypes.length-1)) {
    35.                         methodCode.append(",");//如果不是最后一个参数
    36.                     }
    37.                 }
    38.  
    39.                 methodCode.append("){System.out.println(\"Hello World\");");
    40.                 //动态添加renturn语句
    41.                 String simpleName = method.getReturnType().getSimpleName();//比如  int void  String
    42.                 if("void".equals(simpleName)){
    43.                     //如果是void啥都不写
    44.                 }else if("int".equals(simpleName)){
    45.                     methodCode.append("return 1;");
    46.                 }else if("String".equals(simpleName)){
    47.                     methodCode.append("return \"1\";");
    48.                 }
    49.                 //System.out.println(simpleName);
    50.                 methodCode.append("}");
    51.                 System.out.println(methodCode);
    52.  
    53.                 CtMethod ctMethod=CtMethod.make(methodCode.toString(),ctClassImpl);
    54.                 //将方法添加到类中
    55.                 ctClassImpl.addMethod(ctMethod);
    56.             } catch (Exception e) {
    57.                 e.printStackTrace();
    58.             }
    59.         });
    60.         //在内存中生成类(这一步JVM已经将类加载到内存中)
    61.         Class<?> aClass = ctClassImpl.toClass();
    62.         Test1 test=(Test1)aClass.newInstance();
    63.         test.delete();
    64.         int count = test.insert("sad");
    65.         test.update("sad",1.1);
    66.         
    67.  
    68.     }

    上面方式虽然实现的比较low,主要为说明Mybatis底层javassist的使用

    下面对

    Mybatis学习笔记3 在Web中应用Mybatis_biubiubiu0706的博客-CSDN博客

    中的项目进行修改,就是说AccountDaoImpl不写了

    mybatis-03中只引入了mybatis依赖,但是可以直接使用ClassPool,而这个类是javassist的,原因是mybatis对javassist进行了封装

    下面这段代码就是大概性的介绍Mybatis内部的一种封装    

    1. package com.example.utils;
    2.  
    3. import org.apache.ibatis.javassist.ClassPool;
    4. import org.apache.ibatis.javassist.CtClass;
    5. import org.apache.ibatis.javassist.CtMethod;
    6. import org.apache.ibatis.mapping.SqlCommandType;
    7. import org.apache.ibatis.session.SqlSession;
    8.  
    9. import java.lang.reflect.Method;
    10. import java.util.Arrays;
    11.  
    12. /**
    13.  * 工具类：可以动态的生成DAO的实现类。（或者说可以动态生成DAO的代理类）
    14.  * 注意注意注意注意注意！！！！！！：
    15.  *      凡是使用GenerateDaoProxy的，SQLMapper.xml映射文件中namespace必须是dao接口的全名，id必须是dao接口中的方法名。
    16.  */
    17. public class GenerateDaoProxy { // GenerateDaoProxy是mybatis框架的开发者写的。
    18.  
    19.     /**
    20.      * 生成dao接口实现类，并且将实现类的对象创建出来并返回。
    21.      * @param daoInterface dao接口
    22.      * @return dao接口实现类的实例化对象。
    23.      */
    24.     public static Object generate(SqlSession sqlSession, Class daoInterface){
    25.         // 类池
    26.         ClassPool pool = ClassPool.getDefault();
    27.         // 制造类(com.powernode.bank.dao.AccountDao --> com.powernode.bank.dao.AccountDaoProxy)
    28.         CtClass ctClass = pool.makeClass(daoInterface.getName() + "Proxy"); // 实际本质上就是在内存中动态生成一个代理类。
    29.         // 制造接口
    30.         CtClass ctInterface = pool.makeInterface(daoInterface.getName());
    31.         // 实现接口
    32.         ctClass.addInterface(ctInterface);
    33.         // 实现接口中所有的方法
    34.         Method[] methods = daoInterface.getDeclaredMethods();
    35.         Arrays.stream(methods).forEach(method -> {
    36.             // method是接口中的抽象方法
    37.             // 将method这个抽象方法进行实现
    38.             try {
    39.                 // Account selectByActno(String actno);
    40.                 // public Account selectByActno(String actno){ 代码; }
    41.                 StringBuilder methodCode = new StringBuilder();
    42.                 methodCode.append("public ");
    43.                 methodCode.append(method.getReturnType().getName());
    44.                 methodCode.append(" ");
    45.                 methodCode.append(method.getName());
    46.                 methodCode.append("(");
    47.                 // 需要方法的形式参数列表
    48.                 Class<?>[] parameterTypes = method.getParameterTypes();
    49.                 for (int i = 0; i < parameterTypes.length; i++) {
    50.                     Class<?> parameterType = parameterTypes[i];
    51.                     methodCode.append(parameterType.getName());
    52.                     methodCode.append(" ");
    53.                     methodCode.append("arg" + i);
    54.                     if(i != parameterTypes.length - 1){
    55.                         methodCode.append(",");
    56.                     }
    57.                 }
    58.                 methodCode.append(")");
    59.                 methodCode.append("{");
    60.                 // 需要方法体当中的代码
    61.                 methodCode.append("org.apache.ibatis.session.SqlSession sqlSession = com.example.utils.SqlSessionUtil.openSession();");
    62.                 // 需要知道是什么类型的sql语句
    63.                 // sql语句的id是框架使用者提供的，具有多变性。对于我框架的开发人员来说。我不知道。
    64.                 // 既然我框架开发者不知道sqlId，怎么办呢？mybatis框架的开发者于是就出台了一个规定：凡是使用GenerateDaoProxy机制的。
    65.                 // sqlId都不能随便写。namespace必须是dao接口的全限定名称。id必须是dao接口中方法名。
    66.                 String sqlId = daoInterface.getName() + "." + method.getName();
    67.                 SqlCommandType sqlCommandType = sqlSession.getConfiguration().getMappedStatement(sqlId).getSqlCommandType();
    68.                 if (sqlCommandType == SqlCommandType.INSERT) {
    69.  
    70.                 }
    71.                 if (sqlCommandType == SqlCommandType.DELETE) {
    72.  
    73.                 }
    74.                 if (sqlCommandType == SqlCommandType.UPDATE) {
    75.                     methodCode.append("return sqlSession.update(\""+sqlId+"\", arg0);");
    76.                 }
    77.                 if (sqlCommandType == SqlCommandType.SELECT) {
    78.                     String returnType = method.getReturnType().getName();
    79.                     methodCode.append("return ("+returnType+")sqlSession.selectOne(\""+sqlId+"\", arg0);");
    80.                 }
    81.  
    82.                 methodCode.append("}");
    83.                 CtMethod ctMethod = CtMethod.make(methodCode.toString(), ctClass);
    84.                 ctClass.addMethod(ctMethod);
    85.             } catch (Exception e) {
    86.                 e.printStackTrace();
    87.             }
    88.  
    89.         });
    90.  
    91.         // 创建对象
    92.         Object obj = null;
    93.         try {
    94.             Class<?> clazz = ctClass.toClass();
    95.             obj = clazz.newInstance();
    96.         } catch (Exception e) {
    97.             e.printStackTrace();
    98.         }
    99.         return obj;
    100.     }
    101.  
    102. }

    那么业务层就可以这么写

    上面这步,出了点错,写完时候还没查出来

    其实这个封装Mybatis已经做好了

    这样,面向接口的CRUD就产生了,以后无需再写持久层的实现类

    完整的SqlSessionUtil类

    1. package com.example.utils;
    2.  
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSession;
    5. import org.apache.ibatis.session.SqlSessionFactory;
    6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    7.  
    8. import java.io.IOException;
    9.  
    10. /**
    11.  * @author hrui
    12.  * @date 2023/9/8 14:55
    13.  */
    14. public class SqlSessionUtil {
    15.  
    16.     //工具类的构造方法一般都是私有化
    17.     //方法都是静态的
    18.     //为了防止new对象,构造方法私有化
    19.     private SqlSessionUtil(){
    20.  
    21.     }
    22.     private static SqlSessionFactory sqlSessionFactory;
    23.  
    24.     //类加载时候执行
    25.     //SqlSessionUtil工具类在被加载的时候,解析mybatis-config1.xml.创建sqlSessionFactory对象
    26.     static{
    27.         try {
    28.             //SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
    29.             //下面这么写的原因是SqlSessionFactoryBuilder就是为了创建sqlSessionFactory而来的,使用完后,就不需要,都不需要创建个局部变量
    30.             //一个sqlSessionFactory对应一个数据库
    31.             sqlSessionFactory= new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config1.xml"));
    32.         } catch (IOException e) {
    33.             e.printStackTrace();
    34.         }
    35.     }
    36.  
    37.     //全局的 服务器级别的,一个服务器当中定义一个即可
    38.     private static ThreadLocal<SqlSession> local=new ThreadLocal<>();
    39.  
    40.     //获取会话对象 返回会话对象
    41.     public static SqlSession openSession(){
    42.         SqlSession sqlSession=local.get();
    43.         if(sqlSession==null){
    44.             sqlSession = sqlSessionFactory.openSession();
    45.             local.set(sqlSession);
    46.         }
    47.  
    48.         return sqlSession;
    49.     }
    50.  
    51.     //提供一个关闭的方法
    52.     public static void close(SqlSession sqlSession){
    53.         if(sqlSession!=null){
    54.             //因为核心配置文件中配置POOLED  这里关闭是交还给连接池
    55.             sqlSession.close();
    56.             //注意移除SqlSession对象和当前线程的绑定关系
    57.             //因为Tomcat服务器支持线程池 比如说t1线程用完了,close交还给连接池了,这个sqlSession属于不可用的状态,你没有remove出去 如果t2线程拿到了,那么这个sqlSession不可用
    58.             local.remove();
    59.         }
    60.     }
    61. }

  • 相关阅读:
    [machineLearning]非监督学习unsupervised learning
    K8S架构常用组件核心资源
    valid ready握手无气泡
    盘点年度最佳10大顶级绘图软件，满足你99%的图表需求，赶紧收藏
    【3】Spring Boot 3 集成mybatis-plus+druid+mysql
    Idea提升工作效率的必备技巧
    商简智能：世界领先的高级计划与排程APS供应商
    BEV经典之作Lift, Splat, Shoot解析
    Nginx显示500错误原因和解决方法
    Windowsold文件夹作用以及删除方法
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/132948303