【Java】Javassist动态生成硬编码实现ORM

已于 2022-02-16 11:26:15 修改
阅读量289 收藏 2
点赞数
文章标签： java sql 数据库 javassist
于 2022-02-16 11:16:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Passer_hua/article/details/122956417
版权

目录

  1. 第一版：简单实现
  2. 第二版：将封装过程提取出来
  3. 第三版：通过注解+反射实现
  4. 第四版：通过注解+反射+泛型实现所有entity类的封装
  5. 第五版：Javassist动态生成字节码，达到与第一版硬编码实现的效率
    需求介绍
CREATE TABLE `t_user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=24563 DEFAULT CHARSET=utf8mb4;

-- 可重复执行该语句以达到足够的数据量，我的表里有20万条数据
INSERT INTO `t_user`(`user_name`, `password`) SELECT user_name,`password` FROM t_user

select * from t_user limit 20000

/**
 * 用户实体
 */
public class UserEntity {
    /**
     * 用户 Id
     */
    public int _userId;

    /**
     * 用户名
     */
    public String _userName;

    /**
     * 密码
     */
    public String _password;
}

查询t_user并封装成UserEntity。这就是ORM(对象关系映射)

程序用到了两个依赖javassist会在后面的版本中使用到。

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.12.1.GA</version>
        </dependency>
    </dependencies>

第一版：简单实现

这一版就是sql执行的结果循环遍历通过硬编码的形式封装成UserEntity对象

package org.ormtest.step000;
import org.ormtest.step000.entity.UserEntity;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class App000 {
    static public void main(String[] argvArray) throws Exception {
        (new App000()).start();
    }
    
    private void start() throws Exception {
        // 加载 Mysql 驱动
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();
        // 数据库连接地址
        String dbConnStr = "jdbc:mysql://127.0.0.1:3306/ormtest?useAffectedRows=true&serverTimezone=Asia/Shanghai";
        // 创建数据库连接
        Connection conn = DriverManager.getConnection(dbConnStr,"root","123456");
        // 简历陈述对象
        Statement stmt = conn.createStatement();

        // 创建 SQL 查询
        String sql = "select * from t_user limit 20000";

        // 执行查询
        ResultSet rs = stmt.executeQuery(sql);

        // 获取开始时间
        long t0 = System.currentTimeMillis();

        while (rs.next()) {
            // 创建新的实体对象
            UserEntity ue = new UserEntity();

            ue._userId = rs.getInt("user_id");
            ue._userName = rs.getString("user_name");
            ue._password = rs.getString("password");
            //
            // 关于上面这段代码,
            // 我们是否可以将其封装到一个助手类里??
            // 这样做的好处是:
            // 当实体类发生修改时, 只需要改助手类就可以了...
            //
        }

        // 获取结束时间
        long t1 = System.currentTimeMillis();

        // 关闭数据库连接
        stmt.close();
        conn.close();

        // 打印实例化花费时间
        System.out.println("实例化花费时间 = " + (t1 - t0) + "ms");
    }
}

输出结果

实例化花费时间 = 31ms

第二版：将封装过程提取出来

package org.ormtest.step010;

import org.ormtest.step010.entity.UserEntity;
import org.ormtest.step010.entity.UserEntity_Helper;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class App010 {
    static public void main(String[] argvArray) throws Exception {
        (new App010()).start();
    }

    /**
     * 测试开始
     */
    private void start() throws Exception {
        // 加载 Mysql 驱动
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();
        // 数据库连接地址
        String dbConnStr = "jdbc:mysql://127.0.0.1:3306/ormtest?user=root&password=123456&serverTimezone=Asia/Shanghai";
        // 创建数据库连接
        Connection conn = DriverManager.getConnection(dbConnStr);
        // 简历陈述对象
        Statement stmt = conn.createStatement();

        // 创建 SQL 查询
        String sql = "select * from t_user limit 20000";

        // 执行查询
        ResultSet rs = stmt.executeQuery(sql);

        // 创建助手类
        UserEntity_Helper helper = new UserEntity_Helper();

        // 获取开始时间
        long t0 = System.currentTimeMillis();

        while (rs.next()) {
            // 创建新的实体对象,
            // 这里已经把创建过程封装到助手类中了...
            // 这么做的好处 step000 中已经提到过了
            UserEntity ue = helper.create(rs);
        }

        // 获取结束时间
        long t1 = System.currentTimeMillis();

        // 关闭数据库连接
        stmt.close();
        conn.close();

        // 打印实例化花费时间
        System.out.println("实例化花费时间 = " + (t1 - t0) + "ms");
    }
}

UserEntity_Helper类

package org.ormtest.step010.entity;

import java.sql.ResultSet;

/**
 * 用户实体助手类
 */
public class UserEntity_Helper {
    /**
     * 将数据集装换为实体对象
     *
     * @param rs 数据集
     * @return
     * @throws Exception
     */
    public UserEntity create(ResultSet rs) throws Exception {
        if (null == rs) {
            return null;
        }

        // 创建新的实体对象
        UserEntity ue = new UserEntity();

        ue._userId = rs.getInt("user_id");
        ue._userName = rs.getString("user_name");
        ue._password = rs.getString("password");
        //
        // 都是硬编码会不会很累?
        // 而且要是 UserEntity 和 t_user 加字段,
        // 还得改代码...
        // 为何不尝试一下反射?
        return ue;
    }
}

这一版将写在主程序里的封装对象的逻辑提取到了一个Helper类中，这样主程序就不用修改了，只需要修改Helper类。
然后我们来考虑一下硬编码的问题。如果t_user新增字段还是得每次都修改Helper类，这种设计就不够方便。

第三版：通过注解+反射实现

定义一注解类

/**
 * 数据表中的列
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    /**
     * 列名称
     *
     * @return
     */
    String name();
}

修改实体类加上注解

package org.ormtest.step020.entity;

/**
 * 用户实体
 */
public class UserEntity {
    /**
     * 用户 Id
     */
    @Column(name = "user_id")
    public int _userId;

    /**
     * 用户名
     */
    @Column(name = "user_name")
    public String _userName;

    /**
     * 密码
     */
    @Column(name = "password")
    public String _password;
}

修改Helper类

package org.ormtest.step020.entity;

import java.lang.reflect.Field;
import java.sql.ResultSet;

/**
 * 用户实体助手类
 */
public class UserEntity_Helper {
    /**
     * 将数据集装换为实体对象
     *
     * @param rs 数据集
     * @return
     * @throws Exception
     */
    public UserEntity create(ResultSet rs) throws Exception {
        if (null == rs) {
            return null;
        }
        
        // 创建新的实体对象
        UserEntity ue = new UserEntity();

        // 获取类的字段数组
        Field[] fArray = ue.getClass().getFields();

        for (Field f : fArray) {
            // 获取字段上注解
            Column annoColumn = f.getAnnotation(Column.class);

            if (annoColumn == null) {
                // 如果注解为空,
                // 则直接跳过...
                continue;
            }

            // 获取列名称
            String colName = annoColumn.name();
            // 从数据库中获取列值
            Object colVal = rs.getObject(colName);

            if (colVal == null) {
                // 如果列值为空,
                // 则直接跳过...
                continue;
            }

            // 设置字段值
            f.set(ue, colVal);
        }

        return ue;
    }
}

通过反射就实现了t_user可以随意添加字段，只要在UserEntity类加上对应的注解就可以了，无需修改Helper类。但还是不够通用，接下来就使用泛型来实现ORM

第四版：通过注解+反射+泛型实现所有entity类的封装

Helper修改为XxxEntity_Helper。 简单来说就是将需要封装的类型通过外部传入，然后create()方法就将结果封装成传入的类型即可。

package org.ormtest.step030.entity;

import java.lang.reflect.Field;
import java.sql.ResultSet;

/**
 * 实体助手类, 这个更通用
 */
public class XxxEntity_Helper {
    /**
     * 将数据集装换为实体对象
     *
     * @param entityClazz 实体类
     * @param rs          数据集
     * @param <TEntity>   实体类
     * @return
     * @throws Exception
     */
    public <TEntity> TEntity create(Class<TEntity> entityClazz, ResultSet rs) throws Exception {
        if (null == rs) {
            return null;
        }

        //
        // 更通用的助手类,
        // 甭管实体类是哪个, 也甭管实体类有多少属性,
        // 全灭!
        // 但是,
        // 就是性能太差了...
        //
        // 创建新的实体对象
        Object newEntity = entityClazz.newInstance();

        // 获取类的字段数组
        Field[] fArray = entityClazz.getFields();

        for (Field f : fArray) {
            // 获取字段上注解
            Column annoColumn = f.getAnnotation(Column.class);

            if (annoColumn == null) {
                // 如果注解为空,
                // 则直接跳过...
                continue;
            }

            // 获取列名称
            String colName = annoColumn.name();
            // 从数据库中获取列值
            Object colVal = rs.getObject(colName);

            if (colVal == null) {
                // 如果列值为空,
                // 则直接跳过...
                continue;
            }

            // 设置字段值
            f.set(newEntity, colVal);
        }

        return (TEntity) newEntity;
    }
}

package org.ormtest.step030;

import org.ormtest.step030.entity.UserEntity;
import org.ormtest.step030.entity.XxxEntity_Helper;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * 主应用程序类
 */
public class App030 {
    /**
     * 应用程序主函数
     *
     * @param argvArray 参数数组
     * @throws Exception
     */
    static public void main(String[] argvArray) throws Exception {
        (new org.ormtest.step030.App030()).start();
    }

    /**
     * 测试开始
     */
    private void start() throws Exception {
        // 加载 Mysql 驱动
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();
        // 数据库连接地址
        String dbConnStr = "jdbc:mysql://localhost:3306/ormtest?user=root&password=123456&serverTimezone=Asia/Shanghai";
        // 创建数据库连接
        Connection conn = DriverManager.getConnection(dbConnStr);
        // 简历陈述对象
        Statement stmt = conn.createStatement();

        // 创建 SQL 查询
        String sql = "select * from t_user limit 20000";

        // 执行查询
        ResultSet rs = stmt.executeQuery(sql);
        // 创建助手类
        XxxEntity_Helper helper = new XxxEntity_Helper();

        // 获取开始时间
        long t0 = System.currentTimeMillis();

        while (rs.next()) {
            // 创建新的实体对象
            UserEntity ue = helper.create(UserEntity.class, rs);
        }

        // 获取结束时间
        long t1 = System.currentTimeMillis();

        // 关闭数据库连接
        stmt.close();
        conn.close();

        // 打印实例化花费时间
        System.out.println("实例化花费时间 = " + (t1 - t0) + "ms");
        // 注意: 到这里运行时间翻倍了!
        // 利用反射确实可以获得良好的通用性,
        // 但是却损失了性能...
    }
}

输出结果

实例化花费时间 = 71ms

通用性好了但是运行时间翻倍了！这也不是一个好的设计。

第五版：Javassist动态生成字节码，达到与第一版硬编码实现的效率

优化思路：硬编码的效率高，那我们就使用Javassist生成硬编码。
定义抽象的Helper类

package org.ormtest.step050.entity;
import java.sql.ResultSet;
/**
 * 抽象的实体助手
 */
public abstract class AbstractEntityHelper {
    /**
     * 将数据集转换为实体对象
     *
     * @param rs 数据集
     * @return
     *
     */
    public abstract Object create(ResultSet rs);
}

用来生成EntityHelper的工厂类

package org.ormtest.step050.entity;

import javassist.*;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;

/**
 * 实体助手工厂
 */
public final class EntityHelperFactory {
    /**
     * 助手字典
     */
    private static final Map<Class<?>, AbstractEntityHelper> _entityHelperMap = new HashMap<>();

    /**
     * 私有化类默认构造器
     */
    private EntityHelperFactory() {
    }

    /**
     * 获取帮助
     *
     * @param entityClazz 实体类
     * @return 实体助手
     * @throws Exception
     */
    public static AbstractEntityHelper getEntityHelper(Class<?> entityClazz) throws Exception {
        if (null == entityClazz) {
            // 如果参数对象为空,
            // 则直接退出!
            return null;
        }

        // 获取帮助对象
        AbstractEntityHelper helperObj = _entityHelperMap.get(entityClazz);

        if (helperObj != null) {
            // 如果帮助对象不为空,
            // 则直接返回!
            return helperObj;
        }

// 使用 Javassist 动态生成 Java 字节码
///
        //
        // 获取类池
        ClassPool pool = ClassPool.getDefault();
        pool.appendSystemPath();

        //
        // 导入相关类, 生成以下代码:
        // import java.sql.ResultSet
        // import org.ormtest.entity.UserEntity
        // import ...
        pool.importPackage(ResultSet.class.getName());
        pool.importPackage(entityClazz.getName());

        // 抽象的助手类
        CtClass abstractEntityHelperClazz = pool.getCtClass(AbstractEntityHelper.class.getName());
        // 助手实现类名称
        final String helperImplClazzName = entityClazz.getName() + "_Helper";

        //
        // 创建助手类, 会生成如下代码:
        // public class UserEntity_Helper extends AbstractEntityHelper { ...
        CtClass helperClazz = pool.makeClass(helperImplClazzName, abstractEntityHelperClazz);

        //
        // 创建默认构造器, 会生成如下代码:
        // public UserEntity_Helper() {}
        CtConstructor constructor = new CtConstructor(new CtClass[0], helperClazz);
        // 空函数体
        constructor.setBody("{}");
        // 添加默认构造器
        helperClazz.addConstructor(constructor);

        // 用于创建函数代码字符串
        final StringBuffer sb = new StringBuffer();
        // 添加一个函数, 也就是实现抽象类中的 create 函数
        sb.append("public Object create(java.sql.ResultSet rs) throws Exception {\n");
        // 生成以下代码:
        // UserEntity obj = new UserEntity();
        sb.append(entityClazz.getName())
            .append(" obj = new ")
            .append(entityClazz.getName())
            .append("();\n");

// 通过反射方式获取类的字段数组,
// 并生成代码
///
        //
        // 获取类的字段数组并生成代码
        Field[] fArr = entityClazz.getFields();

        for (Field f : fArr) {
            // 获取字段上注解
            Column annoColumn = f.getAnnotation(Column.class);

            if (annoColumn == null) {
                // 如果注解为空,
                // 则直接跳过...
                continue;
            }

            // 获取列名称
            String colName = annoColumn.name();

            if (f.getType() == Integer.TYPE) {
                // 生成如下代码:
                // obj._userId = rs.getInt("user_id");
                sb.append("obj.")
                    .append(f.getName())
                    .append(" = rs.getInt(\"")
                    .append(colName)
                    .append("\");\n");
            } else if (f.getType().equals(String.class)) {
                // 生成如下代码:
                // obj._userName = rs.getString("user_name");
                sb.append("obj.")
                    .append(f.getName())
                    .append(" = rs.getString(\"")
                    .append(colName)
                    .append("\");\n");
            } else {
                // 不支持的类型...
                // 如果需要支持 float、long、boolean 等类型,
                // 接着往下写就可以了
            }
        }

        sb.append("return obj;\n");
        sb.append("}");

        // 创建解析方法
        CtMethod cm = CtNewMethod.make(
            sb.toString(), helperClazz
        );
        // 添加方法
        helperClazz.addMethod(cm);
        // 调试文件
        helperClazz.writeFile("C:/Data/Temp+Test/debug-java");
        // 获取 Java 类
        Class<?> javaClazz = helperClazz.toClass();

// 创建帮助对象实例
///
        //
        // 创建帮助实例
        helperObj = (AbstractEntityHelper) javaClazz.newInstance();
        // 添加到字典
        _entityHelperMap.put(entityClazz, helperObj);

        return helperObj;
    }
}

使用

package org.ormtest.step050;

import org.ormtest.step050.entity.AbstractEntityHelper;
import org.ormtest.step050.entity.EntityHelperFactory;
import org.ormtest.step050.entity.UserEntity;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * 主应用程序类
 */
public class App050 {
    /**
     * 应用程序主函数
     *
     * @param argvArray 参数数组
     * @throws Exception
     */
    static public void main(String[] argvArray) throws Exception {
        (new App050()).start();
    }

    /**
     * 测试开始
     */
    private void start() throws Exception {
        // 加载 Mysql 驱动
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();
        // 数据库连接地址
        String dbConnStr = "jdbc:mysql://localhost:3306/ormtest?user=root&password=123456&serverTimezone=Asia/Shanghai";
        // 创建数据库连接
        Connection conn = DriverManager.getConnection(dbConnStr);
        // 简历陈述对象
        Statement stmt = conn.createStatement();

        // 创建 SQL 查询
        String sql = "select * from t_user limit 20000";

        // 执行查询
        ResultSet rs = stmt.executeQuery(sql);

        // 创建助手类, 这里采用全新设计的工厂类!
        AbstractEntityHelper helper = EntityHelperFactory.getEntityHelper(UserEntity.class);
        // 读懂上面这一行,
        // 恭喜你已经迈入架构师行列...
        

        // 获取开始时间
        long t0 = System.currentTimeMillis();

        while (rs.next()) {
            // 创建新的实体对象
            UserEntity ue = (UserEntity) helper.create(rs);
        }

        // 获取结束时间
        long t1 = System.currentTimeMillis();

        // 关闭数据库连接
        stmt.close();
        conn.close();

        // 打印赋值时间消耗
        System.out.println("赋值花费时间 = " + (t1 - t0) + "ms");
    }
}

输出结果

赋值花费时间 = 34ms

与第一版硬编码的运行时间几乎相同。

然后是调试文件,也就是javassist帮我们生成的字节码文件，可以看到与我们第二版封装的Helper几乎相同

package org.ormtest.step050.entity;

import java.sql.ResultSet;

public class UserEntity_Helper extends AbstractEntityHelper {
    public UserEntity_Helper() {
    }

    public Object create(ResultSet var1) throws Exception {
        UserEntity var2 = new UserEntity();
        var2._userId = var1.getInt("user_id");
        var2._userName = var1.getString("user_name");
        var2._password = var1.getString("password");
        return var2;
    }
}

总结

通过动态生成硬编码，既兼顾了反射的便利性，又保证了程序的性能。
这个思想在很多框架中都有使用到
如：jprotobuf，FastJson

第一次先反射一遍生成硬编码，之后再使用就一直都是硬编码了。这样的性能是非常好的。

果壳~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Javassist之一秒理解java动态编程
08-25
概述Javassist是一款字节码编辑工具,可以直接编辑和生成Java生成的字节码,以达到对.class文件进行动态修改的效果。
动态对象关系映射D-ORM
NIIT0532的专栏
08-23 288
与传统ORM（如Hibernate、Entity Framework等）相比，D-ORM可以在运行时根据用户需求和业务场景，动态生成和执行SQL，而无需编译或运行前预先定义好实体类和数据库表结构。也可以根据业务逻辑的需求动态地创建、修改或删除数据库表结构。这使得D-ORM更加灵活和适应性强，能够处理更加复杂和多变的数据持久化需求。
Java实现动态表单
zhuqiang12的博客
09-02 8970
前提 我们的业务上会有各种各样的表单，常规的开发是一个表单，我们一般会在数据库里面建立一个对应的表，然后在代码中建立一个model与之对应，一旦建立好以后，就不能再对表单进行修改了，如果需要修改，就需要修改数据库表，修改model重新发版上线，对于频繁需要表单变更的情况来说很不友好。那么有没有方法可以对现有表单的列进行增删改甚至动态生成一个表单呢？这样的话表单变动就不用发版重新上线了，岂不美哉。解决办法自然是有的。 方案 整体思路就是数据库行转列，在java层面动态生成VO返回给前台。...
Java逐步实现一个简单的ORM框架
Poldroc的博客
07-17 754
Java结合druid实现一个简单的ORM框架
通过表单设计器动态生成数据库表以及动态查询的功能实现
热门推荐
u011323025的博客
04-16 1万+
表单设计器动态生成数据库表以及动态查询的功能实现前言1. 功能实现1.1 效果说明1.2 功能流程图1.3 具体后端实现1.4 实现效果2. 尾声 前言 前两天主管安排了作为Java小码农的我实现一个功能需求。花了两天时间，理解了具体功能业务，并艰难的实现了接口。故记录一下此次开发的思路。 1. 功能实现 1.1 效果说明 项目是基于jeecg-boot的前后端分离项目，前端已有一个组件，叫动态表...
Java中自定义操作数据库，动态建表
ProBaiXiaodi的博客
09-28 2870
Java中自定义操作数据库，动态建表，非常简单省心
JavaAgent:Javassist 与 Asm JavaAgent 字节码动态编程项目
06-03
JavaAgent Javassist 与 Asm JavaAgent 字节码动态编程项目
基于javassist调用方法.zip_动态编码_快速反射
09-24
基于javassist的动态编码，快速调用某个类的方法，相比于JDK的反射调用更快
javaagent+javassist
12-25
环境JDK1.8 IDEA项目 javaagent+javassist 下载后导入即可
Javassist如何操作Java 字节码
09-07
主要介绍了Javassist如何操作Java 字节码，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
基于javassist进行动态编程过程解析
08-19
主要介绍了基于javassist进行动态编程过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
javassist+javaAgent探针, 实现jvm退出时打印线程栈日志
最新发布
03-22
javassist+javaAgent探针, 实现jvm退出时打印线程栈日志,方便排查是哪个线程调用了退出，以及退出码
java 反编译工具 jboss-javassist
09-02
能够实现java包的重写，分析，java程序的利器，不会的可以网上搜索相关使用方法，也可以留言求助。内含java包及demo，使用时直接引用java包即可。
javassist官方手册（中文）
09-12
javassist是一个动态生成字节码的框架，生成的字节码可以输出或实时加载到jvm。文档内容全面。
collection-agent:通过javaagent和javassist技术实现对java的ArrayList和HashMap的增强，避免在虚拟器一次load大量数据时导致OOM
06-14
通过javaagent和javassist技术实现对java的ArrayList和HashMap的增强，在操作集合元素时判断集合元素个数， 当集合元素个数大于设置的上限时，抛出异常，终止此次操作，从而避免在集合元素过大导致OOM. #使用方式： ...
Java动态增加实体类的属性
qq_11716的博客
02-15 5615
1、DynamicBean import org.springframework.cglib.beans.BeanGenerator; import org.springframework.cglib.beans.BeanMap; import java.util.Map; public class DynamicBean { /** * 目标对象 */ private Object target; /** * 属性集合 */
Spring boot 自动生成实体类代码
qq_45596062的博客
01-14 3128
Spring boot 自动生成实体类代码 1. 使用的是IDEA，其自带的生成实体类的脚本Generate POJOs.groovy比较简单，那么下面先看看自带的这个脚本怎么用。 当然也可以直接选择右侧边的Database 2. 这时会在右边弹出如下图的窗口，由于我这里已经添加过数据库了，第一次打开会提示使用Alt + Insert 进行添加数据库，我这里使用的是MySQL。 3. 填入你的数据库连接信息，点击下面的测试 4. 这边让设置时间，点击时间设置 时间同样设置为：Shanghai/As
有哪些方法可以在运行时动态生成一个Java类？
TimeFriends
03-14 770
更进一步，我们来看看 JDK dynamic proxy 的实现代码(http://hg.openjdk.java.net/jdk/jdk/file/29169633327c/src/java.base/share/classes/java/lang/reflect/Proxy.java)。你可以参考下面的示例代码。试想，假如我们有这样一个需求，需要添加某个功能，例如对某类型资源如网络通信的消耗进行统计，重点要求是，不开启时必须是零开销，而不是低开销，可以利用我们今天谈到的或者相关的技术实现吗？
数据库界的 Swagger，一键自动生成 Java 实体类和数据库文档！不讲武德！
芋艿V
12-17 3890
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 8:55 更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2020 超神之路...
java动态生成class文件怎么实现
04-20
具体实现可以使用Java内置的类库ASM或者开源项目Javassist，通过编写代码来生成类的属性和方法，并使用相应的API将其编译成class文件。此外，也可以使用Java动态编译器来实现动态生成class文件的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值