【设计模式】—— 中介者模式Mediator

　　前言：【模式总览】——————————by xingoo

　　模式意图

　　使用一个中介的对象，封装一组对象之间的交互，这样这些对象就可以不用彼此耦合。

　　这个中介者常常起着中间桥梁的作用，使其他的对象可以利用中介者完成某些行为活动，因此它必须对所有的参与活动的对象了如指掌！

　　应用场景

　　1 当一组对象要进行沟通或者业务上的交互，但是其关系却又很复杂混乱时，可以采用此模式。

　　2 当一个对象与其他的对象要进行紧密的交互，但又想服用该对象而不依赖其他的对象时。

　　3 想创造一个运行于多个类之间的对象，又不想生成新的子类时。

　　模式结构

　　【设计模式】—— 中介者模式Mediator

　　Mediator 抽象的中介者，定义中介的规范

interface Mediator{
    public void colleagueChanged(Colleague c);
}

　　ConcreteMediator 具体的中介者，通常内部依赖于多个业务对象

class ConcreteMediator implements Mediator{
    private Colleague1 col1;
    private Colleague2 col2;
    public void colleagueChanged(Colleague c) {
        col1.action();
        col2.action();
    }
    public void createConcreteMediator() {
        col1 = new Colleague1(this);
        col2 = new Colleague2(this);
    }
    private Colleague1 getCol1() {
        return col1;
    }
    public Colleague2 getCol2() {
        return col2;
    }
}

　　Colleague 抽象的业务角色

abstract class Colleague{
    private Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    public Mediator getMediator() {
        return mediator;
    }
    public abstract void action();
    public void change(){
        mediator.colleagueChanged(this);
    }
}

　　Colleague1 Colleague2 具体的业务角色

class Colleague1 extends Colleague{
    public Colleague1(Mediator m){
        super(m);
    }
    public void action(){
        System.out.println("this is an action from Colleague1");
    }
}
class Colleague2 extends Colleague{
    public Colleague2(Mediator m){
        super(m);
    }
    public void action(){
        System.out.println("this is an action from Colleague2");
    }
}

　　全部代码

 1 package com.xingoo.test.design.mediator;
 2 abstract class Colleague{
 3     private Mediator mediator;
 4     
 5     public Colleague(Mediator mediator){
 6         this.mediator = mediator;
 7     }
 8     
 9     public Mediator getMediator() {
10         return mediator;
11     }
12     
13     public abstract void action();
14     
15     public void change(){
16         mediator.colleagueChanged(this);
17     }
18 }
19 class Colleague1 extends Colleague{
20     public Colleague1(Mediator m){
21         super(m);
22     }
23     public void action(){
24         System.out.println("this is an action from Colleague1");
25     }
26 }
27 class Colleague2 extends Colleague{
28     public Colleague2(Mediator m){
29         super(m);
30     }
31     public void action(){
32         System.out.println("this is an action from Colleague2");
33     }
34 }
35 interface Mediator{
36     public void colleagueChanged(Colleague c);
37 }
38 class ConcreteMediator implements Mediator{
39     private Colleague1 col1;
40     private Colleague2 col2;
41     
42     public void colleagueChanged(Colleague c) {
43         col1.action();
44         col2.action();
45     }
46     
47     public void createConcreteMediator() {
48         col1 = new Colleague1(this);
49         col2 = new Colleague2(this);
50     }
51     
52     private Colleague1 getCol1() {
53         return col1;
54     }
55     
56     public Colleague2 getCol2() {
57         return col2;
58     }
59     
60 }
61 
62 public class Client {
63     public static void main(String[] args) {
64         ConcreteMediator mediator = new ConcreteMediator();
65         mediator.createConcreteMediator();
66         Colleague1 col1 = new Colleague1(mediator);
67 //        Colleague2 col2 = new Colleague2(mediator);
68         mediator.colleagueChanged(col1);
69     }
70 }

View Code