[Java] 静态代理

什么叫代理？什么是静态代理？什么是动态代理？
Java 动态代理模式
代理:一个角色代表另一个角色来完成某些特定的功能。
比如：生产商，中间商，客户这三者这间的关系
客户买产品并不直接与生产商打交道，也不用知道产品是如何产生的，客户只与中间商打交道，而中间商就可以对产品进行一些包装，提供一些售后的服务。
* 代理模式有三个角色: 1. 抽象主题角色 2. 代理主题角色 3. 实际被代理角色
下面我们来个一个静态代理的实现。
我以一个坦克为例。
1, 现在我们来建立一个java项目，叫Proxy，建立一个类，叫Tank, 继续建立一个接口，
叫 Moveable, 我们用 Tank 来实现 Moveable（意思就是坦克实现移动）
抽象主题角色：Moveable

package com.bjsxt.proxy;

public interface Moveable {
    void move();
}

代理主题角色：TanktimeProxy

package com.bjsxt.proxy;

public class TankTimeProxy implements Moveable {
    
    Moveable t;
    
    public TankTimeProxy(Moveable t) {
        super();
        this.t = t;
    }
    
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        System.out.println("starttime : " + start);
        t.move();
        long end = System.currentTimeMillis();
        System.out.println("time :  " + (end - start));
    }
}

实际被代理对象：Tank

package com.bjsxt.proxy;

import java.util.Random;

public class Tank implements Moveable {

    @Override
    public void move() {
        System.out.println("Tank Moving...");
        try {
            Thread.sleep(new Random().nextInt(10000)); // 产生  100  毫秒  (10秒 ) 以内的随机数
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

测试：TestTank.java

package com.bjsxt.proxy;

public class TestTank {
    public static void main(String[] args) {
        Tank t = new Tank();
        Moveable move = new TankTimeProxy(t);
        move.move();
    }
}

从上例可以看到代理主题角色：TanktimeProxy实现了对Tank的move()方法运行时间的计算，而TanktimeProxy，Tank都实现了Moveable接口，通过调用TanktimeProxy的move()方法我们可以实现对Tank的move()方法的运行时间的计算，而不用在Tank的move()方法中作任何实现，这就是代理的作用。代理实现时TanktimeProxy，Tank必需实现Moveable接口。

下面我想在 TanK 的 move() 方法前后加上日志：

我必需再写一个类来实现这一功能：

package com.bjsxt.proxy;

public class TankLogProxy implements Moveable {
    
    Moveable t;
    
    public TankLogProxy(Moveable t) {
        super();
        this.t = t;
    }

    @Override
    public void move() {
        System.out.println("Tank start");
        t.move();
        System.out.println("Tank end");
    }
}

测试：

package com.bjsxt.proxy;

public class Client {
    public static void main(String[] args) throws Exception {
        
        Tank t = new Tank(); // 最初的代理对象
        TankTimeProxy ttp = new TankTimeProxy(t);
        TankLogProxy tlp = new TankLogProxy(ttp);
        Moveable m = tlp;
        /* 时间包日志
         *   
         *  TankLogProxy tlp = new TankLogProxy(t);      
         *  TankTimeProxy ttp = new TankTimeProxy(tlp);
         *  Moveable m = ttp;
         * 
         * */
        m.move();
    }
}
// 可以对任意的对象、任意的接口方法，实现任意的代理

这样我通过代理在Tank的move()方法前后加入了日志和时间统计的功能，由于TanktimeProxy，TanklogProxy都实现了Moveable接口，所以TanklogProxy可以代理TanktimeProxy，反过来也可以，它们对Tank的代理顺序是可以交换的。满足我们的要求，如果现在我们要先时间，再日志，我们只需要修改一下测试类就oK

这上面的就可以叫静态代理

现在有出现了一个问题？如果我现在有多个类，那我是不是要去实现多个计时，多个日志，那不是和刚才的继承一样，造成了类的大量产生(重复),这样显然是不合理的，那我们带怎么办喃？我们现在就可以使用动态代理

如果我想在Tank的move()方法调用的前后加入更多的功能，是不是要写更多的代理主题角色，这样子会使得代码过于臃肿，不易于维护，那有没有什么办法可以解决呢，答案是可以的，我们可以动态的来生成代理主题角色，来代理所有的被代理对象，这就是动态代理。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

动态代理-你不必知道我存在
理解 Spring 的 AOP
假设：
(1), 具备面向对象的设计思维
(2), 了解多态的概念
(3), 大致了解反射（非必须）
真实案例
(1), 想知道一个方法的运行时间
@1), 继承 VS 聚合 (一个类有另一个类的对象)
tank2 与 tank3 其实都是代理的方法。 tank2与tank3都是代理类

Tank2.java

package com.bjsxt.proxy;

public class Tank2 extends Tank {

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        super.move();
        long end = System.currentTimeMillis();
        System.out.println("time :  " + (end - start));
    }
}

继承实现代理有缺点。实现interface的实现代理好

这两个哪个好喃？

如果现在我们还要增加一个日志的功能，如果是继承，我们还要写一个类来继承Tank2，但是用户又说，我要求先日志，在计算时间，那么是不是又要写个类来实现movaable接口，来修改喃，这样就会造成类的无限增长，这显然是不合理的，所以我们要用聚合。。聚合，无论你增加多少功能，我都可以互相交换.