一、定义
代理模式：为目标对象提供一种代理以控制对目标对象的访问。在某些情况下，一个对象不适合或者不能直接引用目标对象（比如包访问权限的类），而代理对象可以在客户端和目标对象之间起到中介的作用。
代理类就像秘书一样,为老板代理一些琐碎的事情，管事的还是老板。
为目标对象创建一个代理，以控制对它的直接访问。
二、分类
静态代理，JDK动态代理，Cglib动态代理。
三、静态代理
优点：静态代理本质上就是创建一个类的包装类，所以不用修改被代理的对象。
缺点：如果被代理的对象加了一个方法，那么代理类也要同步加一个方法。
下面是一个简单的例子
//被代理的对象或者说是委托对象，实现了接口public class Subject implements Operation{
@Override
public void function() {
System.out.println("主体操作");
}
}
//代理的对象，与委托对象实现了相同的接口
class Proxy implements Operation{
//持有委托对象的引用
private Subject subject;
//使用构造函数接收
public Proxy(Subject subject) {
this.subject = subject;
}
@Override
public void function() {
System.out.println("增强操作，如 日志，安全，事务，缓存");
subject.function();
System.out.println("后置处理，如记录操作时间");
}
}
四、JDK动态代理
优点：JDK动态代理把代理方法的处理都集中到了InvocationHandler这个类的实现中，所以方便统一增加类似于切面的功能，比如记录时间，增加日志、缓存等。
缺点：JDK动态代理只能代理接口的实现
根据我们在Java代码中的“指示”，动态的生成了相关类
下面是一个简单的例子
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxy implements InvocationHandler{
//被代理的对象的引用，或者说是委托对象，也可以称它为真实对象
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
public Object getInstance(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置增强
System.out.println("增强操作，如 日志，安全，事务，缓存");
//调用被代理对象的业务方法
Object result = method.invoke(target,args);
System.out.println("后置增强，用于记录数据,或者记录时间，将数据存到全局map中等");
return result;
}
public static void main(String[] args) {
//业务实现类实现了Operatino接口
Operation subject = new Subject();
//创建动态代理对象
DynamicProxy proxy = new DynamicProxy(subject);
//创建代理实例对象
Operation proxyInstance = (Operation)proxy.getInstance();
//调用代理对象的方法，包裹了真实对象的方法
proxyInstance.function();
}
}
五、Cglib动态代理
如果目标没有实现接口，那么可以用cglib动态代理。cglib是针对类来实现代理的，它生成目标类的一个子类作为代理类。
Cglib动态代理的缺点就是不能对final修饰的类进行代理，final修饰的类不能生成子类。
下面是一个简单的例子
import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxy implements MethodInterceptor {
//被代理的对象，或者是说是真实对象，委托对象
private Object target;
public CglibProxy(Object target) {
this.target = target;
}
public Object getInstance() {
//创建代理对象的工厂
Enhancer enhancer = new Enhancer();
//设置代理对象的父类是当前的真实对象
enhancer.setSuperclass(this.target.getClass());
// 回调方法，当调用代理对象的时候，让真实对象去操作
enhancer.setCallback(this);
// 创建代理对象，并返回
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
//前置增强
System.out.println("增强操作，如 日志，安全，事务，缓存");
Object result = method.invoke(target,args);
System.out.println("后置增强");
return result;
}
public static void main(String[] args) {
Temp temp = new Temp();
CglibProxy proxy = new CglibProxy(temp);
Temp tempInstance = (Temp)proxy.getInstance();
tempInstance.login();
/**
* 运行结果：
* 增强操作，如 日志，安全，事务，缓存
* 临时登录
* 后置增强，用于记录数据,或者记录时间，将数据存到全局map中等
*/
}
}
六、增强工具类例子
在类中添加抽象方法，让子类去继承它，实现其它增强的方法。这有点像拦截器的感觉了。重写invoke方法，父类的用super.invoke()方法回调。
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public abstract class DynamicProxy implements InvocationHandler{
//被代理的对象的引用，或者说是委托对象，也很称它为真实对象
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
//前处理
public abstract Object prehandle();
//后处理
public abstract Object posthandle();
public Object getInstance(){
/**
* 参数1：类加载器
* 参数2：被代理对象所实现的接口，我们动态生成的代理类也将实现这些接口
* 参数3：使用哪个调用处理器的invoke方法，当前就使用这个类的实例对象的invoke方法
*
*/
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
/**
*
* @param proxy 生成的代理对象的引用
* @param method 代理对象调用的方法
* @param args 参数数组
* @return 调用此方法的结果
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
prehandle();
//调用被代理对象的业务方法
Object result = method.invoke(target, args);
posthandle();
return result;
}
}
深度好文：
谈谈JAVA的代理模式认识 一——为什么使用代理模式
java的动态代理机制详解
代理模式（Proxy Pattern），静态代理 VS 动态代理
分割线--------------------------------------------------------------------------------------------
下一篇：代理设计模式9--使用AOP风格的代理模式
刻意练习
（1）一句话描述代理设计模式
（2）静态代理模式的优点与缺点
（3）JDK动态代理的缺点
（4）JDK动态代理的优点
（5）一般代理Controller，为什么用Cglib代理，而不用Jdk动态代理
（6） Cglib动态代理的一个比较常见的缺陷