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

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

　　模式意图

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

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

　　应用场景

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

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

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

　　模式结构

　　

　　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");
    }
}

　　全部代码

 package com.xingoo.test.design.mediator;
 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);
     }
 }
 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");
     }
 }
 interface Mediator{
     public void colleagueChanged(Colleague c);
 }
 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;
     }

 }

 public class Client {
     public static void main(String[] args) {
         ConcreteMediator mediator = new ConcreteMediator();
         mediator.createConcreteMediator();
         Colleague1 col1 = new Colleague1(mediator);
 //        Colleague2 col2 = new Colleague2(mediator);
         mediator.colleagueChanged(col1);
     }
 }

　　运行结果

this is an action from Colleague1
this is an action from Colleague2

　　生活中的设计模式

　　

　　毕业的同学们，第一个要解决的问题就是租房子，当白富美高富帅出没社会后，穷屌丝没了生存之地。但是只要勤劳，一样有饭吃有房住！

　　这里房屋中介好比是一个中介者，它知道每个租客的身份信息，当有房屋出租后，它会发送给每一个租客消息。

　　这样，租客们中有一个变化活动时，都会利用房屋中介，发送消息到其他的租客。下面就是模仿的一个过程。

　　房屋中介代码如下：

 interface StateMediator{
     public void sell(Tenant tenant);
 }
 class RealEstateAgents implements StateMediator{
     private TenantA teA;
     private TenantB teB;
     private TenantC teC;

     public void sell(Tenant tenant) {
         System.out.println("海景洋房 已经租出去了！");
         if(tenant instanceof TenantA){
             teB.crying();
             teC.crying();
         }else if(tenant instanceof TenantB){
             teA.crying();
             teC.crying();
         }else if(tenant instanceof TenantC){
             teB.crying();
             teA.crying();
         }
     }

     public void createAgents(){
         teA = new TenantA(this);
         teB = new TenantB(this);
         teC = new TenantC(this);
     }
 }

　　租客的代码如下：

 abstract class Tenant{
     private RealEstateAgents agent;
     public Tenant(RealEstateAgents agent) {
         this.agent = agent;
     }
     public abstract void crying();
     public void renting(){
         agent.sell(this);
     }
 }
 class TenantA extends Tenant{
     public TenantA(RealEstateAgents agent) {
         super(agent);
     }
     public void crying() {
         System.out.println("我是高富帅 TenantA！哎呀我想要！");
     }
 }
 class TenantB extends Tenant{
     public TenantB(RealEstateAgents agent) {
         super(agent);
     }
     public void crying() {
         System.out.println("我是白富美 TenantB！哎呀我想要！");
     }
 }
 class TenantC extends Tenant{
     public TenantC(RealEstateAgents agent) {
         super(agent);
     }
     public void crying() {
         System.out.println("我是穷屌丝 TenantC！哎呀我想要！");
     }
 }

　　产生的业务活动如下：

 public class ClientTest {
     public static void main(String[] args) {
         RealEstateAgents agent = new RealEstateAgents();
         agent.createAgents();

         System.out.println("TeA 抢到了房子了！");
         agent.sell(new TenantA(agent));

         System.out.println("过了两个月 TeB 抢到了房子了！");
         agent.sell(new TenantB(agent));
     }
 }

　　运行结果

TeA 抢到了房子了！
海景洋房 已经租出去了！
我是白富美 TenantB！哎呀我想要！
我是穷屌丝 TenantC！哎呀我想要！
过了两个月 TeB 抢到了房子了！
海景洋房 已经租出去了！
我是高富帅 TenantA！哎呀我想要！
我是穷屌丝 TenantC！哎呀我想要！