中介者模式

一、简述

中介者模式（Mediator Pattern），使用一个中介对象封装一系列的对象交互，让得各对象之间没有明显的交互，并且能够独立的改变对象之间的交互（可能说的有点绕T_T）。看看这张图，就能理解了。

简单的说就是，中介者对象聚合了对象的交互，其他的对象都是通过中介者对象进行交互，没有直接的交互。这个可以想象一下租房，中介手里有房东的房子，你找中介租房，中介就是你和房东之间的那个中介对象。

虽然跳过中介直接找房东更加便宜，但是相对的，中介起的作用也简化和房东扯皮的一些过程

二、UML类图

• Mediator：抽象中介者，定义了同事对象到中介者对象的接口
• ConcreteMediator：具体的中介者角色，继承抽象中介者，实现了父类定义的方法，负责具体的同事对象之间的交互
• Colleague：抽象同事类， 定义了中介者对象接口，只与中介者交互，不与其他同时对象交互
• ConcreteColleagueA/B：具体的同事类，继承抽象的同事类，每个具体同事类都知道本身小范围内的行为，不知道自身在大范围的目的

其实这样描述，有没有觉得很像MVC模式中的Controller（当然在Controller里面的代码可能不会像中介者模式这样降低View之间的耦合），也是起到Module和View聚合的一个作用，使Module和View的耦合性降低。

二、简单实现

直接实现房客找中介联系房东的过程，首先是抽象中介者。

public abstract class Mediator {
    public  abstract void constact(Person person,String message);
}

然后是抽象的同事类

public class Person {
    protected String name;
    protected Mediator mediator;

    public Person(String name,Mediator mediator){
        this.name = name;
        this.mediator = mediator;
    }
}

接下来就是创建两个具体的同事类了，也就是HouseOwner房东和Tenant租客

public class HouseOwner extends Person {
    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }


    /**
     * @desc 与中介者联系
     * @param message
     * @return void
     */
    public void constact(String message){
        mediator.constact(this,message);
    }

    /**
     * @desc 获取信息
     * @param message
     * @return void
     */
    public void getMessage(String message){
        System.out.println("房主:" + name +",获得信息：" + message);
    }
}

public class Tenant extends Person{

    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }

    /**
     * @desc 与中介者联系
     * @param message
     * @return void
     */
    public void constact(String message){
        mediator.constact(this,message);
    }

    /**
     * @desc 获取信息
     * @param message
     * @return void
     */
    public void getMessage(String message){
        System.out.println("租房者:" + name +",获得信息：" + message);
    }
}

接下来就需要具体的中介者，将房东和租客聚合起来

public class MediatorStructure extends Mediator {
    //首先中介结构必须知道所有房主和租房者的信息
    private HouseOwner houseOwner;
    private Tenant tenant;

    public HouseOwner getHouseOwner() {
        return houseOwner;
    }

    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }

    public Tenant getTenant() {
        return tenant;
    }

    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }

    @Override
    public void constact(Person person, String message) {
        if (person == houseOwner) {
            //如果是房主，则租房者获得信息
            tenant.getMessage(message);
        } else {
            //反正则是房主获得信息
            houseOwner.getMessage(message);
        }
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //一个房主、一个租房者、一个中介机构
        MediatorStructure mediator = new MediatorStructure();

        //房主和租房者只需要知道中介机构即可
        HouseOwner houseOwner = new HouseOwner("包租婆", mediator);
        Tenant tenant = new Tenant("酱爆", mediator);

        //中介结构要知道房主和租房者
        mediator.setHouseOwner(houseOwner);
        mediator.setTenant(tenant);

        tenant.constact("怎么停水啦？");
        houseOwner.constact("你没交水费");
    }
}

输出结果：
房主:包租婆,获得信息：包租婆，怎么停水啦？
租房者:酱爆,获得信息：打死你呀的！！

三、总结

优点：

• 简化对象之间的关系，将系统的各个对象之间的相互关联进行封装，将各个同事类解耦
• 使多对多得关系变为了一对多的关系，简化对象之间的直接交互

缺点

• 由于中介者对象封装了系统中对象之间的交互，导致器变得非常复杂，随着同事类的增加，维护难度会逐渐增大

其实中介者模式的缺点和优点在android中的MVC模式体现的都很明显，所有的交互逻辑在Controller中，但是交互复杂之后经常导致Controller对象过于臃肿，难以维护更加不要说扩展了

——————————————————————————————————
作者：MrTrying
链接：https://www.jianshu.com/p/4a47a899d80c
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

作者：MrTrying
链接：https://www.jianshu.com/p/4a47a899d80c
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。