设计模式之中介者模式

就是把各个对象的交互放在一个公共的场所，也可以理解为第三方。通过公共场所来实现A来影响B。最典型的例子就是MVC。

我们先看看直接通过A来影响B，看看中介者模式的作用。a是b的100倍，a变化后会影响b变化。

直接影响

a和b的抽象类

abstract class AbstractColleague {
    protected  int number;

    public int getNumber(){
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    //抽象方法，修改数字时同时修改关联对象
    public abstract void setNumber(int number,AbstractColleague coll);
}

a对象

public class ColleagueA extends AbstractColleague {
    @Override
    public void setNumber(int number, AbstractColleague coll) {
        this.number = number;
        coll.setNumber(number*100);
    }
}

b对象

public class ColleagueB extends AbstractColleague{
    @Override
    public void setNumber(int number, AbstractColleague coll) {
        this.number = number;
        coll.setNumber(number/100);
    }
}

运行

public class Client {
    public static void main(String[] args) {
        AbstractColleague collA = new ColleagueA();
        AbstractColleague collB = new ColleagueB();

        System.out.println("==========设置A影响B==========");
        collA.setNumber(1288, collB);
        System.out.println("collA的number值："+collA.getNumber());
        System.out.println("collB的number值："+collB.getNumber());

//        System.out.println("==========设置B影响A==========");
//        collB.setNumber(87635, collA);
//        System.out.println("collB的number值："+collB.getNumber());
//        System.out.println("collA的number值："+collA.getNumber());

    }
}

业务操作写在实体中增加代码复杂度，可解性低。

使用中介者模式

中介者抽象类

/**
 * @author liuzonghua
 * @Package top.maniy.mediator
 * @Description: 抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。
 * @date 2019/12/18 16:50
 */
abstract class AbstractMediator {
    protected AbstractColleague A;
    protected AbstractColleague B;

    public AbstractMediator(AbstractColleague a, AbstractColleague b) {
        A = a;
        B = b;
    }

    public abstract void AaffectB();

    public abstract void BaffectA();

中介者实现类

public class Mediator extends AbstractMediator{
    public Mediator(AbstractColleague a, AbstractColleague b) {
        super(a, b);
    }
    //处理A对B的影响
    @Override
    public void AaffectB() {
        int number = A.getNumber();
        B.setNumber(number*100);
    }
    //处理B对A的影响
    @Override
    public void BaffectA() {
        int number = B.getNumber();
        A.setNumber(number/100);
    }
}

抽象类（使用中介者对象相关联）

abstract class AbstractColleague {
    protected  int number;

    public int getNumber(){
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    //抽象方法，修改数字时同时通过中介类修改关联对象
    public abstract void setNumber(int number,AbstractMediator am);
}

对象A

public class ColleagueA extends AbstractColleague {
    @Override
    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.AaffectB();
    }
}

对象B

public class ColleagueB extends AbstractColleague {
    @Override
    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.BaffectA();
    }
}

运行

public class Client {
    public static void main(String[] args){
        AbstractColleague collA = new ColleagueA();
        AbstractColleague collB = new ColleagueB();

        AbstractMediator am = new Mediator(collA, collB);

        System.out.println("==========通过设置A影响B==========");
        collA.setNumber(1000, am);
        System.out.println("collA的number值为："+collA.getNumber());
        System.out.println("collB的number值为A的10倍："+collB.getNumber());

//        System.out.println("==========通过设置B影响A==========");
//        collB.setNumber(1000, am);
//        System.out.println("collB的number值为："+collB.getNumber());
//        System.out.println("collA的number值为B的0.1倍："+collA.getNumber());


    }
}

中介者模式的优点

适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。
使用中介者模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。
使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

适用场景

在面向对象编程中，一个类必然会与其他的类发生依赖关系，完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍，
既然存在这样的情况，说明，一对多的依赖关系有它的合理性，适当的使用中介者模式可以使原本凌乱的对象关系清晰，但是如果滥用，
则可能会带来反的效果。一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用中介者模式。可以将网状结构变为星状结构，
使同事类之间的关系变的清晰一些。

中介者模式是一种比较常用的模式，也是一种比较容易被滥用的模式。对于大多数的情况，同事类之间的关系不会复杂到混乱不堪的网状结构，
因此，大多数情况下，将对象间的依赖关系封装的同事类内部就可以的，没有必要非引入中介者模式。滥用中介者模式，只会让事情变的更复杂。