代理模式 Java设计模式笔记

代理模式的作用：
      为一些对象提供一种代理关系，来控制对这个对象的访问，从而避免调用者对这个对象的直接调用，而起到中介、保护的作用。
代理模式的元素：
      代理存在于事物的“间接关系”之中，不可或缺的需要三种角色：抽象角色、代理角色、真实角色。这里边的抽象角色，是用来解释“代理行为关系”的。
代理模式的故事场景：
      时间回到三国，蜀魏两国掐起来了，诸葛亮又要搞曹操。战争这事儿上，除了武力值，更多的是玩智商，诸葛亮手底下的赵云啊、关兴啊、张苞啊要是直接去跟曹操磕，那根本不是个儿，弄不好直接就被逮去砍头了，所以啊，开战的时候，需要老谋深算的诸葛亮坐镇代理，一会儿让赵云去冲，一会儿让关兴去冲，一会儿让张苞去冲，歇会儿再让谁去冲，不是说六出岐山么，每次换着花样冲，才能让曹操烦不胜烦，头疼欲裂。
角色提取及代码实现：
      既然是两军对垒，诸葛亮赵云小关张等都是将军，都能发起冲锋，肯定要抽象出来一个将军类，我们用接口实现：

/**
 * @author Veiking
 * 定义一个将军接口，诸葛亮，赵云，小关张都是将军
 */
public interface General {
    //将军都会发起冲锋，进行攻击
    public void attacking(); 
}

    赵云是老同志，身经百战，模范将军

/**
 * @author Veiking
 * 定义一个赵云，子龙将军
 */
public class Zhaoyun implements General{
    @Override
    public void attacking() {
        System.out.println("我乃常山赵子龙！进攻...");
    }
}

    关兴、张苞，年少有为，都是将军

/**
 * @author Veiking
 * 定义关兴，小关将军;定义张苞，小张将军
 */
public class Guanxing implements General{
    @Override
    public void attacking() {
        System.out.println("我乃关兴！左勾拳，进攻...");
    }
}
public class Zhangbao implements General{
    @Override
    public void attacking() {
        System.out.println("我乃张苞！右勾拳，进攻...");
    }
}

    诸葛亮老成持重，足智多谋，是领军之将，但他毕竟上点年纪，体力不行，自己折腾不动，更多的功能是指挥作战，具体的冲锋陷阵，得别人来做。默认是赵云做贴身大将，当然，让谁来出战都行

/**
 * @author Veiking
 * 定义一个诸葛亮，诸葛孔明，神人也，喜欢扇扇子
 */
public class Zhugeliang implements General{
    //具体作战的将军
    General general;
    //默认构造函数，赵云，是革命老同志，比较靠谱，默认贴身大将
    public Zhugeliang(){
        general = new Zhaoyun();
    }
    //有时候赵云忙，也可以换个将军来做贴身大将军
    public Zhugeliang(General general){
        this.general = general;
    }
    //打仗不能只用一个将军，适当的可以换个人
    public void setGeneral(General general){
        this.general = general;
    }
    //这个是重点，所有将军都不例外，诸葛亮发起进攻
    @Override
    public void attacking() {
        System.out.println("我乃诸葛亮，别跑！进攻...");
        //当然，老诸葛自己肯定冲不动，冲锋陷阵这事儿，得让具体的将军来干
        this.general.attacking();
    }
    
    ...
    //孔明的个性，招牌动作，多冷都能扇 again and again ...
    public void playFan(){
        System.out.println("羽扇羽扇，帮我算算...");
    }
}

    好，蜀国的诸位将军已经安排妥当，接下来，就该到曹操的营盘上来闹事儿了

/**
 * @author Veiking
 * 曹操的领地，跑来闹事儿的地方
 * （这里曹操领地System.out.println的“旁白”，自然是曹操说的，注意）
 */
public class CaocaoPlace {
    public static void main(String[] args) {
        //众将听命...兵贵诡，军情机密，赵云小关张都猫起来，随时战备出战
        General zhaoyun = new Zhaoyun();
        General guanxing = new Guanxing();
        General zhangbao = new Zhangbao();
        //诸葛亮出现了，蜀军叫阵，大战在即
        Zhugeliang zhugeliang = new Zhugeliang();
        //情节需要，先摇下扇子
        zhugeliang.playFan();
        System.out.println("孔明？！");
        zhugeliang.attacking();
        System.out.println("孔明？！...原来是赵云啊，我挡！");
        //换关兴上
        zhugeliang.setGeneral(guanxing);
        zhugeliang.attacking();
        System.out.println("孔明？！...原来是小关啊，我再挡！");
        //换张苞上
        zhugeliang.setGeneral(zhangbao);
        zhugeliang.attacking();
        System.out.println("孔明？！...原来是小张啊，我再挡！");
        //再换关兴上
        zhugeliang.setGeneral(guanxing);
        zhugeliang.attacking();
        System.out.println("孔明？！...小关怎么又来了，再挡！");
        //再换赵云上
        zhugeliang.setGeneral(zhaoyun);
        zhugeliang.attacking();
        System.out.println("孔明？！...擦，怎么又...受不了了...");
        //情节需要，扇子不能停...
        zhugeliang.playFan();
        ...
        //换了一拨又一拨...
        System.out.println("孔明？！...擦，头痛...");
        ...
        //冲了一次又一次...
        System.out.println("孔明？！...头痛欲裂...");
        //注意，这里边各位蜀将若是不自报家门，曹司令至死都不知道跟自己磕的是谁
    }
}

      据说，诸葛亮是这样去找曹操麻烦，整整六次，让曹头痛不已，最后抢救无效，薨。
小结：
      这里边诸葛亮做的是蜀国将军大代理，有效的避免暴露手下将军智力方面短板，又发挥了他们骁勇善战的长处，算是一举两得，并且无论哪位将军有事儿忙，随时可替补更换，不影响整个事情的发展；从程序的角度来说，代理类这边处理好对外业务，真实类处理好具体事物行为，只要都对接口负责就可以了。

=====================================================
代理模式++ 动态代理：
      代理模式中我们使用代理角色来代理一类真实角色，如果要代理的真实角色种类非常多，可以是将军也可以是小兵，甚至还可以是军马战畜，这时候一个代理类是不能满足所需功能的，代码量可想而知。事实上，诸葛亮管好将军们已经实属不易，如果还去管小兵、车马，那可就要早早累死了。于是“动态代理”横空出世，java引入的动态代理机制，完美的让诸葛亮晋级军师，成为一代大神。
代码实现：
      想发动“动态代理”大招，要引入这三个重要类InvocationHandler、Method、Proxy，其功能暂不表述，且听下回分说，先看诸葛孔明如何做些许改动

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/** 
 * @author Veiking 
 * 定义一个动态诸葛亮，这个诸葛亮不简单，更像个军事
 */ 
public class DynamicZhugeliang implements InvocationHandler {
    private Object obj;
    //一看，参数都Object类了，基本可以包罗万象，什么都可以传进来了
    DynamicZhugeliang(Object obj) {
        this.obj = obj;
    }
    //被代理实际对象的方法代理，这绝对操心的到位，扇子摇一摇，啥事都搞定
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //出招前后，扇子要摇一摇……
        System.out.println("before doing 。。。 羽扇羽扇，帮我算算...");   
        result = method.invoke(obj, args);//
        System.out.println("after doing 。。。 羽扇羽扇，帮我算算...");
        return result;
    }
    //对传进来的任何真实对象，都进行动态生成相应的代理对象，孔明有了这招，几近无敌！
    public static Object proxy(Object obj) {
        Class clazz = obj.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new DynamicZhugeliang(obj));
    }
}

      曹操的领地也要做一点点改动

/**
 * @author Veiking 曹操的动态领地，跑来闹事儿的地方 （旁白还是帮曹操说的）
 */
public class DynamicCaocaoPlace {
    public static void main(String[] args) throws Throwable {
        //将旗招展，大写一个“将”字，是谁出战骚扰，不知道
        General general = null;
        //众将听命...兵贵诡，军情机密，赵云小关张都猫起来，随时战备出战  
        General zhaoyun = new Zhaoyun();  
        General guanxing = new Guanxing();  
        General zhangbao = new Zhangbao();
        //注意诸葛亮在这时候，已经不惜的出来露脸了，只是默默的摇扇子做他的大代理，指挥各位将军轮番闹阵（当然，催催粮草啊，治理国家啊，只要有具体角色提取，都基本不是事儿了）……
        general = (General) DynamicZhugeliang.proxy(zhaoyun);
        general.attacking();
        System.out.println("谁？！...原来是赵云啊，我挡！"); 
        general = (General) DynamicZhugeliang.proxy(guanxing);
        general.attacking();
        System.out.println("谁？！...原来是小关啊，我再挡！");  
        general = (General) DynamicZhugeliang.proxy(zhangbao);
        general.attacking();		
        System.out.println("谁？！...原来是小张啊，我再挡！");  
        ...
        //可怜曹司令，又是一阵头疼……
    }
}

小结：
      话不多说，仅凭诸葛亮的factory方法的参数Object就知道，他已经逆天了，其中动态代理的奥妙，下次笔记细聊。

（故事纯属瞎构，代码仅供参考）