设计模式--中介者模式

Java工程源码

类图

---

定义
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互

–

优点
- 减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，降低了类间耦合性

–

使用场景
适用于对象之间紧密耦合的情况。实际中的应用如MVC框架(Struts(Controller)就是一个中介者，
它把M和V隔离开，协调M和V协同工作，减小M和V的依赖关系)。媒体网关,如MSN服务器(QQ)就是一个中转站，
而飞鸽(IPMsg)直接使用UDP广播方式，就没使用中介者

---

抽象同事类

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator _mediator) {
        this.mediator = _mediator;
    }
}

具体同事类1

public class ConcreteColleague1 extends Colleague {
    // 通过构造方法传递中介者
    public ConcreteColleague1(Mediator _mediator) {
        super(_mediator);
    }

    // 自有方法
    public void selfMethod() {
        System.out.println("同事1执行方法");
    }

    // 依赖方法,依赖中介者
    public void depMethod() {
        System.out.println("同事1找到中介者,让中介者找同事2->");
        // 自己不能处理的逻辑委托给中介者
        super.mediator.doSomething2();
    }
}

具体同事类2

public class ConcreteColleague2 extends Colleague {
    // 通过构造方法传递中介者
    public ConcreteColleague2(Mediator _mediator) {
        super(_mediator);
    }

    // 自有方法
    public void selfMethod() {
        System.out.println("同事2执行方法");
    }

    // 依赖方法,依赖中介者
    public void depMethod() {
        System.out.println("同事2找到中介者,让中介者找同事1->");
        // 自己不能处理的逻辑委托给中介者
        super.mediator.doSomething1();
    }
}

抽象中介者

public abstract class Mediator {
    // 定义同事类
    private ConcreteColleague1 c1;
    private ConcreteColleague2 c2;

    // 注入同事类
    public ConcreteColleague1 getC1() {
        return c1;
    }

    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }

    public ConcreteColleague2 getC2() {
        return c2;
    }

    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }

    // 中介者模式的业务逻辑
    public abstract void doSomething1();

    public abstract void doSomething2();
}

具体中介者

public class ConcreteMediator extends Mediator {

    @Override
    public void doSomething1() {
        // 调用同事类的方法
        System.out.print("中介者找到同事1->");
        super.getC1().selfMethod();
    }

    @Override
    public void doSomething2() {
        System.out.print("中介者找到同事2->");
        super.getC2().selfMethod();
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        // 中介者
        ConcreteMediator mediator = new ConcreteMediator();
        // 同事1
        ConcreteColleague1 c1 = new ConcreteColleague1(mediator);
        // 同事2
        ConcreteColleague2 c2 = new ConcreteColleague2(mediator);
        // 中介者可以找到同事1和同事2
        mediator.setC1(c1);
        mediator.setC2(c2);

        c1.selfMethod();
        // 同事1去找中介者
        c1.depMethod();
        c2.selfMethod();
        // 同事2去找中介者
        c2.depMethod();
    }
}

运行结果

同事1执行方法
同事1找到中介者,让中介者找同事2->
中介者找到同事2->同事2执行方法
同事2执行方法
同事2找到中介者,让中介者找同事1->
中介者找到同事1->同事1执行方法