对于java里的代理，一直是一知半解，这次打算一次性解决这个问题。
我不打算按部就班的解释什么叫代理，而是从一个需求入手，来一步步的引出代理的概念
首先我们有一个项目，完成了一些功能。
在这个项目里面，我们有个UserManager的类，里面有个方法，叫addUser(User):
class UserManager{
public void addUser(User user){
//add a user
}
}
当我们开发完成后，我们突然发现，应该在addUser执行前添加一些东西（比如加个log，或者我们想把user存到缓存里面），而且我们也希望在addUser执行后再做一些事（比如加个log）
一个简单的办法就是我们直接修改方法：
public class UserManager{
public void addUser(User user){
//do something before
//add a user
//do something after
}
}
但是这时候会存在这么几种情况：
1. 需要加前置和后缀的方法很多
2. UserManager不是我们写的类，我不知道它里面的细节，也不想去改动它的代码，以免产生别的什么bug
3. 我压根儿没有UserManager的代码，我们拿到的就是一个jar包，无法修改类的代码
这时候，代理就出现了。
所谓的代理，是为其他对象提供一种代理以控制对这个对象的访问。
就是我们不直接调用我们想调用的类和方法，而是通过代理来调用。
比如说，如果你要买台电脑，你肯定不会直接去dell买，而且会选择去中关村，这里中关村就是一个代理。
还是上面的例子，如果我们使用代理的话，代码是这样的：
//接口
public interface Manager{
public void addUse(User user);
}//UserManager，我们稍微修改了一下，让它实现了Manager接口,而且我们也没有在UserManager里面去加入前置和后缀逻辑
public class UserManager implements Manager{
public void addUser(User user){
//add a user
}
}//代理类，在代理类的addUser方法中，我们调用了UserManager的addUser方法，同时我们增加了前置和后缀逻辑
public class UserManagerProxy implements Manager{
private UserManager manager = new UserManager();
public void addUser(User user){
//do something before
manager.addUser(user);
//do something after
}
}//测试代码，调用了代理类的addUser方法
public class TestProxy
{
public static void main(String args[])
{
Manager manager = new UserManagerProxy();
manager.addUser(user);
}
}代码结束。
可以看到，我们多写了不少代码，这段代码帮我们解决了一些问题，但是也带来了另外一些问题
解决的问题：
1. 我们成功的加入了前置和后缀，而且没有搞乱UserManager这个类的任何代码。你可以试想一下，如果我们要添加的代码，跟业务本身并没有什么关系，比如UserManager看名字是一个管理用户的类，而我们要添加的代码是几行log信息，或者是为了让addUser是一个事务（这个我们后面会讲到）。这个时候，我们把这些业务无关的代码掺杂到UserManager显然是不好的
另外一些问题：
1. 有多少个需要被代理的类(术语叫委托类，后面我们会用这个术语)，我们就需要写多少个代理类。如果需要被代理的类太多，对程序员来说也是一个不小的负担
2. UserManager居然必须要去实现一个接口！这样我还是动了UserManager的代码。而且如果UserManager只是一个jar包里面的类，那我该怎么办？
我们先来解决第一个问题：有多少个委托类，我们就需要写多少个代理类
上面的代理的实现，用一个术语叫做“静态代理”。从字面意思上我们也可以看出来，它跟委托类的关系是静态的，所谓的静态，指的是在代码编译期间，代理类和委托类的关系就确定了—-UserManagerProxy就是用来代理UserManager。在代码运行之前，两者就已经确认了关系，你无法来改变。
要解决第一个问题，可以用下面的代码来实现：
//接口我们还是跟静态代理保持一致
public interface Manager{
public void addUse(User user);
}//UserManager，我们也还是不需要修改
public class UserManager implements Manager{
public void addUser(User user){
//add a user
}
}/*但是这里我们不再使用静态代理类UserManagerProxy，而是换成了另外一个UserManagerHandler，并且实现了接口InvocationHandler，它是java.lang.reflect包里的一个接口，现在你不需要知道太多它的细节，只需要知道我们通常使用它来实现动态代理，而且我们要实现它里面的invoke方法*/
public class ManagerHandler implements InvocationHandler {
private Object target;
//绑定委托对象，并返回代理类
public Object bind(Object target)
{
this.target = target;
//绑定该类实现的所有接口，取得代理类
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
//这里的几个参数说明一下：proxy是代理类的实例，method是被代理类的方法，在这里也就是UserManager的addUer方法，args是被代理类方法的参数，在这里就是addUer方法的参数User
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//do something before
//method.invoke通过反射，调用了target类的method方法，一会我们会把target设置成UserManager的实例
Object value = method.invoke(target, args);
//do something after
return value;
}
}//测试类，可以看到，当我们bind方法传入了UserManager的实例后，调用了代理类的addUser方法，这样实际上执行的是UserManager类的addUser方法
public class TestProxy {
public void addUser(User user) {
ManagerHandler managerHandler = new UserManagerHandler();
(Manager) proxy = (Manager)managerHandler.bind(new UserManager());
proxy.addUser(user);
}
}代码结束。
可以看到，通过上面的代理，我们解决了问题：有多少个委托类，我们就需要写多少个代理类。
如果我们现在还有一个类，叫VIPManager（假设它也实现了接口Manager），那我们依旧可以通过代理类来代理它：
//只需要把UserManager的实例换成VIPManager的实例，方法可能不叫addUser而是addVIP了
public class TestProxy {
public void addUser(User user) {
ManagerHandler managerHandler = new UserManagerHandler();
(Manager) proxy = (Manager)managerHandler.bind(new VIPManager());
proxy.addVIP(user);
}
}而且，即便VIPManager没有实现Manager接口，而是实现了另外一个接口，比如ImportPerson接口，那我们还是可以代理它：
//把Manager接口换成ImportPerson
public class TestProxy {
public void addUser(User user) {
ManagerHandler managerHandler = new UserManagerHandler();
(ImportPerson) proxy = (ImportPerson)managerHandler.bind(new VIPManager());
proxy.addVIP(user);
}
}当然，你需要确保的是，VIPManager和UserManager所需要添加的前置和后缀业务是一样的。
也就是说，在这里，区分是否需要创建多个代理类的依据，由“有多少个委托类”，变成了“我需要额外添加的业务逻辑有多少种”
上面的这种代理模式，我们就解决了“有多少个委托类，我们就需要写多少个代理类”。而这种代理模式，我们叫做动态代理，区别于静态代理，我们可以看到，委托类跟代理类并没有绑死，我们可以用一个代理类来完成多个委托类的代理。
而且，我们还可以在代码运行期间来改变我们代理类所代理的委托类！
看到这里你可能会有疑问了，你的代码里面都写死了VIPManager或UserManager，类一旦装载到方法去，还怎么在代码运行期间来改变委托类？
这里就要提到另外一个知识点：声明式编程。同样这里你也无需了解太多，你只需要知道，java可以通过读取xml的声明，从而达到运行时修改代码（其实关于声明式编程你天天都在用，spring就是个典型的例子）
这样问题就迎刃而解了！我们通过XML配置，来声明我们是要传入一个VIPManager还是UserManager的实例，这样动态代理就完成了运行时才确认究竟代理哪个委托类（实际状况是，运行时才会创建一个代理类，而不是编译时就生成了ManagerProxy.class）！
问题一解决了，现在还剩下问题二：如果要使用代理，我们必须要实现接口
这里再引入一个知识点：CGLIB
cglib是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。
你可以从概念上看出来，这家伙就是为了在运行时改变代码而生
关于cglib我们不在这里展开讨论，但是你需要指导cglib有一个接口MethodInterceptor，我们可以用它来实现动态代理，而无需委托类实现接口。
//UserManager，现在它不再实现任何接口了，就是一个简单的类
public class UserManager{
public void addUser(User user){
//add a user
}
}public class CglibProxy implements MethodInterceptor{
//这是一个增强类（Enhancer的意思也是增强），我们需要用它来创建一个“增强的”UserManager
private Enhancer enhancer = new Enhancer();
//这个方法类似我们在上面动态代理里面的bind方法，用来创建一个代理类的实例，同时绑定委托类，所以这里的参数clazz我们一会会传入UserManager.class
public Object getProxy(Class clazz){
//设置需要创建子类的类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
//通过字节码技术动态创建子类实例
return enhancer.create();
}
//intercept是MethodInterceptor接口要实现的方法，类似于上面动态代理里面的invoke方法
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;
}
} //只需要把UserManager的实例换成VIPManager的实例，方法可能不叫addUser而是addVIP了
public class TestProxy {
public void addUser(User user) {
CglibProxy proxy = new CglibProxy();
//通过生成子类的方式创建代理类,这里传入了UserManager.class，说明委托类是UserManager
UserManager proxyImp = (UserManager)proxy.getProxy(UserManager.class);
proxyImp.addUser(user);
}
}代码结束。
可以看到，UserManager没有实现任何接口，但是我们还是完成了动态代理。
后记：
我们讲了3种模式：
静态代理，动态代理以及cglib动态代理
显然cglib动态代理更加实用。
那在实际应用中，动态代理到底能干什么呢？总不会只是加个log吧？
当然不是。
首先，大家有没有发现，动态代理非常非常类似我们的一个概念AOP（面向切面编程）。
而实际上，动态代理一个很大的作用就是用来实现AOP的，spring也是通过动态代理来实现的AOP。
而AOP可以干什么呢？
举几个例子：
1. 当然我们可以加log
2. 对于一些数据库的操作，我们做事务控制。对于所有以DAO结尾的类，所有的方法执行之前都要调用TransactionManager.begin()，执行之后都要调用TransactionManager.commit(), 如果抛出异常的话调用TransactionManager.rollback()。
3. 添加缓存。比如对于一些我们希望缓存起来是数据，调用redis的缓存方法，并且在获取的时候先检查缓存中是否存在，如果存在则直接返回缓存中的数据
举个添加缓存的例子吧：
//我们还是用UserManager，但是现在我们要处理的方法是getUser
public class UserManager{
public User getUser(String uid){
//访问数据库获取User数据,代码略
return User;
}
}public class CglibProxy implements MethodInterceptor{
private Enhancer enhancer = new Enhancer();
//这是我们自己写的一个缓存类，用来缓存数据
private Cached cached;
public Object getProxy(Class clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
//我们在intercept来实现写入缓存的业务
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
//获取我们要调用的方法的参数（这里我们一会要调用的是UserManager的getUser方法）
Type[] types = method.getParameterTypes();
//如果方法是以get开头，而且只有一个参数，且参数类型是String
if (method.getName().matches("get.+") && (types.length == 1) &&
(types[0] == String.class)) {
//获取参数，args是参数列表，还记得吧？
String key = (String) args[0];
//根据uid，看看我们的缓存里面有没有存过这个用户
Object value = cached.get(key);
//如果没有存，那我们就调用UserManager的getUser方法，并且把获取到的用户传入到我们的cached里面，如果存了，我们就不调用getUser方法，而直接返回缓存里面的User！而这个操作对于调用者来说是不知道的，他还会以为自己调用了getUser方法！
if (value == null) {
value = method.invoke(target, args);
cached.put(key, value);
}
return value;
}
//走到这里说明method没有满足我们的条件，也就是说不是getUser方法。当然你也可以通过筛选method，来让更多的method匹配我们的条件，比如getVIPUser(String)其实也会匹配我们的条件
return method.invoke(target, args);
}
} 代码结束。
怎么样，这样看来非常实用吧：
1. 没有修改UserManager的任何代码，对于UserManager来说，它甚至不知道代理类的存在
2. 在没有侵入UserManager的同时，我们给user做了缓存！！
3. 而且我们还不止给getUser做了缓存，我们还可以给getVIPUser，甚至addUser做一些更好的操作！！
4. 我们甚至在有缓存的情况下，没有调用getUser方法，减少了数据库的访问，而直接从缓存中返回了数据！！！
想象一下实际场景吧！
你完成了一个项目，在这个项目里，你从数据库读取数据展示给用户。
在项目上线后，随着用户的增多，你发现数据库读取扛不住了！
经过一系列分析和操作（比如读写分离）后，你发现给某些业务加个缓存可能是个不错的办法
当然，你也不是非常确定缓存一定能解决所有问题
这个时候，如果没有动态代理，你需要修改所有要加缓存的方法！！如果是个大项目，那代码里不会少了
更让人蛋疼的是，你不确定缓存能解决问题，所以可能修改了后，你还要改回来，或者改成别的！！
基本上要疯啊
而这个时候，如果你使用动态代理，那就是从地狱到天堂了？
你可以通过method来判断给哪些方法来加缓存，你可以通过args[]参数的个数和类型，来判断给哪些方法来加缓存
最重要的是，如果缓存解决不了问题，你还可以快速的换其他方案！！！
还有什么比这个更爽的=。=
OVER.