写在最前面：关于代理模式，我准备写两篇博客。第一篇写基本的代理模式，并提供常用的代理工具类，第二篇在实战中如何使用代理模式----使用注解式AOP操作常用的Controller层代码。
另外推荐关于代理模式的深度好文：
代理模式（Proxy Pattern），静态代理 VS 动态代理
一、定义
代理模式：为目标对象提供一种代理以控制对目标对象的访问。在某些情况下，一个对象不适合或者不能直接引用目标对象（比如包访问权限的类），而代理对象可以在客户端和目标对象之间起到中介的作用， 其特征是代理类与委托类（真实对象）有同样的接口。
代理类就像秘书一样,为老板代理一些琐碎的事情，管事的还是老板。
二、分类
静态代理，JDK动态代理，Cglib动态代理。
三、静态代理
优点：不修改目标对象,同时对目标对象进行功能扩展。
缺点：类多，代码重复，维护难
1. 静态代理很麻烦，需要大量的代理类
代理类与目标类拥有相同的接口，每一个代理类只能代理一个目标类，如果目标类很多，那么代理类也会变得很多。
代理类与目标类拥有相同的接口，每一个代理类只能代理一个目标类，如果目标类很多，那么代理类也会变得很多。
2. 代码重复，因为代理类与目标类都实现了相同的接口，那么也就是说有两个类实现了这个接口，有很多重复的代码。
3.代码维护成本高
另外，如果接口增加了一个方法，那么实现类需要去实现这个方法，代理类也要去实现这个方法，这增加了代码维护的难度。
另外，如果接口增加了一个方法，那么实现类需要去实现这个方法，代理类也要去实现这个方法，这增加了代码维护的难度。
下面是一个简单的例子
package me.jay.designPattern;
/**
* Created by jay.zhou on 2018/4/19.
*/
//被代理的对象或者说是委托对象，实现了接口
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("后置处理，如记录操作时间");
}
public static void main(String[] args) {
//创建一个真实对象
Subject realObject = new Subject();
//创建一个代理对象
Proxy proxy = new Proxy(realObject);
//执行代理对象
proxy.function();
/**
* 运行结果:
* 增强操作，如 日志，安全，事务，缓存
* 主体操作
* 后置处理，如记录操作时间
*
*/
}
}
//业务接口，有一个function方法需要实现
interface Operation{
void function();
}
四、JDK动态代理
优点：代理类的字节码文件在程序运行的时候，由Java反射生成。
缺点：JDK动态代理只能代理有接口的目标类。
总是说“运行时”，到底什么才是运行时？运行时是指并不是在Java代码中定义的，而是相关Java类的字节码文件在JVM在运行的时候，根据我们在Java代码中的“指示”，动态的生成了相关类的字节码文件，就好比我们自己写了那个类一样。泛型也是这个道理。编译时是指，在JVM运行之前就定义好了相关的Java类。
下面是一个简单的例子
package me.jay.designPattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* Created by jay.zhou on 2018/4/19.
*/
public class DynamicProxy implements InvocationHandler{
//被代理的对象的引用，或者说是委托对象，也可以称它为真实对象
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
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 {
//前置增强
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是针对类来实现代理的，它生成目标类的一个子类作为代理类。缺点就是不能对final修饰的类进行代理，final修饰的类不能生成子类。
下面是一个简单的例子
package me.jay.designPattern;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* Created by jay.zhou on 2018/4/19.
*/
//要cglib与asm的相关jar包,这个类用于继承，重写intercept方法
public class CglibProxy implements MethodInterceptor {
//被代理的对象，或者是说是真实对象，委托对象
private Object target;
public CglibProxy(Object target) {
this.target = target;
}
/**
* 创建代理对象
*
* @return 创建出来的代理对象，是真实对象的一个子类
*/
public Object getInstance() {
//创建代理对象的工厂
Enhancer enhancer = new Enhancer();
//设置代理对象的父类是当前的真实对象
enhancer.setSuperclass(this.target.getClass());
// 回调方法，当调用代理对象的时候，让真实对象去操作
enhancer.setCallback(this);
// 创建代理对象，并返回
return enhancer.create();
}
/**
*
* @param proxy 代理对象的引用
* @param method 要被执行的方法
* @param args 方法参数
* @param methodProxy 为生成的代理类对方法的代理引用
* @return 方法执行的返回结果
* @throws Throwable
*/
@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("后置增强，用于记录数据,或者记录时间，将数据存到全局map中等");
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中等
*/
}
}
class Temp {
public void login(){
System.out.println("临时登录");
}
}
六、增强工具类例子
在类中添加抽象方法，让子类去继承它，实现其它增强的方法。这有点像拦截器的感觉了。重写invoke方法，父类的用super.invoke()方法回调。
package me.jay.designPattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* Created by jay.zhou on 2018/4/19.
*/
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 {
//调用被代理对象的业务方法
Object result = method.invoke(target, args);
return result;
}
}
分割线--------------------------------------------------------------------------------------------