字节码及ASM使用

结构化锁定是指方法调用期间每一个monitor退出都与前面monitor进入相匹配的情形。JVM通过以下两条规则来保证结结构化锁成立(T代表一线程，M代表一个monitor)：

   1)T在方法执行时持有M的次数必须与T在方法完成时释放的M次数相等
   2)任何时刻都不会出现T释放M的次数比T持有M的次数多的情况
    

| 前/后缀 | 操作数类型 |
| :------ | :------ |
| i | 整数 | 
| l | 长整数 | 
| s | 短整数 | 
| b | 字节 | 
| c | 字符 | 
| f | 单精度浮点数 | 
| d | 双精度浮点数 | 
| z | 布尔值 | 
| a | 引用 | 

引用自深入理解java虚拟机 字节码指令简介

JAVA源码

package com.taobao.film;

/**
 * @author - zhupin(kaiqiang.gkq@alibaba-inc.com)
 */
public class Demo {
    private static final String HELLO_CONST = "Hello";
    private static String CONST = null;

    static {
        CONST = HELLO_CONST + "%s!";
    }

    public static void main(String[] args) {
        if (args != null && args.length == 1) {
            System.out.println(String.format(CONST, args[0]));
        }
    }
}

对应字节码
简记 ms:操作数栈最大深度 ml:局部变量表最大容量 s:操作数栈 l:局部变量表

// class version 49.0 (49)
// access flags 0x21
public class com/taobao/film/Demo {

  // compiled from: Demo.java

  // access flags 0x1A 常量,类被装载时分配空间 private static final String HELLO_CONST = "Hello";
  private final static Ljava/lang/String; HELLO_CONST = "Hello"

  // access flags 0xA 静态属性,类被装载时分配空间 private static String CONST ;
  private static Ljava/lang/String; CONST

  // access flags 0x1 没有重载构造函数，默认构造函数()V
  public ()V
   L0 // 标签表示方法的字节码中的位置。标签用于跳转，goto和切换指令，以及用于尝试catch块。标签指定刚刚之后的指令。注意，在标签和它指定的指令（例如其他标签，堆栈映射帧，行号等）之间可以有其他元素。
    LINENUMBER 6 L0 //异常的栈信息中对应的line number，可删除不影响运行
    ALOAD 0 //this
    INVOKESPECIAL java/lang/Object. ()V //this.super()
    RETURN
   L1
    LOCALVARIABLE this Lcom/taobao/film/Demo; L0 L1 0
    MAXSTACK = 1 //最大栈深度1,压栈局部变量this
    MAXLOCALS = 1 //局部变量数1,局部变量this

  // access flags 0x9 简记 ms:操作数栈最大深度 ml:局部变量表最大容量 s:操作数栈 l:局部变量表
  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 15 L0
    ALOAD 0 //非静态方法,局部变量0即方法入参第一个参数args reference; ms=1,ml=1,s=[args ref],l=[args ref]
    IFNULL L1  //if(args ref==null)跳转 L1 return
    ALOAD 0 //load args ms=1,ml=1,s=[args ref],l=[args ref]
    ARRAYLENGTH//计算args.length将结果入操作数栈 ms=1,ml=1,s=[args ref],l=[args ref] 
    ICONST_1 //数字常量1 ms=2,ml=1,s=[1,args ref],l=[args ref] 
    IF_ICMPNE L1 //if(args.length == 1) 跳转 L1 return 
   L2 //ms=2,ml=1,s=[],l=[args ref] 
    LINENUMBER 16 L2
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;//访问System.out，入操作数栈 ms=2,ml=1,s=[System.out],l=[args ref]  
    GETSTATIC com/taobao/film/Demo.CONST : Ljava/lang/String;//访问CONST，入操作数栈 ms=2,ml=1,s=[CONST,System.out],l=[args ref]  
    {//这里一段，实现的是new Object[]{args[0]},String.format(String format, Object... args) 
    ICONST_1//1  ms=3,ml=1,s=[1,CONST,System.out],l=[args ref]  
    ANEWARRAY java/lang/Object// new Object[1]; ms=3,ml=1,s=[objects ref,CONST,System.out],l=[args ref]  
    DUP // ms=4,ml=1,s=[objects ref,objects ref,CONST,System.out],l=[args ref]  
    ICONST_0//0 ms=5,ml=1,s=[0,objects ref,objects ref,CONST,System.out],l=[args ref]  
    ALOAD 0 //args reference入操作数栈; ms=6,ml=1,s=[args ref,0,objects ref,objects ref,CONST,System.out],l=[args ref]  
    ICONST_0 //0 ms=7,ml=1,s=[0,args ref,0,objects ref,objects ref,CONST,System.out],l=[args ref] 
    AALOAD //args[0] ms=7,ml=1,s=[args[0],0,objects ref,objects ref,CONST,System.out],l=[args ref]
    AASTORE //objects[0]=args[0]; ms=7,ml=1,s=[objects ref,CONST,System.out],l=[args ref]
    }
    INVOKESTATIC java/lang/String.format (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;//String.format(CONST,objects) ms=7,ml=1,s=[objects ref,CONST,System.out],l=[args ref]
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V //System.out.println(...); ms=7,ml=1,s=[],l=[args ref]
   L1
    LINENUMBER 18 L1
    RETURN
   L3
    LOCALVARIABLE args [Ljava/lang/String; L0 L3 0
    MAXSTACK = 7
    MAXLOCALS = 1

  // access flags 0x8 V classload init，静态代码初始块，类被装在时init
  static ()V
   L0
    LINENUMBER 8 L0 
    ACONST_NULL //压栈常量NULL
    PUTSTATIC com/taobao/film/Demo.CONST : Ljava/lang/String; //静态属性赋值，CONST=null
   L1
    LINENUMBER 11 L1
    LDC "Hello%s!" //加载常量Hello%s! 编译优化，hello+%s编译优化为常量Hello%s!
    PUTSTATIC com/taobao/film/Demo.CONST : Ljava/lang/String;//赋值Hello%s!
   L2
    LINENUMBER 12 L2
    RETURN
    MAXSTACK = 1 //只有赋值操作，操作数栈深度1
    MAXLOCALS = 0 //静态方法无局部变量
}

回答这个问题前我们首先得明白字节码是作用于运行期，所以一般用来在运行期改变类的行为，基本上都会结合代理模式使用。

ASM

BCEL

CGLIB

Javassist

Byte Buddy

本文来介绍下ASM框架的使用(了解一点底层字节码操作，对了解JVM执行过程以及我们常用框架的实现原理都会有新的认识)

ClassReader用来读取原有的字节码，ClassWriter用于写入字节码，ClassVisitor、FieldVisitor、MethodVisitor、AnnotationVisitor访问修改对应组件。(一般不要通过ClassReader读取再通过Vistor修改类型为再ClassWriter回写，覆盖原有类行为，采用继承会更安全)

注:

Diving into Bytecode Manipulation

[字节码操纵技术探秘
](http://www.infoq.com/cn/artic...

以下代码效果等同于上面的Demo示例

import java.io.FileOutputStream;
import java.lang.reflect.Method;

import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

public class DemoDump implements Opcodes {

    public static byte[] dump() throws Exception {

        ClassWriter cw = new ClassWriter(0);
        FieldVisitor fv;
        MethodVisitor mv;
        AnnotationVisitor av0;

        cw.visit(V1_5, ACC_PUBLIC + ACC_SUPER, "com/taobao/film/Demo", null, "java/lang/Object", null);

        cw.visitSource("Demo.java", null);

        {
            fv = cw.visitField(ACC_PRIVATE + ACC_FINAL + ACC_STATIC, "HELLO_CONST", "Ljava/lang/String;", null,
                "Hello");
            fv.visitEnd();
        }
        {
            fv = cw.visitField(ACC_PRIVATE + ACC_STATIC, "CONST", "Ljava/lang/String;", null, null);
            fv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(6, l0);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V", false);
            mv.visitInsn(RETURN);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLocalVariable("this", "Lcom/taobao/film/Demo;", null, l0, l1, 0);
            mv.visitMaxs(1, 1);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(15, l0);
            mv.visitVarInsn(ALOAD, 0);
            Label l1 = new Label();
            mv.visitJumpInsn(IFNULL, l1);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitInsn(ARRAYLENGTH);
            mv.visitInsn(ICONST_1);
            mv.visitJumpInsn(IF_ICMPNE, l1);
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitLineNumber(16, l2);
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitFieldInsn(GETSTATIC, "com/taobao/film/Demo", "CONST", "Ljava/lang/String;");
            mv.visitInsn(ICONST_1);
            mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
            mv.visitInsn(DUP);
            mv.visitInsn(ICONST_0);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitInsn(ICONST_0);
            mv.visitInsn(AALOAD);
            mv.visitInsn(AASTORE);
            mv.visitMethodInsn(INVOKESTATIC, "java/lang/String", "format",
                "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;", false);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            mv.visitLabel(l1);
            mv.visitLineNumber(18, l1);
            mv.visitInsn(RETURN);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitLocalVariable("args", "[Ljava/lang/String;", null, l0, l3, 0);
            mv.visitMaxs(7, 1);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_STATIC, "", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(8, l0);
            mv.visitInsn(ACONST_NULL);
            mv.visitFieldInsn(PUTSTATIC, "com/taobao/film/Demo", "CONST", "Ljava/lang/String;");
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLineNumber(11, l1);
            mv.visitLdcInsn("Hello%s!");
            mv.visitFieldInsn(PUTSTATIC, "com/taobao/film/Demo", "CONST", "Ljava/lang/String;");
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitLineNumber(12, l2);
            mv.visitInsn(RETURN);
            mv.visitMaxs(1, 0);
            mv.visitEnd();
        }
        cw.visitEnd();

        return cw.toByteArray();
    }

    public static class MyClassLoader extends ClassLoader {
        public MyClassLoader() {
            super();
        }

        public MyClassLoader(ClassLoader cl) {
            super(cl);
        }

        public Class defineClass(String name, byte[] b) {
            return defineClass(name, b, 0, b.length);
        }
    }

    public static void main(String[] args) throws Exception {
        byte[] bytes = dump();
        FileOutputStream fileOutputStream = new FileOutputStream("D:Demo.class");
        fileOutputStream.write(bytes);
        fileOutputStream.close();
        MyClassLoader classLoader = new MyClassLoader(Thread.currentThread().getContextClassLoader());
        Class testClass = classLoader.defineClass("com.taobao.film.Demo",
            bytes);
        // invoke static
        Method staticMain = testClass.getMethod("main", String[].class);
        staticMain.invoke(null, new Object[] {new String[] {"zhupin"}});
    }
}

XML快速序列化

为无状态逻辑类的指定函数产生一个代理，代理接口接受字符串数组，转换后调用原函数

fastjson hotcode asm

dubbo hsf javaassist

hibernate cglib javaassist

spring aop cglib (通过设置-Dcglib.debugLocation=D://tmp 开启classdump)

mockito cglib

最早接触字节码编程还是在使用IL(C# Emit)，也在大型项目中使用过ASM获得了不错的效果。不过个人觉得操作字节码编程还是要保持谨慎态度。下面是我的一点小建议：

操作字节码作用于运行期，对于开发人员是完全透明的。

字节码编程的可阅读可维护性比较差，不要滥用字节码编程。

能通过设计模式实现的场景尽量通过设计模式实现；

字节码编程中复杂的逻辑也尽量使用java实现，在字节码中调用；

使用字节码解决一些框架性的问题，不要用于处理易变逻辑；

字节码编程从逻辑块着手，优先明确程序跳转Label，再补充逻辑执行

借助工具
推荐使用intellj idea插件ASM Bytecode Outline，目前生成的字节码对应到 ASM 5.x。

使用decompile工具校验生成代码是否正确。

更多文章请访问我的博客
转载请注明出处