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

后端 · 2020-11-14 ·

在现实生活中,常常会出现好多对象之间存在复杂的交互关系,这种关系常常是"网状结构",每个对象都必须知道它需要交互的对象。例如,一个班级里,每个人都必须记住他/她所有同学的电话,而且如果有一个人将电话修改了,他/她必须告诉其他所有同学,每个人都和其他剩下的人有关系,关系非常复杂。

如果把这种“网状结构”改为“星形结构”的话,将大大降低他们之间的“耦合性”,这是找一个“中间者”就可以了。如上说每个同学必须记住其他同学的电话,只要找一个“中间人”,将所有的同学的联系方式交由他维护,这样有一个人修改了电话,只需要告知“中间人”即可。还有银行也可以想象成一个中介者,管理着许多存款人和贷款人,存款的需要知道银行贷款给谁,或者贷款人无需知道存款的人是谁,存款人只需存款,贷款人只需贷款即可,无需关注太多的对象。

在软件开发系统中,这样的例子也很多,例如,在MVC框架中,控制器(C)就是模型(M)和视图(V)的中介者。

定义

定义了一个中介对象来封装一系列对象的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。

角色


中介者模式模式的主要角色如下:

  1. 抽象中介者角色:它是中介者的接口,提供了同学注册和转发同学对象信息的抽象方法。
  2. 具体中介者角色:实现中介者结构,定义一个List来管理同学对象,当有某个同学信息发生改变,将次改变转发给其他同学。
  3. 抽象同学类角色:定义同学类的接口,保存中介者对象,提供同学对象交互的抽象方法,实现所有相互影响的同学类的公共功能。
  4. 具体同学类角色:是抽象同学类的实现者,当需要其他同学对象交互时,将同学对象注册到中介者上,由中介者对象负责后续的交互。

代码

package xin.mla.mediator;

import java.util.ArrayList;
import java.util.List;

public class MediatorTest {

    public static void main(String[] args) {
        Classmate classmateA = new ConcreteClassmateA();
        Classmate classmateB = new ConcreteClassmateB();
        Classmate classmateC = new ConcreteClassmateC();
        Mediator mdeiator = new ConcreteMediator();
        mdeiator.register(classmateA);
        mdeiator.register(classmateB);
        mdeiator.register(classmateC);
        classmateB.send();

    }

}

// 抽象中介者
abstract class Mediator {
    abstract void register(Classmate classmate);

    abstract void relay(Classmate classmate);
}

// 具体中介者

class ConcreteMediator extends Mediator {
    private List<Classmate> classmates = new ArrayList<>();

    @Override
    void register(Classmate classmate) {
        if (!classmates.contains(classmate)) {
            classmates.add(classmate);
            classmate.setMedium(this);
        }
    }

    @Override
    void relay(Classmate classmate) {
        for (Classmate obj : classmates) {
            // 排除自身,告知其他同学
            if (!obj.equals(classmate)) {
                obj.receive();
            }
        }
    }

}

// 抽象同学类
abstract class Classmate {
    protected Mediator mediator;

    public void setMedium(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void receive();

    public abstract void send();
}

// 具体同学类
class ConcreteClassmateA extends Classmate {
    public void receive() {
        System.out.println("同学A收到请求");
    }

    public void send() {
        System.out.println("同学A改变他的联系方式,请求中介者转发");
        mediator.relay(this);
    }
}

// 具体同学类
class ConcreteClassmateB extends Classmate {
    public void receive() {
        System.out.println("同学B收到请求");
    }

    public void send() {
        System.out.println("同学B改变他的联系方式,请求中介者转发");
        mediator.relay(this);
    }
}

// 具体同学类
class ConcreteClassmateC extends Classmate {
    public void receive() {
        System.out.println("同学C收到请求");
    }

    public void send() {
        System.out.println("同学C改变他的联系方式,请求中介者转发");
        mediator.relay(this);
    }
}

优点

  1. 降低了对象之间的耦合性,是得对象易于独立的被复用。
  2. 提高系统的灵活性,使得系统易于维护和扩展。

缺点

  1. 当同学类太多时,中介者的职责将很大,以至于难以维护。
%