概述
AOP用到了两种动态代理来实现织入功能：
- jdk动态代理
- cglib动态代理
- 比较：
- jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。
- jdk动态代理的应用前提是目标类必须基于统一的接口。因此，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。
静态代理
- 建一个接口，接口中定义相应（代理对象和目标对象都要实现）的 方法
public interface Subject{
void test();
}
- 目标类（实现上述接口）
public class RealSubject implements Subject{
@Override
public void tset(){
System.out.printin("target method");
}
}
- 代理类（实现上述接口）
public class Proxy implements Subject{
private RealSubject realSubject;
public Proxy(RealSubject realSubject){
this.realSubject = realSubject;
}
@Override
public void test(){
System.out.printin("Before");
try{
realSubject.test();
}catch(Exception e){
System.out.println("ex:"+e.getmessage());
throw e;
}finally{
System.out.println("After");
}
}
}
- 客户端调用
public class Client{
public static void main(String[] args){
//通过接口
Subject subject = new Proxy(new RealSubject());
subject.test();
}
}
动态代理
（静态代理缺点:不灵活，重复代码多）
基于接口代理(jdk)
- 类:java.lang.reflect.Proxy(通过该类动态生成代理类)
- 代理类实现接口:InvocationHandler
- jdk代理只能基于接口动态代理(因为生成的proxy class中，继承了Proxy类，实现了需要代理的接口，而Java是单继承，多实现的处理方式)
- 动态代理类
- 实现接口的方法
- 引用目标方法
- 构造器注入目标方法
- 通过反射调用目标方法
public class JdkProxySubject implements InvocationHandler{
//引入要代理的真实对象
private RealSubject realSubject;
//用构造器注入目标方法，给我们要代理的真实对象赋初值
public JdkProxySubject(RealSubject realSubject){
this.realSubJect=realSubject;
}
//实现接口的方法
@Override
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
System.out.println("before");
Object result = null;
try{
//调用目标方法
//利用反射构造目标对象
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
result=method.invoke(realSubject,args);
}catch(Exception e){
System.out.println("ex:"+e.getMessage());
throw e;
}finally{
System.out.println("after");
}
return result;
}
}
- 客户端调用(使用Proxy)
public class Client{
public static void main(String[] args){
//使用Proxy构造对象
//参数
//java泛型需要转换一下
/* 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
* 第一个参数 getClassLoader() ，我们这里使用Client这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
* /
Subject subject = (Subject) java.lang.reflect.Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Subject.class},new JdkProxySubject(new RralSubject()));
//调用方法
subject.test;
}
}
原理解析
- 过程
- 调用Proxy.newProxyInstance生成代理类的实现类:
- 调用getProxyClass0寻找或生成指定代理类
(从缓存中取，如果没有，就生成一个放在缓存中 : 通过ProxyClassFactory生成)- 缓存调用ProxyClassFactory生成代理类,proxy class的生成最终调用ProxyClassFactory的apply方法.
- ProxyGenerator.generateProxyClass使用生成的代理类的名称，接口，访问标志生成proxyClassFile字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
- 生成字节码之后利用反射生成实例
Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。
- InvocationHandler接口:
-
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
-
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
我们看到这个方法一共接受三个参数，那么这三个参数分别代表什么呢？
－proxy: 指代我们所代理的那个真实对象
－method: 指代的是我们所要调用真实对象的某个方法的Method对象
－args: 指代的是调用真实对象某个方法时接受的参数
- Proxy类
-
Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：
这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
-
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
-
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法
-
h: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
基于继承代理(cglib)
- 代理类
public class CglibMethodInterceptor implements MethodInterceptor{//主要的方法拦截类，它是Callback接口的子接口，需要用户实现
@Override
public Object intercept(Object obj,Method method,Object
[] args,MethodProxy proxy )throws Throwable{
System.out.println("before cgplib");
Object result = null;
try{
//利用反射创建代理对象
result = proxy.invokeSuper(obj,args);
}catch(Exception e){
System.out.println("ex:"+e.getMessage());
throw e;
}finally{
System.out.println("after cglib");
}
return result;
}
}
- 调用类
public class Client{
public static void main(String[] args){
// 主要的增强类
Enhancer enhancer=new Enhancer;
// 目标类 , 设置父类，被增强的类
enhancer.setSuperclass(RealSubject.class);
// 回调对象
enhancer.setCallback(new CglibMethodInterceptor());
//生成代理类对象，用cglibProxy来增强RealSubject
Subject subject=enhancer.create();
subject.test();
}
}
原理解析
Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理：
CGLIB的核心类：
- net.sf.cglib.proxy.Enhancer – 主要的增强类
- net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
- net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：
- Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象，也不会出现死循环的问题。
-net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调（callback）类型，它经常被基于代理的AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法
public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable;
- 第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。
Java字节码生成开源框架–ASM：
ASM 是一个 Java 字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。
不过ASM在创建class字节码的过程中，操纵的级别是底层JVM的汇编指令级别，这要求ASM使用者要对class组织结构和JVM汇编指令有一定的了解。
喜欢的话可以点点关注，或者添加作者微信，欢迎随时来撩
