Spring系列：代理（jdk动态代理，cglib代理）

使用代理的目的：

1）为其他对象提供一种代理以控制对这个对象的访问.
2）方便系统的扩展和测试。

举例两个具体情况:
(1)如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代替真正的图片.

(2)如果那个对象在Internet的某个远端服务器上,直接操作这个对象因为网络速度原因可能比较慢,那我们可以先用Proxy来代替那个对象.

通用代理的2种实现：

1）jdk动态代理
2）cglib代理

1.jdk动态代理

jdk中为实现代理提供了支持，主要用到2个类：

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler

java.lang.reflect.Proxy：这是jdk动态代理中主要的一个类，主要用到里面有一些静态方法。

Proxy::getProxyClass方法：为指定的接口创建代理类，返回代理类的Class对象

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)
参数说明：
loader：定义代理类的类加载器
interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口

Proxy::newProxyInstance方法：创建代理类的实例对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是InvocationHandler类型的，这个是个借口如下：

public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;

上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler接口的invoke方法处理，所以主要代码需要卸载invoke方法中。

Proxy::isProxy方法：判断指定的类是否是一个代理类
Proxy::getInvocationHandler方法：获取代理对象的InvocationHandler对象

public static InvocationHandler getInvocationHandler(Object proxy)throws IllegalArgumentException

JDK动态代理不足之处：
1）调用主要是通过反射的方式，JVM中运行时的效率比较低，如果调用反射的频率比较高时，很容易成为系统中的性能瓶颈。不建议在循环中使用。
2）代理类只能是接口类型，不能是具体的实现类

JDK代理使用示例：方法功能扩展运行时间功能

 public class UserService implements IUserService {@Overridepublic void insert(String name) {System.out.println(String.format("用户[name:%s]插入成功!", name));}
}

使用Proxy::newProxyInstance 的方式实现JDK代理

/*
下面代码面主要是createProxy方法用来创建代理对象，2个参数：
target：目标对象，需要实现targetInterface接口
targetInterface：需要创建代理的接口
invoke方法中通过method.invoke(this.target, args)调用目标方法，然后统计方法的耗时。
使用的是Proxy.newProxyInstance方法
*/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class CostTimeInvocationHandler implements InvocationHandler {private Object target;public CostTimeInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long starTime = System.nanoTime();Object result = method.invoke(this.target, args);//@1long endTime = System.nanoTime();System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));return result;}/*** 用来创建targetInterface接口的代理对象** @param target          需要被代理的对象* @param targetInterface 被代理的接口* @param <T>* @return*/public static <T> T createProxy(Object target, Class<T> targetInterface) {if (!targetInterface.isInterface()) {throw new IllegalStateException("targetInterface必须是接口类型!");} else if (!targetInterface.isAssignableFrom(target.getClass())) {throw new IllegalStateException("target必须是targetInterface接口的实现类!");}return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));}
}

@Testpublic void costTimeProxy2() {IUserService serviceA = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);serviceA.insert("隔壁二牛");}

使用Proxy::getProxyClass 的方式实现JDK代理

@Testpublic void costTimeProxy3() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {UserService service = new UserService();Class<?> proxyClass = Proxy.getProxyClass(IUserService.class.getClassLoader(), IUserService.class);InvocationHandler invocationHandler = new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long starTime = System.nanoTime();Object result = method.invoke(service, args);//@1long endTime = System.nanoTime();System.out.println(service.getClass() + "." + method.getName() + "方法耗时(纳秒):" + (endTime - starTime));return result;}};IUserService serviceA =(IUserService)proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);serviceA.insert("隔壁二牛");}

Proxy使用注意

1.jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能
为力的，此时需要我们用到下面要说的cglib了。2.Proxy类中提供的几个常用的静态方法大家需要掌握3.通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接
口中的invoke方法进行处理，这个接口内容是关

2.cglib代理

cglib是一个强大、高性能的字节码生成库底层封装了ASM，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对final类进行代理操作。
ASM优势
ASM 能够通过改造既有类，直接生成需要的代码。增强的代码是硬编码在新生成的类文件内部的，没有反射带来性能上的付出。同时，ASM 与 Proxy 编程不同，不需要为增强代码而新定义一个接口，生成的代码可以覆盖原来的类，或者是原始类的子类。它是一个普通的 Java 类而不是 proxy 类，甚至可以在应用程序的类框架中拥有自己的位置，派生自己的子类。

相比于其他流行的 Java 字节码操纵工具，ASM 更小更快。ASM 具有类似于 BCEL 或者 SERP 的功能，而只有 33k 大小，而后者分别有 350k 和 150k。同时，同样类转换的负载，如果 ASM 是 60% 的话，BCEL 需要 700%，而 SERP 需要 1100% 或者更多。

cglib组成结构

cglib常见的用法

1.拦截所有方法（MethodInterceptor）
2.拦截所有方法并返回固定值（FixedValue）
3.直接放行，不做任何操作（NoOp.INSTANCE）
5.不同的方法使用不同的拦截器（CallbackFilter）
6.对第五条的优化（CallbackHelper）

1.拦截所有方法（MethodInterceptor）

public class Service1 {public void m1() {System.out.println("我是m1方法");}public void m2() {System.out.println("我是m2方法");}
}

import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class CglibTest {@Testpublic void test1() {//使用Enhancer来给某个类创建代理类，步骤//1.创建Enhancer对象Enhancer enhancer = new Enhancer();//2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类enhancer.setSuperclass(Service1.class);/*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/enhancer.setCallback(new MethodInterceptor() {/*** 代理对象方法拦截器* @param o 代理对象* @param method 被代理的类的方法，即Service1中的方法* @param objects 调用方法传递的参数* @param methodProxy 方法代理对象* @return* @throws Throwable*/@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("调用方法:" + method);//可以调用MethodProxy的invokeSuper调用被代理类的方法Object result = methodProxy.invokeSuper(o, objects);return result;}});//4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下Service1 proxy = (Service1) enhancer.create();//5.调用代理对象的方法proxy.m1();proxy.m2();}
}

上面代码中的注释很详细，列出了给指定的类创建代理的具体步骤，整个过程中主要用到了Enhancer类和MethodInterceptor接口。enhancer.setSuperclass用来设置代理类的父类，
即需要给哪个类创建代理类，此处是Service1enhancer.setCallback传递的是MethodInterceptor接口类型的参数，MethodInterceptor接口有个intercept方法，这个方法会拦截代理对象所有的方法调用。还有一个重点是
Object result = methodProxy.invokeSuper(o, objects);可以调用被代理类，也就是Service1类中的具体的方法，从方法名称的意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为Service1类创建了一个子类。

2.拦截所有方法并返回固定值（FixedValue）

@Testpublic void test3() {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(Service1.class);// 创建的代理对象，调用其任意方法返回的都是"路人甲"。enhancer.setCallback(new FixedValue() {@Overridepublic Object loadObject() throws Exception {return "路人甲";}});Service1proxy = (Service1) enhancer.create();System.out.println(proxy.m1());//@1System.out.println(proxy.m2()); //@2System.out.println(proxy.toString());//@3}

3.直接放行，不做任何操作（NoOp.INSTANCE）

 @Testpublic void test6() {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(Service1.class);// 不做任何处理，直接放行enhancer.setCallback(NoOp.INSTANCE);Service1proxy = (Service1) enhancer.create();System.out.println(proxy.m1());System.out.println(proxy.m2());}

5.不同的方法使用不同的拦截器（CallbackFilter）

public class Service4 {public void insert1() {System.out.println("我是insert1");}public void insert2() {System.out.println("我是insert2");}public String get1() {System.out.println("我是get1");return "get1";}public String get2() {System.out.println("我是get2");return "get2";}
}

/*** 需求，给这个类创建一个代理需要实现下面的功能：* 以insert开头的方法需要统计方法耗时* 以get开头的的方法直接返回固定字符串*/@Testpublic void test4() {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(Service4.class);//创建2个CallbackCallback[] callbacks = {//下面这个用来拦截所有get开头的方法，返回固定值的new FixedValue() {@Overridepublic Object loadObject() throws Exception {return "EXECUTE METHOD";}},//这个用来拦截所有insert开头的方法new MethodInterceptor() {@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {long starTime = System.nanoTime();Object result = methodProxy.invokeSuper(o, objects);long endTime = System.nanoTime();System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));return result;}}};enhancer.setCallbackFilter(new CallbackFilter() {@Overridepublic int accept(Method method) {return 0;}});//调用enhancer的setCallbacks传递Callback数组enhancer.setCallbacks(callbacks);/*** 设置过滤器CallbackFilter* CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法* 返回的是callbacks数组的下标*/enhancer.setCallbackFilter(new CallbackFilter() {@Overridepublic int accept(Method method) {//获取当前调用的方法的名称String methodName = method.getName();/*** 方法名称以insert开头，* 返回callbacks中的第1个Callback对象来处理当前方法，* 否则使用第二个Callback处理被调用的方法*/return methodName.startsWith("insert") ? 1 : 0;}});Service4 proxy = (Service4) enhancer.create();System.out.println("---------------");proxy.insert1();System.out.println("---------------");proxy.insert2();System.out.println("---------------");// proxy.get1();System.out.println(proxy.get1());// proxy.get2();System.out.println("---------------");System.out.println(proxy.get2());try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}}

6.对第五条的优化（CallbackHelper）

 /*** cglib中有个CallbackHelper类，可以对案例5的代码进行有环，CallbackHelper类相当于对一些代码进行了封装，* 方便实现案例5的需求，实现如下：*/@Testpublic void test5() {Enhancer enhancer = new Enhancer();//创建2个CallbackCallback costTimeCallback = (MethodInterceptor) (Object o, Method method, Object[] objects, MethodProxy methodProxy) -> {long starTime = System.nanoTime();Object result = methodProxy.invokeSuper(o, objects);long endTime = System.nanoTime();System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));return result;};//下面这个用来拦截所有get开头的方法，返回固定值的Callback fixdValueCallback = (FixedValue) () -> "EXECUTE METHOD";CallbackHelper callbackHelper = new CallbackHelper(Service4.class, null) {@Overrideprotected Object getCallback(Method method) {return method.getName().startsWith("insert") ? costTimeCallback : fixdValueCallback;}};enhancer.setSuperclass(Service4.class);//调用enhancer的setCallbacks传递Callback数组enhancer.setCallbacks(callbackHelper.getCallbacks());/*** 设置CallbackFilter,用来判断某个方法具体走哪个Callback*/enhancer.setCallbackFilter(callbackHelper);Service4 proxy = (Service4) enhancer.create();System.out.println("---------------");proxy.insert1();System.out.println("---------------");proxy.insert2();System.out.println("---------------");System.out.println(proxy.get1());System.out.println("---------------");System.out.println(proxy.get2());}

cglib实现通用的统计任意类方法耗时代理类

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class CostTimeProxy implements MethodInterceptor {//目标对象private Object target;public CostTimeProxy(Object target) {this.target = target;}@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {long starTime = System.nanoTime();//调用被代理对象（即target）的方法，获取结果Object result = method.invoke(target, objects); //@1long endTime = System.nanoTime();System.out.println(method + "，耗时(纳秒)：" + (endTime - starTime));return result;}/*** 创建任意类的代理对象** @param target* @param <T>* @return*/public static <T> T createProxy(T target) {CostTimeProxy costTimeProxy = new CostTimeProxy(target);Enhancer enhancer = new Enhancer();enhancer.setCallback(costTimeProxy);enhancer.setSuperclass(target.getClass());return (T) enhancer.create();}
}

用例：

@Test
public void test7() {//创建Service1代理Service1 service1 = CostTimeProxy.createProxy(new Service1());service1.m1();
}

CGLIB和Java动态代理的区别

1.Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类
的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；2.Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB使用ASM
框架直接对字节码进行操作，在类的执行过程中比较高效