如果对我这段代码感兴趣，直接拷贝测试debug，要不然你不知道我写的是什么鬼，如果有什么问题，可以告诉我。

一、实现动态代理，首先得考虑有应该定义哪些类，根据JDK的动态代理思想，那么它就应该有一个生成代理的类

  1. package com.asm_core;
  2.  
  3. import java.io.PrintWriter;
  4. import java.lang.reflect.Method;
  5. import java.util.List;
  6.  
  7. import org.objectweb.asm.ClassWriter;
  8. import org.objectweb.asm.Opcodes;
  9. import org.objectweb.asm.tree.ClassNode;
  10. import org.objectweb.asm.tree.FieldInsnNode;
  11. import org.objectweb.asm.tree.FieldNode;
  12. import org.objectweb.asm.tree.InsnList;
  13. import org.objectweb.asm.tree.InsnNode;
  14. import org.objectweb.asm.tree.JumpInsnNode;
  15. import org.objectweb.asm.tree.LabelNode;
  16. import org.objectweb.asm.tree.LdcInsnNode;
  17. import org.objectweb.asm.tree.MethodInsnNode;
  18. import org.objectweb.asm.tree.MethodNode;
  19. import org.objectweb.asm.tree.TypeInsnNode;
  20. import org.objectweb.asm.tree.VarInsnNode;
  21. import org.objectweb.asm.util.TraceClassVisitor;
  22.  
  23. import com.asm_core.logic.AddLogic;
  24.  
  25. /**
  26.  * 生成代理对象
  27.  * @author may
  28.  *
  29.  */
  30. public class GenSubProxy {
  31.  
  32.     //逻辑接口
  33.     private AddLogic logic = null;
  34.     //被代理类的所有方法
  35.     private Method[] methods = null;
  36.  
  37.     private String classNamePrefix = null;
  38.  
  39.     private String descInfoPrefix = null;
  40.  
  41.     private String logicPkg = null;
  42.  
  43.     public GenSubProxy(AddLogic logic) {
  44.  
  45.         String logicClassName = AddLogic.class.getName();
  46.  
  47.         this.logicPkg = logicClassName.substring(0, logicClassName.lastIndexOf(AddLogic.class.getSimpleName())).replace(".", "/");
  48.  
  49.         this.logic = logic;
  50.  
  51.     }
  52.  
  53.     public Object genSubProxy(Class<?> superClass) {
  54.  
  55.         //获得被代理类的方法集合
  56.         methods = superClass.getDeclaredMethods();
  57.  
  58.         classNamePrefix = superClass.getName().substring(0, superClass.getName().lastIndexOf(superClass.getSimpleName()));
  59.  
  60.         descInfoPrefix = classNamePrefix.replace(".", "/");
  61.  
  62.         Object obj = null;
  63.         try {
  64.             PrintWriter pw = new PrintWriter(System.out, true);
  65.             //生成ClassNode
  66.             ClassNode cn = genClassNode(superClass);
  67.             //ClassWriter.COMPUTE_FRAMES表示让asm自动生成栈图，虽然会慢上二倍。
  68.             ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
  69.  
  70.             TraceClassVisitor tcv = new TraceClassVisitor(cw, pw);
  71.  
  72.             cn.accept(tcv);
  73.  
  74.             //cn.accept(cw);
  75.  
  76.             byte[] b = cw.toByteArray();
  77.  
  78.             MyClassLoader classLoader = new MyClassLoader(b);
  79.  
  80.             Class<?> proxy = classLoader.loadClass(classNamePrefix + "$Proxy");
  81.  
  82.             obj = proxy.newInstance();
  83.  
  84.             Method method = proxy.getDeclaredMethod("setLogic", AddLogic.class);
  85.  
  86.             method.invoke(obj, logic);
  87.  
  88.             Method meth = proxy.getDeclaredMethod("setMethods", Method[].class);
  89.  
  90.             meth.invoke(obj, new Object[] {methods});
  91.  
  92.         } catch (Exception e) {
  93.             e.printStackTrace();
  94.         }
  95.  
  96.         return obj;
  97.     }
  98.  
  99.     public ClassNode genClassNode(Class<?> superClass) {
  100.  
  101.         String superName = superClass.getName().replace(".", "/");
  102.  
  103.         ClassNode cn = new ClassNode(Opcodes.ASM5);
  104.  
  105.         //定义代理类的类名
  106.         cn.name = descInfoPrefix + "$Proxy";
  107.         //超类为当前被代理类
  108.         cn.superName = superName;
  109.  
  110.         cn.access = Opcodes.ACC_PUBLIC;
  111.  
  112.         cn.version = Opcodes.V1_8;
  113.  
  114.         cn = proxyMethod(cn);
  115.  
  116.         return cn;
  117.  
  118.     }
  119.  
  120.     @SuppressWarnings("all")
  121.     public ClassNode proxyMethod(ClassNode cn) {
  122.  
  123.         List<MethodNode> list = cn.methods;
  124.  
  125.         List<FieldNode> fields = cn.fields;
  126.         //这里赋初始值必须是Integer, Float, Long, Double 或者 String，null
  127.         fields.add(new FieldNode(Opcodes.ACC_PUBLIC, "logic", "L" + logicPkg + "AddLogic;", null, null));
  128.         //添加methods字段
  129.         fields.add(new FieldNode(Opcodes.ACC_PUBLIC, "methods", "[Ljava/lang/reflect/Method;", null, null));
  130.         //添加方法setLogic，用于设置Logic
  131.         MethodNode mn = new MethodNode(Opcodes.ACC_PUBLIC, "setLogic", "(L" + logicPkg + "AddLogic;)V", null, null);
  132.         //下面的指令相当于this.logic = logic;
  133.         InsnList insnList = mn.instructions;
  134.  
  135.         insnList.add(new VarInsnNode(Opcodes.ALOAD, 0));
  136.  
  137.         insnList.add(new VarInsnNode(Opcodes.ALOAD, 1));
  138.  
  139.         insnList.add(new FieldInsnNode(Opcodes.PUTFIELD, descInfoPrefix + "$Proxy", "logic", "L" + logicPkg + "AddLogic;"));
  140.  
  141.         insnList.add(new InsnNode(Opcodes.RETURN));
  142.  
  143.         mn.maxLocals = 2;//定义最大的本地变量
  144.  
  145.         mn.maxStack = 2;//定义最大的操作数栈
  146.  
  147.         list.add(mn);
  148.         //添加一个setMethods方法，用于设置methods字段
  149.         MethodNode meth = new MethodNode(Opcodes.ACC_PUBLIC, "setMethods", "([Ljava/lang/reflect/Method;)V", null, null);
  150.         //这段指令相当于this.methods = methods;
  151.         InsnList methList = meth.instructions;
  152.  
  153.         methList.add(new VarInsnNode(Opcodes.ALOAD, 0));
  154.  
  155.         methList.add(new VarInsnNode(Opcodes.ALOAD, 1));
  156.  
  157.         methList.add(new FieldInsnNode(Opcodes.PUTFIELD, descInfoPrefix + "$Proxy", "methods", "[Ljava/lang/reflect/Method;"));
  158.  
  159.         methList.add(new InsnNode(Opcodes.RETURN));
  160.  
  161.         meth.maxLocals = 2;
  162.  
  163.         meth.maxStack = 2;
  164.  
  165.         list.add(meth);//
  166.         //添加构造方法
  167.         MethodNode init = new MethodNode(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
  168.         //这里是调用父类构造器，相当于super();
  169.         InsnList initList = init.instructions;
  170.  
  171.         initList.add(new VarInsnNode(Opcodes.ALOAD, 0));
  172.  
  173.         initList.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, descInfoPrefix + "SayHello", "<init>", "()V", false));
  174.  
  175.         initList.add(new InsnNode(Opcodes.RETURN));
  176.  
  177.         init.maxLocals = 1;
  178.  
  179.         init.maxStack = 1;
  180.  
  181.         list.add(init);
  182.  
  183.         int count = 0;
  184.         //循环创建需要代理的方法
  185.         for (Method method : methods) {
  186.  
  187.             MethodNode methodNode = new MethodNode(Opcodes.ACC_PUBLIC,  method.getName(), DescInfo.getDescInfo(method), null, null);
  188.  
  189. //            System.err.println(DescInfo.getDescInfo(method));
  190.  
  191.             InsnList il = methodNode.instructions;
  192.  
  193.             //获得参数的类型
  194.             Class<?>[] clazz = method.getParameterTypes();
  195.  
  196.             //计算出参数会占用掉的本地变量表长度，long，double类型占用两个slot
  197.             int len = LocalLen.len(clazz);
  198.             //获得这个方法的参数个数，不包括this
  199.             int size = clazz.length;
  200.             //或的返回值类型
  201.             Class<?> rtClazz = method.getReturnType();
  202.  
  203.             il.clear();
  204.             /**
  205.              * 下面的一大段指令的意思是
  206.              * int index = count;
  207.              * Method method = methods[index];//从methods中获得对应的方法对象
  208.              * Object[] objs = new Object[]{arg0,arg1,arg2....};用来存方法传过来的参数值的
  209.              * try {
  210.              *         logic.addLogic(method, objs);
  211.              * } catch(Exception e) {
  212.              *         e.printStackTrace();
  213.              * }
  214.              */
  215.             il.add(new LdcInsnNode(count));//
  216.  
  217.             il.add(new VarInsnNode(Opcodes.ISTORE, len + 1));
  218.  
  219.             il.add(new VarInsnNode(Opcodes.ALOAD, 0));
  220.  
  221.             il.add(new FieldInsnNode(Opcodes.GETFIELD, descInfoPrefix + "$Proxy", "methods", "[Ljava/lang/reflect/Method;"));
  222.  
  223.             il.add(new VarInsnNode(Opcodes.ILOAD, len + 1));
  224.  
  225.             il.add(new InsnNode(Opcodes.AALOAD));
  226.  
  227.             il.add(new VarInsnNode(Opcodes.ASTORE, len + 2));//将栈顶的method存到局部变量表中
  228.  
  229.             //将参数长度推到栈顶
  230.             il.add(new LdcInsnNode(size));
  231.  
  232.             il.add(new TypeInsnNode(Opcodes.ANEWARRAY, "java/lang/Object"));//new 出一个Object的数组
  233.  
  234.             il.add(new VarInsnNode(Opcodes.ASTORE, len + 3));//将数组存到本地变量表中
  235.  
  236.             int index = 1;
  237.  
  238.             //将参数值全都存到数组中
  239.             for(int i = 0; i < size; i++) {
  240.  
  241.                 il.add(new VarInsnNode(Opcodes.ALOAD, len + 3));//将数组推到栈顶
  242.  
  243.                 il.add(new LdcInsnNode(i));//下标
  244.  
  245.                 int opcode = OpcodeMap.getOpcodes(clazz[i].getName());//获得当前是什么类型的参数，使用什么样类型的指令
  246.                 //如果是long，double类型的index加2
  247.                 if(opcode == 22 || opcode == 24) {
  248.  
  249.                     il.add(new VarInsnNode(opcode,index));//将long或者double参数推到栈顶
  250.                     index += 2;
  251.                 } else {
  252.  
  253.                     il.add(new VarInsnNode(opcode, index));//将参数推到栈顶
  254.                     index += 1;
  255.                 }
  256.  
  257.                 if(AutoPKG.auto(clazz[i].getName()) != null) {
  258.  
  259.                     il.add(new MethodInsnNode(Opcodes.INVOKESTATIC, AutoPKG.auto(clazz[i].getName()), "valueOf", AutoPKG_valueOf.auto(clazz[i].getName()), false));
  260.  
  261.                 }
  262.  
  263.                 il.add(new InsnNode(Opcodes.AASTORE));//将数据存到数组中
  264.  
  265.             }
  266.  
  267.             il.add(new VarInsnNode(Opcodes.ALOAD, 0));//
  268.  
  269.             il.add(new FieldInsnNode(Opcodes.GETFIELD, descInfoPrefix + "$Proxy", "logic", "L" + logicPkg + "AddLogic;"));
  270.  
  271.             il.add(new VarInsnNode(Opcodes.ALOAD, len+2));
  272.  
  273.             il.add(new VarInsnNode(Opcodes.ALOAD, len + 3));
  274.  
  275.             il.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "" + logicPkg + "AddLogic", "addLogic", "(Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;", true));
  276.  
  277.             il.add(new TypeInsnNode(Opcodes.CHECKCAST, rtClazz.getName().replace(".", "/")));
  278.  
  279.             LabelNode label = new LabelNode();
  280.  
  281.             il.add(new JumpInsnNode(Opcodes.GOTO, label));
  282.             //由于对栈图还是不太明白是啥意思，如果有知道的麻烦告知我一声
  283.             //il.add(new FrameNode(Opcodes.F_SAME, 0, null, 0, null));
  284.  
  285.             il.add(new VarInsnNode(Opcodes.ASTORE, len + 4));
  286.  
  287.             il.add(new VarInsnNode(Opcodes.ALOAD, len + 4));
  288.  
  289.             il.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/lang/Exception", "printStackTrace", "()V", false));
  290.  
  291.             il.add(label);
  292.  
  293.             il.add(new InsnNode(OpcodeRt.getOpcodes(rtClazz.getName())));
  294.  
  295.             methodNode.maxLocals = 5+len;
  296.  
  297.             methodNode.maxStack = 5;
  298.  
  299.             list.add(methodNode);
  300.  
  301.             count ++;
  302.         }
  303.  
  304.         return cn;
  305.     }
  306.  
  307. }

二、有了生成代理的类，那么就还应该有个处理逻辑的接口

  1. package com.asm_core.logic;
  2.  
  3. import java.lang.reflect.Method;
  4.  
  5. /**
  6.  * 这个类用来增加方法逻辑,类似于JDK代理的InvocationHandler
  7.  * @author may
  8.  *
  9.  */
  10. public interface AddLogic {
  11.  
  12.     /**
  13.      *
  14.      * @param method 被代理对象的方法对象
  15.      * @param args 被代理方法的参数
  16.      * @throws Exception
  17.      */
  18.     public Object addLogic(Method method, Object[] args) throws Exception ;
  19.  
  20. }

三、如果方法参数中存在基本类型参数，要自动打包成Object[] args，写个基本类型对应包装类助手

  1. package com.asm_core;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. public class AutoPKG {
  7.  
  8.     public static final Map<String, String> map = new HashMap<>();
  9.  
  10.     static {
  11.         map.put("int", "java/lang/Integer");
  12.  
  13.         map.put("byte", "java/lang/Byte");
  14.  
  15.         map.put("short", "java/lang/Short");
  16.  
  17.         map.put("long", "java/lang/Long");
  18.  
  19.         map.put("boolean", "java/lang/Boolean");
  20.  
  21.         map.put("char", "java/lang/Character");
  22.  
  23.         map.put("float", "java/lang/Float");
  24.  
  25.         map.put("double", "java/lang/Double");
  26.  
  27.     }
  28.  
  29.     public static String auto(String type) {
  30.  
  31.         if(map.containsKey(type)) {
  32.  
  33.             return map.get(type);
  34.         } else {
  35.  
  36.             return null;
  37.         }
  38.  
  39.     }
  40.  
  41. }

四、基本类型对应包装类的valueOf方法的描述符

  1. package com.asm_core;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. public class AutoPKG_valueOf {
  7.  
  8.     public static final Map<String, String> map = new HashMap<>();
  9.  
  10.     static {
  11.         map.put("int", "(I)Ljava/lang/Integer;");
  12.  
  13.         map.put("byte", "(B)Ljava/lang/Byte;");
  14.  
  15.         map.put("short", "(S)Ljava/lang/Short;");
  16.  
  17.         map.put("long", "(J)Ljava/lang/Long;");
  18.  
  19.         map.put("boolean", "(Z)Ljava/lang/Boolean;");
  20.  
  21.         map.put("char", "(C)Ljava/lang/Character;");
  22.  
  23.         map.put("float", "(F)Ljava/lang/Float;");
  24.  
  25.         map.put("double", "(D)Ljava/lang/Double;");
  26.  
  27.     }
  28.  
  29.     public static String auto(String type) {
  30.  
  31.         if(map.containsKey(type)) {
  32.  
  33.             return map.get(type);
  34.         } else {
  35.  
  36.             return null;
  37.         }
  38.  
  39.     }
  40.  
  41. }

五、方法描述符生成助手

  1. package com.asm_core;
  2.  
  3. import java.lang.reflect.Method;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6.  
  7. /**
  8.  * 用于生成字节码描述符的工具类
  9.  * @author may
  10.  *
  11.  */
  12. public class DescInfo {
  13.  
  14.     public static final Map<String, String> map = new HashMap<>();
  15.  
  16.     static {
  17.  
  18.         map.put("int", "I");
  19.  
  20.         map.put("byte", "B");
  21.  
  22.         map.put("short", "S");
  23.  
  24.         map.put("long", "J");
  25.  
  26.         map.put("boolean", "Z");
  27.  
  28.         map.put("char", "C");
  29.  
  30.         map.put("float", "F");
  31.  
  32.         map.put("double", "D");
  33.  
  34.         map.put("void", "V");
  35.  
  36.     }
  37.  
  38.     public static String getDescInfo(Method method) {
  39.  
  40.         Class<?>[]  pt = method.getParameterTypes();
  41.  
  42.         Class<?>  rt = method.getReturnType();
  43.  
  44.         String rtStr = "V";
  45.  
  46.         if(map.containsKey(rt.getName())) {
  47.  
  48.             rtStr = map.get(rt.getName());
  49.  
  50.         } else {
  51.             /**
  52.              * 如果不为空，那么就是数组
  53.              */
  54.             Class<?> clazz= rt.getComponentType();//如果原来的rt是int[][]
  55.             Class<?> oldClazz = clazz;//int[]
  56.             int count = 0;
  57.             if(oldClazz != null) {
  58.                 rtStr = "";
  59.                 while(clazz != null) {
  60.                     count ++;//
  61.                     oldClazz = clazz;
  62.                     clazz= clazz.getComponentType();
  63.                 }
  64.                 for(int i = 0; i < count; i++) {
  65.                     rtStr += "[";
  66.  
  67.                 }
  68.                 if(map.containsKey(oldClazz.getName())) {
  69.                     rtStr += map.get(oldClazz.getName());
  70.                 } else {
  71.                     rtStr += "L" + oldClazz.getName().replace(".", "/") + ";";
  72.                 }
  73.             } else {
  74.  
  75.                 rtStr = "L" + rt.getName().replace(".", "/") + ";";
  76.             }
  77.         }
  78.  
  79.         String descInfo = "(";
  80.  
  81.         for (Class<?> class1 : pt) {
  82.             String name = class1.getName();
  83.  
  84.             if(map.containsKey(name)) {
  85.                 descInfo += map.get(name);
  86.  
  87.             } else {
  88.                 if(class1.getComponentType() != null) {
  89.                     descInfo += class1.getName().replace(".", "/");
  90.  
  91.                 } else {
  92.  
  93.                     descInfo += ("L" + name.replace(".", "/") + ";");
  94.                 }
  95.             }
  96.  
  97.         }
  98.         descInfo += ")" + rtStr;
  99.         return descInfo;
  100.  
  101.     }
  102.  
  103. }

六、用于计算局部变量表的slot长度

  1. package com.asm_core;
  2.  
  3. /**
  4.  * 计算本地变量表的长度，long，double类型会占用两个slot
  5.  * @author may
  6.  *
  7.  */
  8. public class LocalLen {
  9.  
  10.     public static int len(Class<?>[] clzz) {
  11.  
  12.         int count = 0;
  13.  
  14.         for (Class<?> class1 : clzz) {
  15.  
  16.             String str = class1.getName();
  17.             if(str.equals("long") || str.equals("double")) {
  18.  
  19.                 count += 2;
  20.  
  21.             } else {
  22.  
  23.                 count ++;
  24.             }
  25.         }
  26.  
  27.         return count;
  28.     }
  29.  
  30. }

七、根据不同类型使用不同字节码指令助手类

  1. package com.asm_core;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. import org.objectweb.asm.Opcodes;
  7.  
  8. public class OpcodeMap {
  9.  
  10.     public static Map<String, Integer> map = new HashMap<>();
  11.  
  12.     static {
  13.  
  14.         map.put("int", Opcodes.ILOAD);
  15.  
  16.         map.put("byte", Opcodes.ILOAD);
  17.  
  18.         map.put("short", Opcodes.ILOAD);
  19.  
  20.         map.put("long", Opcodes.LLOAD);
  21.  
  22.         map.put("boolean", Opcodes.ILOAD);
  23.  
  24.         map.put("char", Opcodes.ILOAD);
  25.  
  26.         map.put("float", Opcodes.FLOAD);
  27.  
  28.         map.put("double", Opcodes.DLOAD);
  29.  
  30.     }
  31.  
  32.     public static int getOpcodes(String type) {
  33.  
  34.         if(map.containsKey(type)) {
  35.  
  36.             return map.get(type);
  37.  
  38.         } else {
  39.  
  40.             return Opcodes.ALOAD;
  41.         }
  42.  
  43.     }
  44.  
  45. }

八、根据不同的返回类型使用不同字节码指令的助手类

  1. package com.asm_core;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. import org.objectweb.asm.Opcodes;
  7.  
  8. public class OpcodeRt {
  9.  
  10.     public static Map<String, Integer> map = new HashMap<>();
  11.  
  12.     static {
  13.  
  14.         map.put("int", Opcodes.IRETURN);
  15.  
  16.         map.put("byte", Opcodes.IRETURN);
  17.  
  18.         map.put("short", Opcodes.IRETURN);
  19.  
  20.         map.put("long", Opcodes.LRETURN);
  21.  
  22.         map.put("boolean", Opcodes.IRETURN);
  23.  
  24.         map.put("char", Opcodes.IRETURN);
  25.  
  26.         map.put("float", Opcodes.FRETURN);
  27.  
  28.         map.put("double", Opcodes.DRETURN);
  29.  
  30.         map.put("void", Opcodes.RETURN);
  31.  
  32.     }
  33.  
  34.     public static int getOpcodes(String type) {
  35.  
  36.         if(map.containsKey(type)) {
  37.  
  38.             return map.get(type);
  39.  
  40.         } else {
  41.  
  42.             return Opcodes.ARETURN;
  43.         }
  44.  
  45.     }
  46.  
  47. }

九、自定义类加载器

  1. package com.asm_core;
  2.  
  3. public class MyClassLoader extends ClassLoader {
  4.  
  5.     private byte[] b = null;
  6.  
  7.     public MyClassLoader(byte[] b) {
  8.  
  9.         this.b = b;
  10.  
  11.     }
  12.  
  13.     @Override
  14.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  15.  
  16.         return this.defineClass(name, b, 0, b.length);
  17.     }
  18.  
  19. }

十、测试类

1】实现逻辑接口

  1. package com.asm_core.test;
  2.  
  3. import java.lang.reflect.Method;
  4.  
  5. import com.asm_core.logic.AddLogic;
  6.  
  7. /**
  8.  * 实现了方法逻辑的类
  9.  * @author may
  10.  *
  11.  */
  12. public class AddLogicImpl implements AddLogic {
  13.  
  14.     private Object sayHello;
  15.  
  16.     public AddLogicImpl(Object sayHello) {
  17.  
  18.         this.sayHello = sayHello;
  19.  
  20.     }
  21.  
  22.     @Override
  23.     public Object addLogic(Method method, Object[] args) throws Exception {
  24.  
  25.         System.out.println("Hello");
  26.         Object obj = method.invoke(sayHello, args);//我们可以在调用目标方法的周围增加逻辑
  27.         System.out.println("baby");
  28.         return obj;
  29.     }
  30.  
  31. }

2】被代理类

  1. package com.asm_core.test;
  2.  
  3. import java.util.Date;
  4.  
  5. /**
  6.  * 需要进行代理的类
  7.  * @author Administrator
  8.  *
  9.  */
  10. public class SayHello {
  11.  
  12.     public void sayHello(String str_1, String str_2, int age, String[] args) {
  13.  
  14.         System.out.println(str_1 + " " + str_2 + "嘿嘿：" + age);
  15.  
  16.     }
  17.  
  18.     private String l() {
  19.         System.out.println("private String l() {");
  20.         return "";
  21.  
  22.     }
  23.  
  24.     public int[][] tt(int age, long l, double d) {
  25.         System.out.println("public int[][] tt(int age) {");
  26.         return new int[][]{};
  27.     }
  28.  
  29.     public String[][] hh(long k, double d, Double dd) {
  30.         System.out.println("public String[][] hh(long k, double d, Double dd) {");
  31.         return null;
  32.     }
  33.  
  34.     public String[][] hh(short age, byte[] arg, int a, float f, char c, long l, double d, int[][] ii, String str, String[][] ss, Date date) {
  35.         System.out.println("public String[][] hh(short age, byte[] arg, int a, float f, char c, long l, double d, int[][] ii, String str, String[][] ss, Date date) {");
  36.         return null;
  37.     }
  38.  
  39.     /*public String[][] hh(Long l, Double d) {
  40.         System.out.println("public String[][] hh(short age, byte[] arg, double d) {");
  41.         return null;
  42.     }*/
  43.  
  44. }

3】Test

  1. package com.asm_core.test;
  2.  
  3. import java.util.Date;
  4.  
  5. import com.asm_core.GenSubProxy;
  6. import com.asm_core.logic.AddLogic;
  7.  
  8. public class Test {
  9.  
  10. public static void main(String[] args) {
  11.  
  12.         SayHello sayHello = new SayHello();
  13.  
  14.         AddLogic logic = new AddLogicImpl(sayHello);
  15.  
  16.         GenSubProxy genSubProxy = new GenSubProxy(logic);
  17.  
  18.         Object obj = genSubProxy.genSubProxy(SayHello.class);
  19.  
  20.         SayHello sh = (SayHello) obj;
  21.  
  22.         sh.hh((byte)1, new byte[]{}, 1, 1f, 's',1, 1, new int[][]{{12}}, "", new String[][]{{"sdf","s"}}, new Date());
  23.  
  24.         sh.sayHello("sg", "srt", 234, new String[]{});
  25.  
  26.     }
  27.  
  28. }

十一、总结

使用ASM实现动态代理，需要先学懂JVM虚拟机的字节码指令。在自己写字节码指令的时候，如果你忘记了某些代码的指令的实现，别忘记使用JDK的javap -c -v -private **.class。通过javap我们可以解决好多我们曾经感到疑惑的地方，比如为什么匿名内部类使用局部变量时这个局部变量不能变？为什么在字节码层面上不能直接将基本类型复制给Object类型？synchronized字节码中如何表述的。。。。。。

使用ASM实现动态代理的更多相关文章

  1. JDK、CGLIB、Javassist和ASM的动态代理使用对比

    动态代理是指在运行时,动态生成代理类.正如标题所示,能够提供动态代理的方式有很多.既然选择这么有很多,那么如何选择会更好呢? 带着这个疑问,我找到了Dubbo的作者--梁飞大神的一篇文章.文章中对四种 ...

  2. Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出 ...

  3. Java 动态代理机制详解（JDK 和CGLIB，Javassist，ASM）

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出 ...

  4. ASM字节码框架学习之动态代理

    ASM字节码操纵框架,可以直接以二进制的形式来来修改已经存在的类或者创建新的类.ASM封装了操作字节码的大部分细节,并提供了非常方便的接口来对字节码进行操作.ASM框架是全功能的,使用ASM字节码框架 ...

  5. Java动态代理机制详解（类加载，JDK 和CGLIB，Javassist，ASM）

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出 ...

  6. 设计模式7---Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出 ...

  7. JVM插码之四：Java动态代理机制的对比（JDK 和CGLIB，Javassist，ASM）

    一.class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件, ...

  8. java中动态代理的实现

    动态代理的实现 使用的模式:代理模式. 代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问.类似租房的中介. 两种动态代理: (1)jdk动态代理,jdk动态代理是由Java内部的反射机制 ...

  9. Java动态代理全面分析

    代理模式 解说:给某一个对象提供一个代理,并由代理对象控制对原对象的引用: 代理模式需要以下几个角色: 1  主题:规定代理类和真实对象共同对外暴露的接口: 2  代理类:专门代理真实对象的类: 3 ...

随机推荐

  1. Spring5源码深度分析(二)之理解@Conditional,@Import注解

    代码地址: 1.源码分析二主要分析的内容 1.使用@Condition多条件注册bean对象2.@Import注解快速注入第三方bean对象3.@EnableXXXX 开启原理4.基于ImportBe ...

  2. java编程思想之面向对象

    面向对象和面向过程 面向对象(Object Oriented),简称OO,是软件开发方法的一种,我们都知道java是基于面向对象开发的,但是说到面向对象,我们不得不提一提面向过程开发,面向过程,又称结 ...

  3. 第三章： Expressions and Flow Control

    第三章: Expressions and Flow Control一:局部变量和实例变量定义变量是指设定变量的数据类型和变量的名字,Java语言要求变量遵循先定义,再初始化,然后使用的规则.作用域:指 ...

  4. Django生成PDF显示在网页上以及解决中文显示乱码的问题

    项目地址:https://github.com/PythonerKK/django-generate-pdf/tree/master 这个demo实现了通过用户输入自己的个人信息生成一份简历pdf,来 ...

  5. django-haystack+whoosh+jieba实现中文全文搜索

    先上效果图 附上个人网站:https://liyuankun.cn 安装依赖库 注意:这里我们不安装django-haystack,因为要添加中文分词的功能很麻烦,所以我直接集成了一个中文的djang ...

  6. 不懂数据库索引的底层原理？那是因为你心里没点b树

    本文在个人技术博客不同步发布,详情可用力戳 亦可扫描屏幕右侧二维码关注个人公众号,公众号内有个人联系方式,等你来撩...   前几天下班回到家后正在处理一个白天没解决的bug,厕所突然传来对象的声音: ...

  7. leadcode的Hot100系列--104. 二叉树的最大深度

    依然使用递归思想. 思路: 1.树的深度 = max (左子树深度,右子树深度)+ 1 . ------> 这里的加1是表示自己节点深度为1. 2.如果当前节点为null,则说明它的左右子树深度 ...

  8. Linux部署项目常用命令

    前言:一般项目都会使用阿里云等服务器作为云服务器.此时必不可免会使用到一系列常用的命令.这里我整合一下常用的命令 1.一般链接阿里云服务器常用的的是xshell跟xftp. 下载路径:https:// ...

  9. 基于SpringBoot的Web API快速开发基础框架

    其实还是很因为懒,才会有这个案例项目的产生,每次开启一个终端的小服务都要整理一次框架,造成重复的.不必要的.缺乏创造性的劳动,SO,本着可以用.用着简单的原则上传代码到Github,希望有需要的朋友直 ...

  10. shell的用处到底大不大

    我曾在智联招聘等网站上搜寻有关shell脚本员的职位,与C++.JAVA等热门语言相比,冷清很多.看上去似乎招shell程序员的公司比较少.是不是公司不重视或者是很少用到shell这个东东呢?     ...