代理模式和装饰模式非常类似，甚至代码都类似。二者最主要的区别是：代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能。我们日常看到的mybatis分页插件，以及日志拦截、事务拦截、权限拦截这些几乎全部由动态代理的身影。代理模式使用到极致开发就是AOP，这是各位采用Spring架构开发必然要使用到的技术，它就是使用了代理和反射的技术，后续会讲到。
UML图
静态代理和动态代理
代理分为静态代理和动态代理，静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能。
代码实现--静态代理
/**
* 接口
*/
public interface Subject {
void request();
void hello();
}
/**
* 接口的真实实现类
*/
public class RealSubject implements Subject {
@Override
public void request(){
System.out.println("From Real Subject");
}
@Override
public void hello() {
System.out.println("hello world");
}
}
/**
* 代理类
*/
public class ProxySubject implements Subject {
RealSubject subject = new RealSubject();
@Override
public void request() {
System.out.println("静态代理前置内容");
subject.request();
System.out.println("静态代理后置内容");
}
@Override
public void hello() {
System.out.println("静态代理前置内容");
subject.hello();
System.out.println("静态代理后置内容");
}
}
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
ProxySubject proxySubject = new ProxySubject();
proxySubject.hello();
System.out.println("------------");
proxySubject.request();
}
}
运行结果
静态代理前置内容
hello world
静态代理后置内容
静态代理前置内容
From Real Subject
静态代理后置内容
代码实现--动态代理
JDK动态代理
public interface Subject {
void hello();
}
public class SubjectImpl implements Subject {
@Override
public void hello() {
System.out.println("hello world");
}
}
public class MyInvocationHandler implements InvocationHandler {
private Object object;
public Object setProxy(Object o) {
this.object = o;
return Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("begin jdkProxy");
Object object = method.invoke(this.object, args);
System.out.println("end jdkProxy");
return object;
}
}
public class Client {
public static void main(String[] args) {
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
Subject subject = (Subject) myInvocationHandler.setProxy(new SubjectImpl());
subject.hello();
}
}
Cglib动态代理
public class Target {
public void eat() {
System.out.println("I am eating");
}
public String hello(String name) {
System.out.println("hello");
return "hello " + name;
}
}
public class Interceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("begin cglib proxy");
Object object = methodProxy.invokeSuper(o, objects);
System.out.println("end cglib proxy");
return object;
}
}
public class Client {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer(); //字节码增强器
enhancer.setCallback(new Interceptor()); //设置回调
enhancer.setSuperclass(Target.class); //设置被代理类为父类
Target target = (Target) enhancer.create(); //创建代理实例
target.eat();
target.hello("world");
}
}
总结一下
JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
Spring在使用两种动态代理时的机制
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
如何强制使用CGLIB实现AOP？
（1）添加CGLIB库，SPRING_HOME/cglib/*.jar
（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>
JDK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法， 因为是继承，所以该类或方法最好不要声明成final
源码分析详解参考以下两篇文章：
JDK动态代理源码分析详解
Cglib动态代理源码分析详解
