字节码增强工具bytekit封装使用

已于 2023-03-05 14:27:01 修改
阅读量523 收藏 1
点赞数 1
分类专栏： agent java 文章标签： java jvm spring
于 2023-03-02 13:35:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzl1369248650/article/details/129038326
版权
java 同时被 2 个专栏收录
46 篇文章 1 订阅
订阅专栏
agent
7 篇文章 0 订阅
订阅专栏

bytekit是阿里开源的字节码增强工具，可以很方便的提供字节码增强的api

pom

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>bytekit-core</artifactId>
            <version>0.0.4</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy-agent</artifactId>
            <version>1.10.18</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.benf</groupId>
            <artifactId>cfr</artifactId>
            <version>0.150</version>
            <optional>true</optional>
        </dependency>

工具类

import com.alibaba.bytekit.agent.inst.NewField;
import com.alibaba.bytekit.asm.MethodProcessor;
import com.alibaba.bytekit.asm.interceptor.InterceptorProcessor;
import com.alibaba.bytekit.asm.interceptor.annotation.InterceptorParserHander;
import com.alibaba.bytekit.asm.interceptor.parser.DefaultInterceptorClassParser;
import com.alibaba.bytekit.utils.AsmUtils;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.alibaba.deps.org.objectweb.asm.Type;
import com.alibaba.deps.org.objectweb.asm.tree.AnnotationNode;
import com.alibaba.deps.org.objectweb.asm.tree.ClassNode;
import com.alibaba.deps.org.objectweb.asm.tree.FieldNode;
import com.alibaba.deps.org.objectweb.asm.tree.MethodNode;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class EnhanceUtil {

    private static final String CONSTRUCT_MATCH_METHOD = "constructMatch";

    private static final String STATIC_MATCH_METHOD = "staticMatch";

    private static final String METHOD_MATCH_METHOD = "methodMatch";

    public static byte[] enhanceClass(byte[] bytes, Class interceptorClass,ClassLoader classLoader) throws Exception {
        // 初始化Instrumentation
//        AgentUtils.install();

        // 解析定义的 Interceptor类 和相关的注解
        DefaultInterceptorClassParser interceptorClassParser = new DefaultInterceptorClassParser();

        // 源文件字节码classNode
        ClassNode originClassNode = AsmUtils.toClassNode(bytes);

        //interceptor classNode
//        ClassNode apmClassNode = AsmUtils.loadClass(interceptorClass);
        ClassNode apmClassNode = getInterceptorClassNode(interceptorClass,classLoader);


        ClassNode targetClassNode = AsmUtils.copy(originClassNode);

        //把interceptor classNode 名称换成originClassNode 的名称
        byte[] renameClass = AsmUtils.renameClass(AsmUtils.toBytes(apmClassNode), Type.getObjectType(originClassNode.name).getClassName());

        apmClassNode = AsmUtils.toClassNode(renameClass);

        //添加@NewField 的字段
        List<FieldNode> fieldNodes = apmClassNode.fields;
        List<String> fieldMethodName = new ArrayList<>();
        if (fieldNodes != null){
            for (FieldNode fieldNode : fieldNodes){
                if (fieldNode.visibleAnnotations != null){
                    for( AnnotationNode annotationNode : fieldNode.visibleAnnotations) {

                        if(Type.getType(NewField.class).equals(Type.getType(annotationNode.desc))) {
                            String fieldName = fieldNode.name;
                            fieldName =  fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                            fieldMethodName.add("set"+fieldName);
                            fieldMethodName.add("get"+fieldName);
                            AsmUtils.addField(targetClassNode, fieldNode);
                        }

                    }
                }
            }
        }

        //添加字段的get set方法
        for (MethodNode methodNode : apmClassNode.methods){

            if (fieldMethodName.contains(methodNode.name)){
                AsmUtils.addMethod(targetClassNode,methodNode);
            }
        }

//        List<String> methodNameList = Arrays.asList(targetMethodNames);

        //根据注解解析出拦截器InterceptorProcessor
        List<InterceptorProcessor> processors = interceptorClassParser.parse(interceptorClass);
        // 对加载到的字节码做增强处理
        for (MethodNode methodNode : targetClassNode.methods) {

            Object flag = null;
            //构造函数
            if ("<init>".contains(methodNode.name)) {
                try {
                    Method method = interceptorClass.getMethod(CONSTRUCT_MATCH_METHOD,String.class);
                    flag = method.invoke(null,methodNode.desc);
                }catch (Throwable e){
                    System.err.println("get construct math method error");
                    e.printStackTrace();
                }
//                flag = byteKitInterceptor.constructMatch(methodNode.desc);
            }else if ("<clinit>".contains(methodNode.name)){
                //静态方法快
                try {
                    Method method = interceptorClass.getMethod(STATIC_MATCH_METHOD,String.class);
                    flag = method.invoke(null,methodNode.desc);
                }catch (Throwable e){
                    System.err.println("get static math method error");
                    e.printStackTrace();
                }

            } else {
                //方法
                try {
                    Method method = interceptorClass.getMethod(METHOD_MATCH_METHOD,String.class,String.class);
                    flag = method.invoke(null,methodNode.name,methodNode.desc);
                }catch (Throwable e){
                    System.err.println("get method math method error");
                    e.printStackTrace();
                }

//                flag = byteKitInterceptor.methodMatch(methodNode.name,methodNode.desc);
            }

            if (flag!= null && "true".equals(flag.toString())){
                MethodProcessor methodProcessor = new MethodProcessor(targetClassNode, methodNode);
                for (InterceptorProcessor interceptor : processors) {
                    System.out.println("----------------[SF Agent bytekit]EnhanceUtil interceptor className:"+targetClassNode.name +" method:"+methodNode.name +" methodDesc:"+methodNode.desc +" methodProcessor:"+methodProcessor.getMethodNode().name );
                    //生成拦截器代码
                    interceptor.process(methodProcessor);
                }
            }


//            if (methodNameList.contains(methodNode.name)) {
//                MethodProcessor methodProcessor = new MethodProcessor(targetClassNode, methodNode);
//                for (InterceptorProcessor interceptor : processors) {
//                    interceptor.process(methodProcessor);
//                }
//            }
        }

        ClassReader classReader = AsmUtils.toClassNode(bytes, originClassNode);
//        ClassReader classReader2 = new ClassReader(bytes);
//        System.out.println(classReader2);
        byte[] resutlBytes = AsmUtils.toBytes(targetClassNode,classLoader,classReader);
        // 获取增强后的字节码
        return resutlBytes;
    }


    private static ClassNode getInterceptorClassNode(Class interceptorClass,ClassLoader classLoader) throws Exception {


        String resource = interceptorClass.getName().replace('.', '/') + ".class";
//
//        String path = interceptorClass.getProtectionDomain().getCodeSource().getLocation().getFile();
//        JarFile jarFile = new JarFile(path);
//
//        JarEntry jarEntry = jarFile.getJarEntry(resource);
//        InputStream is = jarFile.getInputStream(jarEntry);

        ClassLoader interceptorClassClassLoader = interceptorClass.getClassLoader();
        if (interceptorClassClassLoader != null){
            return AsmUtils.loadClass(interceptorClass);
        }

//
        interceptorClassClassLoader = ClassLoader.getSystemClassLoader();
        InputStream is = interceptorClassClassLoader.getResourceAsStream(resource);
        ClassReader cr = new ClassReader(is);
        ClassNode classNode = new ClassNode();
        cr.accept(classNode, ClassReader.SKIP_FRAMES);
        return classNode;
    }

//    public static void main(String[] args) {
//        URL resource = ClassLoader.getSystemClassLoader().getResource("sun/net/www/http/HttpClient.class");
//        System.out.println(resource);
//    }
}

使用

BytekitTransformer 字节码增强入口类
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.Method;
import java.security.ProtectionDomain;
import java.util.*;


public class BytekitTransformer implements ClassFileTransformer,Runnable {


    private static Map<String, String> enhanceModels = new HashMap<>();

    private static Map<String, TransformerLoad> TransformerLoadMap = new HashMap<>();

    private static int delayStartRetransformTime = -1;

    static {
        //后面可以改成spi扩展的方式

        enhanceModels.put("org/apache/logging/log4j/core/layout/PatternLayout$Builder","bytekit.Log4j2ByteEnhance");
        enhanceModels.put("ch/qos/logback/core/pattern/PatternLayoutBase","bytekit.LogbackByteEnhance");
        enhanceModels.put("ch/qos/logback/classic/PatternLayout","bytekit.LogbackPatternByteEnhance");
//        enhanceModels.put("sun/net/www/protocol/http/HttpURLConnection","HttpUrlConnectionByteEnhance");
//        enhanceModels.put("java/net/HttpURLConnection","HttpUrlConnectionByteEnhance");
        // enhanceModels.put("sun/net/www/http/HttpClient","HttpUrlConnectionByteEnhance");

    }


    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        if (enhanceModels.containsKey(className)) {
            System.out.println("[bytekit] "+new Date()+" bytekitTransformer transform loader:"+loader+" className:"+className);
            String abstractByteEnhance;
            TransformerLoad transformerLoad = null;
            try {
                abstractByteEnhance = enhanceModels.get(className);

                Class abstractByteEnhanceCla = null;
                try {
                    if (loader == null){
                        loader = getClassLoader(abstractByteEnhance);
                    }

                    transformerLoad = getTransformerLoad(className,loader,abstractByteEnhance);

                    if (transformerLoad.getLoadCount() >0 ){
                        System.out.println("[ bytekit] "+new Date()+" bytekitTransformer transform 已经加载过  loader："+loader+" className:"+className+"  plugin:"+abstractByteEnhance);
                        return classfileBuffer;
                    }

                    transformerLoad.setLoadCount();
                    abstractByteEnhanceCla = loader.loadClass(abstractByteEnhance);
                }catch (Throwable e){
                    System.err.println("[bytekit] "+new Date()+" bytekitTransformer loader加载不到类 loader:"+loader+" className:"+className+"  plugin:"+abstractByteEnhance+"  e:"+e.getMessage());
                    if (transformerLoad != null){
                        transformerLoad.setErrorCount();
                        transformerLoad.setError(e.getMessage());
                    }
                    return classfileBuffer;
                }

                if (abstractByteEnhanceCla == null){
                    System.err.println("[bytekit] "+new Date()+" bytekitTransformer abstractByteEnhance is null loader:"+loader+" className:"+className+"  plugin:"+abstractByteEnhance);
                    throw new RuntimeException("abstractByteEnhanceCla is null");
                }

                Object obj = abstractByteEnhanceCla.newInstance();


                Method enhance = abstractByteEnhanceCla.getMethod("enhance",ClassLoader.class,String.class,Class.class,ProtectionDomain.class,classfileBuffer.getClass());

                byte[] bytes = (byte[])enhance.invoke(obj,loader,className,classBeingRedefined,protectionDomain,classfileBuffer);
                transformerLoad.setSuccessCount();
                System.out.println("[bytekit] "+new Date()+" bytekitTransformer transform 执行插件类enhance成功 loader:"+loader+" className:"+className+"  plugin:"+abstractByteEnhance);
                return bytes;
//                Method math = abstractByteEnhanceCla.getMethod("math",ClassLoader.class,String.class,Class.class,ProtectionDomain.class);

//                Boolean flag = (Boolean) math.invoke(obj,loader,className,classBeingRedefined,protectionDomain);
//                if (flag){

//                    byte[] bytes = abstractByteEnhance.enhance(loader,className,classBeingRedefined,protectionDomain,classfileBuffer);
//                System.err.println(Decompiler.decompile(bytes));
//                    return bytes;
//                }
            }catch (Throwable e){
                e.printStackTrace();
                System.err.println("[bytekit] BytekitTransformer  transform error e:"+e.getMessage());
                if (transformerLoad != null){
                    transformerLoad.setErrorCount();
                    transformerLoad.setError(e.getMessage());
                }

            }

        }
        return classfileBuffer;
    }

    /**
     * bootstrap 的类加载loader是null,获取系统类加载器
     * @return
     */
    private ClassLoader getClassLoader(String cla){
        ClassLoader loader;
        loader = GovernanceAgent.class.getClassLoader();
        try {
            loader.loadClass(cla);
        } catch (ClassNotFoundException e) {
            loader = Thread.currentThread().getContextClassLoader();
            try {
                loader.loadClass(cla);
            } catch (ClassNotFoundException e1) {
                System.out.println("[bytekit] "+new Date()+" bytekitTransformer getClassLoader error loader:"+loader+" className:"+cla+ " e:"+e.getMessage());
                return null;
            }
        }
        return loader;
    }


    private static TransformerLoad getTransformerLoad(String className,ClassLoader classLoader,String enhance){

        String key = className+"_"+classLoader.getClass().getTypeName();
        TransformerLoad transformerLoad = TransformerLoadMap.get(key);
        if (transformerLoad != null){
            return transformerLoad;
        }

        transformerLoad = new TransformerLoad();
        transformerLoad.setClassName(className);
        transformerLoad.setByteEnhance(enhance);
        transformerLoad.setClassLoader(classLoader);

        TransformerLoadMap.put(key,transformerLoad);
        return transformerLoad;
    }

    public void start(){
        Thread thread = new Thread(this::run);
        thread.setName("bytekitTransformer thread");
        thread.setDaemon(true);
        thread.start();
    }

    @Override
    public void run() {
        delayStartRetransformTime = Integer.valueOf(EnvUtils.getProperty("GOV_RETRANSORM_TIME","-1"));

        if (delayStartRetransformTime < 0){
            return;
        }

        System.out.println("[bytekit] "+new Date()+" bytekitTransformer 延时增强启动");
        Instrumentation inst = InstrumentConfig.INSTANCE.get();
        try {
            Thread.sleep(delayStartRetransformTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        List<Class> unEnhance = new ArrayList<>();

        ClassLoader classLoader = ClassLoaderUtil.getClassLoader();
        System.out.println("[bytekit] "+new Date()+" bytekitTransformer 延时增强 loader:"+classLoader);
        enhanceModels.forEach((className,enhance) ->{
            try {
                className = className.replaceAll("/",".");
                Class cla = classLoader.loadClass(className);
                unEnhance.add(cla);
            } catch (Exception e) {
                System.err.println("[bytekit] "+new Date()+" bytekitTransformer 延时增强加载增强类失败 loader:"+classLoader+" className:"+className+" enhance:"+enhance+" e:"+e.getMessage());
            }
        });


        for (Class aClass : unEnhance){
            if (!inst.isModifiableClass(aClass) || !inst.isRetransformClassesSupported()){
                System.out.println("[bytekit] "+new Date()+" bytekitTransformer 不能retransformClasses className:"+aClass);
            }

            try {
                System.out.println("[bytekit] "+new Date()+" bytekitTransformer 延时增强 aClass"+aClass);
                inst.retransformClasses(aClass);
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("[bytekit] "+new Date()+" bytekitTransformer retransformClasses error className:"+aClass);
            }
        }
    }

    /**
     * 转换加载模型
     */
    public static class TransformerLoad {

        private ClassLoader classLoader;

        private String className;

        private String ByteEnhance;

        private int loadCount;

        private int successCount;

        private int errorCount;

        public ClassLoader getClassLoader() {
            return classLoader;
        }

        public void setClassLoader(ClassLoader classLoader) {
            this.classLoader = classLoader;
        }

        private List<String> error = new ArrayList<>();

        public String getClassName() {
            return className;
        }

        public void setClassName(String className) {
            this.className = className;
        }

        public String getByteEnhance() {
            return ByteEnhance;
        }

        public void setByteEnhance(String byteEnhance) {
            ByteEnhance = byteEnhance;
        }

        public int getLoadCount() {
            return loadCount;
        }

        public void setLoadCount() {
            this.loadCount++;
        }

        public int getSuccessCount() {
            return successCount;
        }

        public void setSuccessCount() {
            this.successCount++;
        }

        public int getErrorCount() {
            return errorCount;
        }

        public void setErrorCount() {
            this.errorCount++;
        }


        public List<String> getError() {
            return error;
        }

        public void setError(String error) {
            this.error.add(error);
        }
    }


}
抽象的增强类

import java.security.ProtectionDomain;

public abstract class AbstractByteEnhance {


    public  byte[] enhance(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer){
        try {
           if (math(loader,className,classBeingRedefined,protectionDomain)){
                byte[] bytes =  EnhanceUtil.enhanceClass(classfileBuffer,getInterceptorClass(),loader);

                return bytes;
            }

            System.out.println("AbstractByteEnhance bytekit enhance math匹配失败  className:"+className);
        } catch (Throwable e) {
            System.err.println("AbstractByteEnhance bytekit enhance error className:"+className);
            e.printStackTrace();
        }

        return classfileBuffer;
    }

    public abstract Class getInterceptorClass();

    /**
     * 匹配是否进行字节码增强
     * @param loader
     * @param className
     * @param classBeingRedefined
     * @param protectionDomain
     * @return
     */
    public boolean math(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain){
        try {
            Class interceptorClass = getInterceptorClass();
            if (NullInterceptor.class.equals(interceptorClass)){
                System.err.println("AbstractByteEnhance bytekit 类加载器找不到 增强目标类："+className+" loader:"+loader);
                return false;
            }
            loader.loadClass(interceptorClass.getName());
            return true;
        } catch (Throwable e) {
            System.err.println("AbstractByteEnhance bytekit 类加载器找不到 "+getInterceptorClass().getName()+" loader:"+loader+" e:"+e.getMessage());
            return false;
        }
    }

}
拦截器

对logback进行增强

import com.sf.plough.governance.agent.dependencies.com.alibaba.bytekit.asm.binding.Binding;
import com.alibaba.bytekit.asm.interceptor.annotation.AtExceptionExit;
import com.alibaba.bytekit.asm.interceptor.annotation.AtExit;

import java.lang.reflect.Field;

public class LogbackInterceptor {
//    private static Logger logger = Logger.getLogger("");
//    public static Logger logger = LoggerFactory.getLogger("sf-bytekit");

//    private final static String constructArgs = "(Ljava/lang/String;Lorg/apache/logging/log4j/core/Filter;Lorg/apache/logging/log4j/core/Layout;Z[Lorg/apache/logging/log4j/core/config/Property;)V";

    // 拦截方法Entry点进行处理
    /*@AtEnter(inline = true, suppress = RuntimeException.class, suppressHandler = PrintExceptionSuppressHandler.class)
    public static void atEnter(@Binding.This Object object,
                               @Binding.Class Object clazz,
                               @Binding.Args Object[] args,
                               @Binding.MethodName String methodName,
                               @Binding.MethodDesc String methodDesc) throws NoSuchFieldException {

    }*/

    // 拦截方法正常返回的语句，在返回前进行处理
    @AtExit(inline = true)
    public static void atExit(@Binding.This Object object,
                              @Binding.Class Object clazz,
                              @Binding.Args Object[] args,
                              @Binding.MethodName String methodName,
                              @Binding.MethodDesc String methodDesc,
                              @Binding.Return Object returnObject) throws Exception {
        if ("setPattern".equals(methodName) && args != null && args.length == 1){
            Class cla = object.getClass().getSuperclass();
            Field field = cla.getDeclaredField("pattern");
            field.setAccessible(true);
            String pattern = PatternUtil.patternConvert(String.valueOf(args[0]),"%tid");
//            AgentLogger.info("--------logback PatternLayoutBase setPattern2 重写pattern:"+pattern);
            //因为spring boot项目logger不生效
            System.out.println("logback PatternLayoutBase setPattern 重写pattern:"+pattern);
            field.set(object,pattern);
        }
    }

    // 拦截方法内部抛出异常点
    @AtExceptionExit(inline = true, onException = RuntimeException.class)
    public static void atExceptionExit(@Binding.Class Object clazz,@Binding.Throwable RuntimeException ex/*,
                                       @Binding.Field(name = "exceptionCount") int exceptionCount*/) {
        ex.printStackTrace();
//        AgentLogger.error("[SF AGENT]LogbackInterceptor atExceptionExit error, clazz:" + clazz,ex);
        throw ex;
    }

    public static Boolean methodMatch(String method,String methodDesc){
        return "setPattern".equals(method);
    }

    public static Boolean constructMatch(String methodDesc){
        return false;
    }

    public static Boolean staticMatch(String methodDesc){
        return false;
    }

}

参考连接：https://github.com/kangzhenkang/bytekit

草丛里的码农
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
开源诊断利器Arthas ByteKit 深度解读(1)：基本原理介绍
横云断岭的专栏
07-16 1481
Arthas ByteKit 深度解读(1)：基本原理介绍前言本文由整体到局部的思路展开分析Arthas ByteKit 字节码处理框架，结合类图和数据流图，介绍ByteKit字节码处理...
bytekit:Java字节码套件
03-21
ByteKit Java字节码套件。 目标 之前的Arthas里的字节码增强，是通过asm来处理的，代码逻辑不好修改，理解困难 基于ASM提供更高层的字节码处理能力，面向诊断/ APM领域，不是通用的字节码库 ByteKit期望能提供一套简洁的API，让开发人员可以比较轻松的完成字节码增强 对比 功能 函数Enter / Exit注入点 绑定数据 排队 防止重复增强 避免装箱/拆箱费用 起源替换 @ExceptionHandler ByteKit @AtEnter @AtExit @AtExceptionExit @AtFieldAccess @AtInvoke @AtInvokeException @AtLine @AtSyncEnter @AtSyncExit @AtThrow 这个/参数/返回/抛出场地当地人子调用入参/返回值/子调用异常电话号码 ✓ ✓ ✓ ✓ ✓ 字
ByteKit: 阿里巴巴的Java性能优化利器
最新发布
gitblog_00047的博客
04-26 329
ByteKit: 阿里巴巴的Java性能优化利器 项目地址:https://gitcode.com/alibaba/bytekit ByteKit 是阿里巴巴开源的一款强大的Java字节码操作框架，它为开发者提供了一套灵活、高效的工具集，用于在运行时对Java字节码进行动态修改和分析，以实现对应用程序的深度性能优化。 技术解析 ByteKit的核心是基于ASM库的，ASM是一个流行且强大的Java...
java字节码生成框架及使用示例
penriver的博客
07-12 1661
目前Java字节码生成框架大致有ASM、Javassist和byte buddy三种 1 字节码生成框架 1.1 ASM 1.1.1 介绍 ASM官网 介绍如下： ASM是一个通用的Java字节码操作和分析框架。它能够以二进制形式修改已有的类或是动态生成类。 ASM提供了一些常见的字节码转换和分析算法，可以根据这些算法构建定制的复杂转换和代码分析工具。 ASM提供了与其他Java字节码框架类似的功能，但侧重于性能。因为它的设计和实现是尽可能的小和快，所以它非常适合在动态系统中使用(当然也可以在静态方式中使用
应用诊断利器Arthas ByteKit 深度解读(2)：本地变量及参数绑定
横云断岭的专栏
07-20 1130
前言本文通过分析ByteKit的本地变量绑定（LocalVarsBinding）处理代码，结合Java Opcode手册、asm代码、javap反汇编字节码等工具，深入讲解每个指令的用法...
深入了解JVM字节码增强技术
08-25
在文章中，我们通过示例代码，详细地介绍了JVM字节码增强技术的实现步骤和机制，并且给出了一个使用字节码增强实现日志记录的示例代码。希望这个文章能够对大家的学习或者工作具有一定的参考学习价值。
jclasslib 修改class字节码工具
01-11
`jclasslib` 是一款强大的Java字节码查看和编辑工具，尤其适合Java开发者在处理已编译的`.class`文件时使用。它允许我们深入理解类文件的结构，甚至对字节码进行修改，这对于调试、优化、学习Java虚拟机（JVM）的...
XJad 字节码反编译工具
08-17
"XJad"就是这样一个专门用于字节码反编译的工具，尤其针对Java平台。 XJad是由MicroWorld公司开发的一个早期的Java字节码反编译器。在Java的早期版本中，由于没有官方的反编译工具，XJad成为了开发者和安全研究人员...
Java 字节码编辑工具
10-11
优秀的Java字节码可视化编辑工具，使用方便上手简单。
jitwatch java字节码编译工具 可以将字节码转换成汇编语言
01-04
不需要下载源码编译执行，可以直接运行jar文件 运行命令：java -jar jitwatch.jar
Alibaba OneJavaAgent 初探
Mr_rain的专栏
05-19 1794
一、使用 1､plugin 在这种模式下，one-java-agent在加载plugin时，会从以下几个方面进行，分别是 描述 plugin.properties 这个文件是一个引导文件，里面的配置内容引导plugin加载 plugin-jar plugin的引导包，内有实现PluginActivator，用于引导和管理plugin的初始化和销毁 instrument-lib 这个目录存放plugin的代理逻辑和Instrument类 在项目中有demo，以dubbo-test
Java 字节的常用封装
weixin_33895516的博客
12-26 155
　　一. Java 的字节　　byte (字节) 是 Java 中的基本数据类型，一个 byte 包含8个 bit(位)，byte 的取值范围是-128到+127。　　byte 跟 Java 其他基本类型的关系：　　　　二. 常用封装　　由于工作关系，我封装了一个操作字节的库　　github 地址：https://github.com/fengzhizi715/bytekit　　2.1 bytek...
架构（十五）Java字节码增强
m0_69270256的博客
02-27 7824
一般如果需要做增强类的架构工具会使用SpringBoot提供的切面，但是这逃不开两个问题：1、使用方需要加注解代码；2、版本更新导致的发布。 所以java还提供了字节码层面的增强方案，对使用的系统是无感的。
java agent设计开发概要
wzl1369248650的博客
02-10 1296
java agent开发心得
Arthas底层bytekit
qq276726581的博客
04-06 237
public static void main(String[] args) throws Throwable { Sample sample = new Sample(); Thread t = new Thread(new Runnable() { @Override public void run() { while (true) { try ...
阿里开源的15个顶级Java项目
q1472750149的博客
11-04 1197
上个周末抽时间整理了一些阿里开源的一些 Java 开源项目，希望对大家有帮助！这篇文章收录的所有开源项目都是还在继续维护并且可以使用的。 虽然有部分项目不是那么”完美“，但是依然非常值得我们学习。 感谢阿里技术团队的小伙伴们为 Java 开源生态做的贡献！ Canal Canal[kə'næl] 翻译过来是水道/管道/沟渠的意思，主要用于基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。 Canal 可以帮助我们实现 MySQL 和其他数据源比如 Elasticsearch、Kafka
字节码增强技术-Byte Buddy
热门推荐
qq_36654870的博客
08-12 1万+
字节码增强技术-Byte Buddy 目录简介性能使用installHello World创建动态类加载类拦截方法通过匹配模式拦截方法委托参数绑定AgentElementMatcherTransformerEND 简介 Byte Buddy是一个字节码生成和操作库，用于在Java应用程序运行时创建和修改Java类，而无需编译器的帮助。除了Java类库附带的代码生成实用程序外，Byte Buddy还允许创建任意类，并且不限于实现用于创建运行时代理的接口。此外，Byte Buddy提供了一种方便的API，可以使
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值