简单认识代理模式

代理模式的定义：
为其他对象提供一种代理以控制这个对象的访问。
这句话可以用图来表表示，一般的情况是：

使用代理模式后：
假设我们这里有

1. 玩家接口
2. 玩家的实现类

那么对应上图，我们就是用户，我们需要使用玩家的实现类去玩游戏，用类图来表示则是如下：
我们玩手游的时候，比如公主连接，每个月都会有公会战，搞得跟上班一样，我们不想打会战，会战给的水晶又是必不可少的，这时候我们就要找其他玩家帮我们代刀，代刀在使用我们号进行游玩的时候也是玩家，那他就必须要实现玩家的接口，并且需要活动要代刀的账号。
类图就会发展成下面的样子。

以下是代码实现

public class Proxy implements IPlayer{
    private IPlayer gameplayer = null;
    //获取需要代刀的玩家账号
    public Proxy(IPlayer _gameplayer){
        this.gameplayer = _gameplayer;
    }
    //用需要代刀的玩家账号登录
    public void login(){
        gameplayer.login();
    } 
    //用需要代刀的玩家账号来玩
    public void play(){
        gameplayer.play();
    }   
}

这样就完成了简单的一个静态代理类
在实际的场景类中，我们可以直接调用Proxy，就能够使用Player类内的方法。

什么是动态代理？

在静态代理中，我们代理一个Player类，我们就要写相应的Proxy类。
假如下一次我想代理不是Player的类，那我们是要把整个应用程序停下来写一个代理类吗？
显然不是，所以动态代理就是
在实现阶段不关心要代理谁，而是在运行期间才制定一个代理对象。
这个思想，跟反射几乎一模一样。

这样就是需要设计了一个万能的代理类，可以代理任何一种对象，
Java内置的JDK就有这样的类（如果代码能力深厚，可以自己实现一个这样的万能类）
这个类的作用相当于上面类图中的Proxy，不过他能够代理任何有接口的实现类（有接口相当重要，因为接口需要作为参数构造Proxy）。

当我们把接口传入Proxy的时候，Proxy会把设计好被代理接口的所有方法，默认的情况，就是把方法返回值都设置为空，显然，我们肯定不希望这种情况，因此我们还要定义接口类方法的实现。

我们看官方的API文档是怎么说的。
官方API文档上，实例Proxy类需要三个参数

1. 接口的类加载器
2. 接口的所有接口
3. 一个InvocationHandler类

1和2相当是用了反射的机制，让Proxy变成万能的。
第三个则是根据传入的接口，进行代理类的实现，让接受了某个接口的Proxy变成独一无二的。

因此我们还需要创建一个InvocationHandler的实例。
我们可以查看Java的API，知道他是个接口。

到这里，有反射基础的同学们一下子应该就会想起反射里面
“利用反射获取类的成员方法，并进行调用”这个知识点
那里同样就是使用了Invoke。
这里几乎是一模一样的。

至此，我们可以得到下面一串代码，来定义一个动态代理的实例。

步骤：
1、定义一个InnovationHandler实现类

public class PlayIH implements InnovationHandler{
    //被代理者
    Class cls = null;
    //被代理的实例
    Object obj = null;
    //构造函数,
    public PlayIH(Object _object){
        this.obj = _object; 
    } 
    
    //实现接口方法invoke
    public Object invoke(Object proxy,Method method,Object[] args]) throws Throwable{
        //如果这样写，就相当于对代理对象的所有方法都经过这个路线
        Object result = method.invoke(this.obj,args);
        //利用反射的知识，我们可以捕捉类方法的名字，然后对其进行针对性的操作
        // if("login".equals(method.getName())){
                 //执行代理方法
                 //returnValue = method.invoke(this.obj,"这里写入独特的参数");
                 //}       
        return result;
    }
}

2、在场景类中进行代理

public static void main(String[] args){
    //1、创建玩家实例
    IPlayer realplayer = new Player("真实的玩家");
    //2、定义一个handler实例
    InnocationHandler handler = new PlayIH(realplayer);
    //3、获取类加载器
    ClassLoader cl = realplayer.getClass().getClassLoader();
    //4、获取一个动态代理的实例
    IPlayer proxy = (IPlayer)Proxy.newInstance(cl,realplayer.getClass().getInterfaces(),handler);
    //代理登录
    proxy.login();
    //代理代刀
    proxy.play();
}

这就是AOP编程的核心，动态代理。

AOP编程没有使用什么新的技术，但是它对我们的设计、编码有非常大的影响，对于日志、事务、权限等都可以在系统设计阶段不用考虑，而在设计后通过AOP的方式切过去。（引自《设计模式之禅》）

而我们的类图其实可以画出：
文章主要参考：
《设计模式之禅 第二版》