标签：byte class method acea 类装载 target 没有权限 rtb ems
AOP就是面向切面编程，我们可以从以下几个层面来实现AOP
以下是各种实现机制的比较：
| 类别 | 机制 | 原理 | 优点 | 缺点 |
|---|---|---|---|---|
| 静态AOP | 静态织入 | 在编译期，切面直接以字节码的形式编译到目标字节码文件中 | 对系统无性能影响 | 灵活性不够 |
| 动态AOP | 动态代理 | 在运行期，目标类加载后，为接口动态生成代理类，将切面织入到代理类中 | 相对于静态AOP更加灵活 |
切入的关注点需要实现接口。 对系统有一点性能影响 |
| 动态字节码生成 | CGLIB | 在运行期，目标类加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中 | 没有接口也可以织入 | 扩展类的实例方法为final时，则无法进行织入 |
| 自定义类加载器 | 在运行期，目标加载前，将切面逻辑加到目标字节码里 | 可以对绝大部分类进行织入 | 代码中如果使用了其他类加载器，则这些类将不会被织入 | |
| 字节码转换 | 在运行期，所有类加载器加载字节码前进行拦截 | 可以对所有类进行织入 |
织入器通过在切面中定义pointcout来搜索目标（被代理类）的JoinPoint（切入点），然后把要切入的逻辑（Advice）织入到目标对象里，生成代理类
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了
动态代理：即在运行期动态创建代理类，使用动态代理实现AOP需要4个角色：
例子演示的是在方法执行前织入一段记录日志的代码，其中
public interface IBusiness { void doSomeThing(); } public interface IBusiness2 { void doSomeThing2(); } public class Business implements IBusiness, IBusiness2 { @Override public void doSomeThing() { System.out.println("执行业务逻辑"); } @Override public void doSomeThing2() { System.out.println("执行业务逻辑2"); } }
package aop; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * 打印日志的切面 */ public class LogInvocationHandler implements InvocationHandler { private Object target;//目标对象 public LogInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //执行织入的日志，你可以控制哪些方法执行切入逻辑 if (method.getName().equals("doSomeThing2")) { System.out.println("记录日志"); } //执行原有逻辑 Object recv = method.invoke(target, args); return recv; } }
package aop; import java.lang.reflect.Proxy; public class Main { public static void main(String[] args) { //需要代理的类接口，被代理类实现的多个接口都必须在这这里定义 Class[] proxyInterface = new Class[] {IBusiness.class, IBusiness2.class}; //构建AOP的Advice，这里需要传入业务类的实例 LogInvocationHandler handler = new LogInvocationHandler(new Business()); //生成代理类的字节码加载器 ClassLoader classLoader = Business.class.getClassLoader(); //织入器，织入代码并生成代理类 IBusiness2 proxyBusiness = (IBusiness2) Proxy.newProxyInstance(classLoader, proxyInterface, handler); proxyBusiness.doSomeThing2(); ((IBusiness)proxyBusiness).doSomeThing(); } }
执行结果：
记录日志
执行业务逻辑2
执行业务逻辑
本节将结合动态代理的源代码讲解其实现原理
动态代理的核心其实就是代理对象的生成，即Proxy.newProxyInstance(classLoader, proxyInterface, handler)
让我们进入newProxyInstance方法观摩下，核心代码就三行：
//获取代理类 Class cl = getProxyClass(loader, interfaces); //获取带有InvocationHandler参数的构造方法 Constructor cons = cl.getConstructor(constructorParams); //把handler传入构造方法生成实例 return (Object) cons.newInstance(new Object[] { h });
getProxyClass(loader, interfaces)方法用于获取代理类，它主要做了三件事情：
查找代理类getProxyClass(loader, interfaces)方法：
1 // 缓存的key使用接口名称生成的List 2 Object key = Arrays.asList(interfaceNames); 3 synchronized (cache) { 4 do { 5 Object value = cache.get(key); 6 // 缓存里保存了代理类的引用 7 if (value instanceof Reference) { 8 proxyClass = (Class) ((Reference) value).get(); 9 } 10 if (proxyClass != null) { 11 // 代理类已经存在则返回 12 return proxyClass; 13 } else if (value == pendingGenerationMarker) { 14 // 如果代理类正在产生，则等待 15 try { 16 cache.wait(); 17 } catch (InterruptedException e) { 18 } 19 continue; 20 } else { 21 //没有代理类，则标记代理准备生成 22 cache.put(key, pendingGenerationMarker); 23 break; 24 } 25 } while (true); 26 }
生成加载代理类：
//生成代理类的字节码文件并保存到硬盘中(默认不保存到硬盘) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces); //使用类加载器将字节码加载到内存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
代理类生成过程ProxyGenerator.generateProxyClass()方法的核心代码分析：
//添加接口中定义的方法，此时方法体为空 for (int i = 0; i < this.interfaces.length; i++) { localObject1 = this.interfaces[i].getMethods(); for (int k = 0; k < localObject1.length; k++) { addProxyMethod(localObject1[k], this.interfaces[i]); } } //添加一个带有InvocationHandler的构造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1); //循环生成方法体代码（省略） //方法体里生成调用InvocationHandler的invoke方法代码。（此处有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;") //将生成的字节码，写入硬盘，前面有个if判断，默认情况下不保存到硬盘。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class"); localFileOutputStream.write(this.val$classFile);
通过以上分析，我们可以推出动态代理为我们生产了一个这样的代理类。把方法soSomeThing的方法体修改为调用LogInvocationHandler的invoke方法
代码如下：
public class ProxyBusiness implements IBusiness, IBusiness2 { private LogInvocationHandler h; @Override public void doSomeThing2() { try { Method m = (h.target).getClass().getMethod("doSomeThing", null); h.invoke(this, m, null); } catch (Throwable e) { // 异常处理（略） } } @Override public boolean doSomeThing() { try { Method m = (h.target).getClass().getMethod("doSomeThing2", null); return (Boolean) h.invoke(this, m, null); } catch (Throwable e) { // 异常处理（略） } return false; } public ProxyBusiness(LogInvocationHandler h) { this.h = h; } //测试用 public static void main(String[] args) { //构建AOP的Advice LogInvocationHandler handler = new LogInvocationHandler(new Business()); new ProxyBusiness(handler).doSomeThing(); new ProxyBusiness(handler).doSomeThing2(); } }
从前两节的分析我们可以看出，动态代理在运行期通过接口动态生成代理类，这为其带来了一定的灵活性，但这个灵活性却带来了两个问题：
使用动态字节码生成技术实现AOP原理是在运行期间目标字节码加载后，生成目标类的子类，将切面逻辑加入到子类中，所以cglib实现AOP不需要基于接口
本节介绍如何使用cglib来实现动态字节码技术。
cglib是一个强大的、高性能的Code生成类库，它可以在运行期间扩展Java类和实现Java接口，它封装了Asm，所以使用cglib前需要引入Asm的jar
1 package cglib; 2 3 /** 4 * 这个是没有实现接口的实现类 5 */ 6 public class BookFacadeImpl { 7 public void addBook() { 8 System.out.println("增加图书的普通方法。。。"); 9 } 10 11 public void deleteBook() { 12 System.out.println("删除图书的普通方法。。。"); 13 } 14 }
1 package cglib; 2 3 import net.sf.cglib.proxy.Enhancer; 4 import net.sf.cglib.proxy.MethodInterceptor; 5 import net.sf.cglib.proxy.MethodProxy; 6 7 import java.lang.reflect.Method; 8 9 /** 10 * 使用cglib动态代理 11 */ 12 public class BookFacadeCglib implements MethodInterceptor { 13 14 private Object target; 15 16 /** 17 * 创建代理对象 18 * 19 * @param target 20 * @return 21 */ 22 public Object getInstance(Object target) { 23 this.target = target; 24 Enhancer enhancer = new Enhancer(); 25 enhancer.setSuperclass(this.target.getClass()); 26 //回调方法 27 enhancer.setCallback(this); 28 //创建代理 29 return enhancer.create(); 30 } 31 32 //回调方法 33 @Override 34 public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 35 if (method.getName().equals("addBook")) { 36 System.out.println("记录增加图书的日志"); 37 } 38 methodProxy.invokeSuper(obj, args); 39 return null; 40 } 41 }
package cglib; /** * 测试cglib字节码代理 */ public class TestCglib { public static void main(String[] args) { BookFacadeCglib cglib = new BookFacadeCglib(); BookFacadeImpl bookFacade = (BookFacadeImpl) cglib.getInstance(new BookFacadeImpl()); bookFacade.addBook(); bookFacade.deleteBook(); } }
执行结果：
记录增加图书的日志
增加图书的普通方法。。。
删除图书的普通方法。。。
如果我们实现了一个自定义类加载器，在类加载到JVM之前直接修改某些类的方法，并将切入逻辑织入到这个方法里，然后将修改后的字节码文件交给虚拟机运行，那岂不是更直接
Javassist是一个编辑字节码的框架，可以让你很简单地操作字节码。它可以在运行期定义或修改Class。使用Javassist实现AOP的原理是在字节码加载前直接修改需要切入的方法
这比使用cglib实现AOP更加高效，并且没有太多限制，实现原理如下图：
我们使用类加载器启动我们自定义的类加载器，在这个类加载器里加一个类加载监听器，监听器发现目标类被加载时就织入切入逻辑
清单1：启动自定义的类加载器
//获取存放CtClass的容器ClassPool ClassPool cp = ClassPool.getDefault(); //创建一个类加载器 Loader cl = new Loader(); //增加一个转换器 cl.addTranslator(cp, new MyTranslator()); //启动MyTranslator的main函数 cl.run("jsvassist.JavassistAopDemo$MyTranslator", args);
清单2：类加载监听器
public static class MyTranslator implements Translator { public void start(ClassPool pool) throws NotFoundException, CannotCompileException { } /* * * 类装载到JVM前进行代码织入 */ public void onLoad(ClassPool pool, String classname) { if (!"model$Business".equals(classname)) { return; } //通过获取类文件 try { CtClass cc = pool.get(classname); //获得指定方法名的方法 CtMethod m = cc.getDeclaredMethod("doSomeThing"); //在方法执行前插入代码 m.insertBefore("{ System.out.println(\"记录日志\"); }"); } catch (NotFoundException e) { } catch (CannotCompileException e) { } } public static void main(String[] args) { Business b = new Business(); b.doSomeThing2(); b.doSomeThing(); } }
输出：
执行业务逻辑2
记录日志
执行业务逻辑
从本节中可知，使用自定义的类加载器实现AOP在性能上有优于动态代理和cglib，因为它不会产生新类，但是它仍人存在一个问题，就是如果其他的类加载器来加载类的话，这些类就不会被拦截
自定义类加载器实现AOP只能拦截自己加载的字节码，那么有一种方式能够监控所有类加载器加载的字节码吗？
有，使用Instrumentation，它是Java5的新特性，使用Instrument，开发者可以构建一个字节码转换器，在字节码加载前进行转换
本节使用Instrumentation和javassist来实现AOP
首先需要创建字节码转换器，该转换器负责拦截Business类，并在Business类的doSomeThing方法前使用javassist加入记录日志的代码
1 public class MyClassFileTransformer implements ClassFileTransformer { 2 3 /** 4 * 字节码加载到虚拟机前会进入这个方法 5 */ 6 @Override 7 public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, 8 ProtectionDomain protectionDomain, byte[] classfileBuffer) 9 throws IllegalClassFormatException { 10 System.out.println(className); 11 //如果加载Business类才拦截 12 if (!"model/Business".equals(className)) { 13 return null; 14 } 15 16 //javassist的包名是用点分割的，需要转换下 17 if (className.indexOf("/") != -1) { 18 className = className.replaceAll("/", "."); 19 } 20 try { 21 //通过包名获取类文件 22 CtClass cc = ClassPool.getDefault().get(className); 23 //获得指定方法名的方法 24 CtMethod m = cc.getDeclaredMethod("doSomeThing"); 25 //在方法执行前插入代码 26 m.insertBefore("{ System.out.println(\"记录日志\"); }"); 27 return cc.toBytecode(); 28 } catch (NotFoundException e) { 29 } catch (CannotCompileException e) { 30 } catch (IOException e) { 31 //忽略异常处理 32 } 33 return null; 34 }
使用premain函数注册字节码转换器，该方法在main函数之前执行
public class MyClassFileTransformer implements ClassFileTransformer { public static void premain(String options, Instrumentation ins) { //注册我自己的字节码转换器 ins.addTransformer(new MyClassFileTransformer()); } }
需要告诉JVM在启动main函数之前，需要先执行premain函数。
首先，需要将premain函数所在的类打成jar包，并修改jar包里的META-INF\MANIFEST.MF文件
1 Manifest-Version: 1.0 2 Premain-Class: bci. MyClassFileTransformer
其次，在JVM的启动参数里加上-javaagent:D:\java\projects\opencometProject\Aop\lib\aop.jar
执行main函数，你会发现切入的代码无侵入性的织入进去了
1 public static void main(String[] args) { 2 new Business().doSomeThing(); 3 new Business().doSomeThing2(); 4 } 5
输出：
1 model/Business 2 sun/misc/Cleaner 3 java/lang/Enum 4 model/IBusiness 5 model/IBusiness2 6 记录日志 7 执行业务逻辑 8 执行业务逻辑2 9 java/lang/Shutdown 10 java/lang/Shutdown$Lock
从输出中可以看到系统类加载器加载的类也经过了这里
Spring默认采取动态代理机制实现AOP，当动态代理不可用时（代理类无接口）会使用cglib机制
但Spring的AOP有一定的缺点：
public IMsgFilterService getThis() { return (IMsgFilterService) AopContext.currentProxy(); } public boolean evaluateMsg () { // 执行此方法将织入切入逻辑 return getThis().evaluateMsg(String message); } @MethodInvokeTimesMonitor("KEY_FILTER_NUM") public boolean evaluateMsg(String message) {
public boolean evaluateMsg () { // 执行此方法将不会织入切入逻辑 return evaluateMsg(String message); } @MethodInvokeTimesMonitor("KEY_FILTER_NUM") public boolean evaluateMsg(String message) {
http://www.iteye.com/topic/1116696
标签：byte class method acea 类装载 target 没有权限 rtb ems
原文地址：http://www.cnblogs.com/xiaoxiao7/p/6057724.html
