《大话》之第三者家族 代理 Vs 中介者

前两天，有个同学突然问我说：“我感觉代理模式和中介者模式不好区分，你能给我讲讲吗？”

刚开始还没敢张嘴，因为他突然一问，我貌似也不知道，经过整理，现在将结果贴出来，请大家共享

代理模式：

内容：为其他对象提供一种代理以控制对这个对象的访问

图文并茂：

用这个图，大家可以看到什么呢？客户？  No！从这个图上，我们可以看到，Subject，定义了RealSubject和Proxy（主体和代理）公用的接口，而代理却取而代之了

实战演练：

<span style="font-size:18px;"><strong>//定义  美女类，需要返回美女的姓名，咱得知道东西送给谁是不？
        class BeautifulGirl
        {
            private string name;
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
        }
        interface IGiveGift       //送礼物的借口，以下是三种送东西的方法
        {
            void GiveFlowers();
            void GiveDollew();
            void GivePen();
        }
        class Zhuti : IGiveGift     //主体，本来的冤大头，也就是花钱的人
        {
            BeautifulGirl mm;
            public Zhuti(BeautifulGirl mm)
            {
                this.mm = mm;
            }
            //自己花钱买鲜花送人
            public void GiveFlowers()
            {
                Console.WriteLine(mm.Name + "我送给你鲜花儿");
            }
            //自己花钱买洋娃娃送人
            public void GiveDollew()
            {
                Console.WriteLine(mm.Name + "我送给你洋娃娃");
            }
            //自己花钱买钢笔送人
            public void GivePen()
            {
                Console.WriteLine(mm.Name + "我送给你钢笔");
            }
        }
        //可是主体不好意思，或者是太懒，找了个送信的人帮他送信，还让他全权代表自己（傻帽，求爱的人千万不能学他）
        class Proxy : IGiveGift      //代理类   拥有所有主体能干的事，（送礼物），可是就是没有花钱
        {
            Zhuti gg;
            public Proxy(BeautifulGirl mm)
            {
                gg = new Zhuti(mm);
            }
            public void GiveFlowers()      //实现了和主体同样的接口
            {
                gg.GiveFlowers();
            }
            public void GiveDollew()
            {
                gg.GiveDollew();
            }
            public void GivePen()
            {
                gg.GivePen();
            }
        }
        //客户端代码
        static void Main(string[] args)
        {
            BeautifulGirl xiaohua = new BeautifulGirl();
            xiaohua.Name = "小花儿";
            Proxy zhangsan = new Proxy(xiaohua);//代理去干活了，可是却是署的自己的第一人称“我”，鬼知道我原来代                                                    表的是不是zhangsan
            zhangsan.GiveDollew();
            zhangsan.GiveFlowers();
            zhangsan.GivePen();
            Console.Read();
        }
    }</strong></span>

<span style="font-size:18px;color:#009900;"><strong>运行结果：</strong></span>

从这上面大家应该可以理解了吧，本来是zhuti要买东西送给美女的，可是他不好意思，要求代理者去为他送礼物，这也就使代理者和主体实现了同样的送礼物的接口，但是美女知道的是代理者送的礼物，根本就不认识主体，所有有关礼物的东西都被代理者拦断，无从深究。小花和主体之间根本就没有交互。而小花了解到的，也仅仅只是代理而已。就这样，一个第三者，堂而皇之的用老板的东西达到了泡妞的效果，气死老板了

这也就是说，代理模式是一种全权代理的方法，所有来的或者去的都是从代理发出，外界和代理的老板之间没有任何直接沟通的地方， 也就是说（这个代理者就是一个假冒的主体，真假美猴王，主体所有的方法，代理者全都可以实现），另一句话就是，没有代理的同意，没有人能联系了解主体，代理成为了外界访问主体的唯一通口

中介者模式：

内容：用一个中介对象来封装一系列的对象交互。中介者师哥对象不需要现实的相互应用，从而使其耦合松散，而且可以独立的改变它们之间的交互

图文并茂：

这个图就已经很明确了，下面就说说我的理解

其实这个中介者就相当于古代皇帝身边的传旨太监，对大臣传密旨说的时候“奉天承运，皇帝召曰，封……为工部侍郎，钦此”，大臣就会知道，哦哦，原来皇帝封我做大官了，然后“谢主隆恩”，当太监回到皇宫面见皇帝后对皇帝复命“某某大臣，对皇帝您感恩戴德，高呼万岁”。其实呢，皇帝封赏的时候压根就没见大臣，大臣山呼万岁的时候，皇帝也没见到，但是皇帝却知道是大臣山呼万岁，大臣也知道，是皇帝封赏了自己，这就是期间的这个中介者   太监   起到了作用，他领两者之间有了意义上的交互。

然而，被封赏的大臣不会仅是一位，这次是这位，下次可能就换成别人，但是太监会去向那些被封赏的大臣去宣旨，也就是说，太监会判断谁被封赏了，然后在去找他宣旨，专业点说，就是太监这个中介者，可以独立的改变 皇帝与大臣之间的交互。

实战：

<span style="font-size:18px;"><strong> abstract class Mediator  //定义抽象的送礼物发送信息的方法，得到人名和发送的信息
        {
            public abstract void IGiveGift(string gift, People person);
        }
        abstract class People
        {
            protected Mediator mediator;
            public People(Mediator mediator)   //构造方法，得到一个中介者对象
            {
                this.mediator = mediator;
            }
        }
        class ConcreteMediator : Mediator       //这里是所有的参与事件对象，李四，小花
        {
            private ConcretePeople1 lisi;
            private ConcretePeople2 xiaohua;
            public ConcretePeople1 Lisi
            {
                set { lisi = value; }
            }
            public ConcretePeople2 Xiaohua
            {
                set { xiaohua = value; }
            }
            public override void IGiveGift(string gift, People person)   //重写发送信息送礼物的方法，
            {
                if (person == lisi)
                {
                    xiaohua.Notify(gift);        //如果中介者见到的是李四，就把小花说的话告诉他
                }
                else
                {
                    lisi.Notify(gift);         //如果中介者见到的是小花 ，就把李四的话和东西，送给小花
                }
            }
        }
        class ConcretePeople1 : People
        {
            public ConcretePeople1(Mediator mediator)
                : base(mediator)
            {}
            public void IGiveGift(string gift)
            {
                mediator.IGiveGift(gift, this);    //这个礼物和信息都是中介者代为送达的
            }
            public void Notify(string gift)
            {
                Console.WriteLine("李四得到信息："+gift);
            }
        }
        class ConcretePeople2 : People
        {
            public ConcretePeople2(Mediator mediator)
                : base(mediator)
            {}
            public void IGiveGift(string gift)
            {
                mediator.IGiveGift(gift, this);
            }
            public void Notify(string gift)
            {
                Console.WriteLine("小花儿得到信息："+gift);
            }
        }
        //客户端代码
        static void Main(string[] args)
        {
            ConcreteMediator m = new ConcreteMediator();
            ConcretePeople1 lisi = new ConcretePeople1(m);
            ConcretePeople2 xiaohua = new ConcretePeople2(m);
            m.Lisi = lisi;
            m.Xiaohua = xiaohua;
            lisi.IGiveGift("我送你的钢笔、洋娃娃、鲜花儿，你喜欢吗？");   //要送的礼物  和  要说的话
            xiaohua.IGiveGift("我收到了你送的钢笔、洋娃娃、鲜花儿，我很喜欢");
            Console.WriteLine();
        }
    }</strong></span>

结果：

这期间的这个中介者，见到小花就像小花说李四的要对小花说的话；而见到李四呢，就像李四说小花想说的话，动态的判断了应该对谁说什么话。

如果在具体一点，更形象的就是中介所，假如有三个租房客，三个租房商，一个中介，三个租房客会对中介说自己的要租的房子的要求，而三个租房商会对中介说自己出租房子的价格、条件等等，其间，中介就会通过思考，配对，谁的房子适合谁，然后再进行联系，假如有一位租房客对房子不满意，那中介完全可以马上为他换另一个租房客的房子，实现了   独立的改变租房客与租房商之间的交互

总结：

中介者模式：  处于两组客户之间，为他们协调，合时宜的改变两组客户中某个和某个之间的交互

代理模式： 处于访问者和被访问者之间，所有的访问者想要访问被访问者的问题都要通过代理来回答，也就是说代理控制住了被访问者和外界的交流，只有通过代理，被访问者的答案才会被访问者知道