代理模式：动态代理与静态代理
In the Spring Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy。
动态代理的两种方式：JDK动态代理与CGLIB代理
默认情况下，Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的，而对于类的代理使用CGLIB来实现。
1.JDK动态代理
如何使用JDK动态代理。JDK提供了java.lang.reflect.Proxy类来实现动态代理的，可通过它的newProxyInstance来获得代理实现类。同时对于代理的接口的实际处理，是一个java.lang.reflect.InvocationHandler，它提供了一个invoke方法供实现者提供相应的代理逻辑的实现。可以对实际的实现进行一些特殊的处理，像Spring AOP中的各种advice。下面来看看如何使用。
//被代理的接口
package com.mikan.proxy;
public interface HelloWorld {
void sayHello(String name);
}
接口的实现类：
package com.mikan.proxy;
public class HelloWorldImpl implements HelloWorld {
@Override
public void sayHello(String name) {
System.out.println("Hello " + name);
}
}
实现一个java.lang.reflect.InvocationHandler：
package com.mikan.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class CustomInvocationHandler implements InvocationHandler {
private Object target;
public CustomInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invocation");
Object retVal = method.invoke(target, args);
System.out.println("After invocation");
return retVal;
}
}
使用代理：
package com.mikan.proxy;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) throws Exception {
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
CustomInvocationHandler handler = new CustomInvocationHandler(new HelloWorldImpl());
HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(),new Class[]{HelloWorld.class}, handler);
proxy.sayHello("Mikan");
}
}
运行的输出结果：
localhost:classes mikan$ java com/mikan/proxy/ProxyTest
Before invocation
Hello Mikan
After invocation
从上面可以看出，JDK的动态代理使用起来非常简单，但是只知道如何使用是不够的，知其然，还需知其所以然。
所以要想搞清楚它的实现，那么得从源码入手。这里的源码是1.7.0_79。首先来看看它是如何生成代理类的：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
// 这里是生成class的地方
Class<?> cl = getProxyClass0(loader, intfs);
// 使用我们实现的InvocationHandler作为参数调用构造方法来获得代理类的实例
try {
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
return AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return newInstance(cons, ih);
}
});
} else {
return newInstance(cons, ih);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
}
其中newInstance只是调用Constructor.newInstance来构造相应的代理类实例，这里重点是看getProxyClass0这个方法的实现：
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
// 代理的接口数量不能超过65535（没有这种变态吧）
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理
return proxyClassCache.get(loader, interfaces);
}
可以看到，动态生成的代理类有如下特性：
1） 继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
2） 提供了一个使用InvocationHandler作为参数的构造方法。
3） 生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。
4） 重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。
5） 代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。
2.JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。
简单的实现举例：
这是一个需要被代理的类，也就是父类，通过字节码技术创建这个类的子类，实现动态代理。
public class SayHello { public void say(){ System.out.println("hello everyone"); } }
该类实现了创建子类的方法与代理的方法。getProxy(SuperClass.class)方法通过入参即父类的字节码，通过扩展父类的class来创建代理对象。intercept()方法拦截所有目标类方法的调用，obj表示目标类的实例，method为目标类方法的反射对象，args为方法的动态入参，proxy为代理类实例。proxy.invokeSuper(obj, args)通过代理类调用父类中的方法。
public class CglibProxy implements MethodInterceptor{ private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz){ //设置需要创建子类的类 enhancer.setSuperclass(clazz); enhancer.setCallback(this); //通过字节码技术动态创建子类实例 return enhancer.create(); } //实现MethodInterceptor接口方法 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("前置代理"); //通过代理类调用父类中的方法 Object result = proxy.invokeSuper(obj, args); System.out.println("后置代理"); return result; } }
具体实现类：
public class DoCGLib { public static void main(String[] args) { CglibProxy proxy = new CglibProxy(); //通过生成子类的方式创建代理类 SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class); proxyImp.say(); } }
输出结果：
前置代理
hello everyone
后置代理
3.CGLIB与JDK动态代理之间的比较：
JDK代理需要实现某个接口，而CGLIB却没有此限制。
CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。
————————————————————————————————————————————
备注：aop pointcut表达式（*）
execution（方法修饰符+返回值 完整类名+方法名（方法参数））
例如：
A、execution(public void *(..))：所有返回值是public void的方法都会被拦截到
B、execution(public void day6.com.beans.PersonService.*(..))：表示day6.com.beans.PersonService下所有返回值是public void的方法都会被拦截到
C、execution(public void day6.com.beans.PersonService.save(java.lang.String...))：表示day6.com.beans.PersonService类中的第一个形参类型是String的save方法会被拦截到
D、execution(public void save(..))：表示所有类中的save方法会被拦截到
E、execution(public void day6.com.service..*(..))：表示day6.com.service包下的类以及子包的类所有public void方法都会被拦截到
F、execution(public !void day6.com.service..*(..))：表示day6.com.service包下的类以及子包的类所有public 不是void返回类型的方法都会被拦截到
end