【設計模式】—— 中介者模式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！哎呀我想要！