设计模式---中介者模式

一、简介

? ? ? ? 一般来说，在软件开发中，类之间的关系是非常复杂的，往往每个类中都有很多其他对象的引用，形成一张复杂的网状结构，显得非常混乱，软件6大设计原则的迪米特法则告诉我们，一个类应尽可能的少于其他类发生交互，尽量提供一个中间类来完成，那么我们的中介者模式就是迪米特法则最好的实现。

? ? ? ? 中介者模式是行为型设计模式的一种，它的原始定义是：定义一个单独（中介）的对象，来封装一组对象之间的交互，将这组对象之间的交互委派给中介对象交互，避免对象直接交互。

? ? ? ? 中介者对象就是用于处理对象与对象之间的直接交互，封装了多个对象之间的交互细节，中介者设计模式更中间层很像，通过引入中介这个中间层将一组对象之间的交互关系从多对多的网状关系转换为一对多的星状关系，原来一个对象要跟n个对象交互，现在只需要跟中介对象交互就可以了，从而最小化对象之间的交互关系，降低代码的复杂度，提高代码的可读性和可维护性。

二、结构?

? ? ? ? 中介者模式的结构由以下几个角色组成：

? ? ? ? ①抽象中介者

? ? ? ? ②具体中介者

? ? ? ? ③抽象同事对象

? ? ? ? ④具体同事对象

三、实现

? ? ? ? 以现实生活中租房为例我们实现一下中介者，我们可以拆分为几个角色,

? ? ? ? ①租房用户（张三，李四.....）

? ? ? ? ②中介（链家，安居客...）

1）抽象中介者

/**
 * 抽象中介者
 */
public interface Intermediary {
    //用来同事对象之间交互
    void RentHouse(String money);
}

2）具体中介者

class LianJia implements  Intermediary{

    @Override
    public void RentHouse(int money) {
        if (money<800){
            System.out.println("对不起，未找到此价位的房子");
        }else {
            System.out.println("链家正在寻找价格合适的房子");
            System.out.println("链家已找到房子，位置xxxxx");
        }
    }
}

class AnJuKe implements  Intermediary{

    @Override
    public void RentHouse(int money) {
            System.out.println("安居客正在寻找价格合适的房子");
            System.out.println("安居客已找到房子，位置xxxxx");
    }
}

3）抽象同事类

/**
 * 抽象同事类
 */
public abstract class LookHouseUser {
    
    private Intermediary intermediary;//持有一个中介者引用

    public LookHouseUser(Intermediary intermediary) {
        this.intermediary = intermediary;
    }

    public Intermediary getIntermediary() {
        return intermediary;
    }
    
   abstract void lookHouse(int money);
}

4)具体同事类

 class LookHouseUserA extends LookHouseUser{

        public LookHouseUserA(Intermediary intermediary) {
            super(intermediary);
        }

        @Override
        void lookHouse(int money) {
            System.out.println("用户A寻找"+money+"元房子");
            getIntermediary().RentHouse(money);
        }
    }


class LookHouseUserB extends LookHouseUser{

    public LookHouseUserB(Intermediary intermediary) {
        super(intermediary);
    }

    @Override
    void lookHouse(int money) {
        System.out.println("用户B寻找"+money+"元房子");
        getIntermediary().RentHouse(money);
    }
}

5）客户端

public class Client {
    public static void main(String[] args) {
        //创建中介对象
        LianJia lianJia = new LianJia();
        AnJuKe anJuKe = new AnJuKe();

        //小明通过链家找500元房子
        LookHouseUserA userA = new LookHouseUserA(lianJia);
        userA.lookHouse(500);

        //小王通过安居客寻找800元房子
        LookHouseUserB userB = new LookHouseUserB(anJuKe);
        userB.lookHouse(800);

        /**
         *用户A寻找500元房子
         * 对不起，未找到此价位的房子
         * 用户B寻找800元房子
         * 安居客正在寻找价格合适的房子
         * 安居客已找到房子，位置xxxxx
         */
    }
}

通过上述代码，我们将租房子的动作交给了中介帮我们去完成，避免了两个类之间的直接交互，符合迪米特法则。

四、总结

优点

①简化了对象之间的交互，它用中介和同事的一对多交互代替了原来的同事之间的多对多交互，一对多关系更好理解，并且易于维护和扩展，将原本难以理解的网状结构变为星状结构。

②可以将各个同事对象进行解耦，中介者有利于各个同事之间的松耦合，可以独立的改变和复用某一同事或中介者，增加新的中介类和新的同事类都比较方便，符合开闭原则。

③可以较少子类的生成，中介者将原本分布于多个对象的行为集中在一起，改变这些行为我们只需要生成新的中介者子类即可，使得各个同事类可以被重用，而无需直接对同事类进行扩展。

缺点

①在具体的中介类中包含了大量同事之间的交互细节，可能导致中介者类变得非常复杂，不好维护

使用场景?

①系统中对象之间存在复杂的交互关系，系统 结构混乱且难以理解

②一个对象由于引用了其他的很多对象并且直接和这些对象进行通信，导致难以复用该对象

③想要通过一个中间类来封装多个类中的行为，而又不想生成太多的子类，此时可以引用中介类来实现，可以在中介者类中定义对象的交互的公共行为，如果需要改变行为则可以增加新的中介者类。