深入Java設計模式之中介模式

什麼是中介者模式

用一箇中介對象封裝一系列的對象 交互，中介者使各對象不需要顯示地相互作用，從而使其耦合鬆散，而且可以獨立地改變它 們之間的交互，減少類之間的依賴 

中介者模式適用場景

在以下情況下可以考慮使用中介者模式：

• 系統中對象之間存在複雜的引用關係，系統結構混亂且難以理解。
• 一個對象由於引用了其他很多對象並且直接和這些對象通信，導致難以複用該對象。
• 想通過一箇中間類來封裝多個類中的行爲，而又不想生成太多的子類。可以通過引入中介者類來實現，在中介者中定義對象交互的公共行爲，如果需要改變行爲則可以增加新的具體 中介者類

中介者模式的分類

標準中介者

 

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;
/**
 * 期望實現的效果：驅動執行完之後執行cpu,cpu執行完之後執行聲音和音頻
 * @author lzhcode
 *
 */
public class ClientForComputerDemo
{
    public static void main(String[] args)
    {
        MainBoard mainBoard = new MainBoard();
        CDDriver cdDriver = new CDDriver(mainBoard);
        CPU cpu = new CPU(mainBoard);
        VideoCard videoCard = new VideoCard(mainBoard);
        SoundCard soundCard = new SoundCard(mainBoard);
        mainBoard.setCdDriver(cdDriver);
        mainBoard.setCpu(cpu);
        mainBoard.setVideoCard(videoCard);
        mainBoard.setSoundCard(soundCard);
        cdDriver.readCD();
    }
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public abstract class Colleague
{
    private final Mediator mediator;

    protected Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public Mediator getMediator()
    {
        return mediator;
    }
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public interface Mediator
{
	/**
	 * 同事對象在自身發生改變的時候，通知中介者的方法
	 * 讓中介者去負責相應同事的交互
	 * 同事對象在自身 好讓中介者對象實例去獲取同事對象的狀態
	 * @param colleague
	 */
    public void changed(Colleague colleague);
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public class MainBoard implements Mediator
{
    protected CPU cpu;
    private CDDriver cdDriver;
    private VideoCard videoCard;
    private SoundCard soundCard;

    public void setCdDriver(CDDriver cdDriver)
    {
        this.cdDriver = cdDriver;
    }

    public void setCpu(CPU cpu)
    {
        this.cpu = cpu;
    }

    public void setVideoCard(VideoCard videoCard)
    {
        this.videoCard = videoCard;
    }

    public void setSoundCard(SoundCard soundCard)
    {
        this.soundCard = soundCard;
    }

    public void changed(Colleague colleague)
    {
        if (colleague == cdDriver)
        {
            this.operateCDDriverReadData((CDDriver) colleague);
        } else if (colleague == cpu)
        {
            this.operateCPU((CPU) colleague);
        }
    }

    public void operateCDDriverReadData(CDDriver cdDriver)
    {
        String data = cdDriver.getData();
        this.cpu.executeData(data);
    }

    public void operateCPU(CPU cpu)
    {
        String videoData = cpu.getVideoData();
        String soundData = cpu.getSoundData();
        this.videoCard.showData(videoData);
        this.soundCard.soundData(soundData);
    }
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public class CPU extends Colleague
{
    private String videoData;
    private String soundData;

    protected CPU(Mediator mediator)
    {
        super(mediator);
    }

    public String getVideoData()
    {
        return videoData;
    }

    public String getSoundData()
    {
        return soundData;
    }

    public void executeData(String data)
    {
        String[] ss = data.split(",");
        this.videoData = ss[0];
        this.soundData = ss[1];
        this.getMediator().changed(this);
    }
}

 

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public class SoundCard extends Colleague
{
    protected SoundCard(Mediator mediator)
    {
        super(mediator);
    }

    public void soundData(String data)
    {
        System.out.println("畫外音：" + data);
    }
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public class VideoCard extends Colleague
{
    protected VideoCard(Mediator mediator)
    {
        super(mediator);
    }

    public void showData(String data)
    {
        System.out.println("您正在觀看的是：" + data);
    }
}

package com.lzhsite.technology.designPattern.mediator.ComputerDemo;

public class CDDriver extends Colleague {
	
	private String data;

	protected CDDriver(Mediator mediator) {
		super(mediator);
	}

	public String getData() {
		return data;
	}

	public void readCD() {
		this.data = "Video Data, Sound Data";
		this.getMediator().changed(this);
	}
}

 廣義中介者 

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

public class ClientForColleagueDemo
{
    public static void main(String[] args)
    {
        AbstractMediator mediator = new Mediator();
        ColleagueA colleagueA = new ColleagueA();
        ColleagueB colleagueB = new ColleagueB();
        mediator.addColleague("ColleagueA", colleagueA);
        mediator.addColleague("ColleagueB", colleagueB);
        colleagueA.self();
        colleagueA.out();
        System.out.println("合作愉快，任務完成");
        System.out.println();
        colleagueB.self();
        colleagueB.out();
        System.out.println("合作愉快，任務完成");
    }
}

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

public class AbstractColleague
{
    protected AbstractMediator mediator;

    public void setMediator(AbstractMediator mediator)
    {
        this.mediator = mediator;
    }
}

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

import java.util.Hashtable;

public abstract class AbstractMediator
{
    protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();

    public void addColleague(String name, AbstractColleague colleague)
    {
    	//在這裏把自己註冊進中介mediator,與其取得聯繫
        colleague.setMediator(this);
        this.colleagues.put(name, colleague);
    }

    public void deleteColleague(String name)
    {
        this.colleagues.remove(name);
    }

    public abstract void execute(String name, String method);
}

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

public class Mediator extends AbstractMediator {
	public void execute(String name, String method) {
		if ("self".equals(method)) {
			if ("ColleagueA".equals(name)) {
				ColleagueA colleagueA = (ColleagueA) super.colleagues.get("ColleagueA");
				colleagueA.self();
			} else {
				ColleagueB colleagueB = (ColleagueB) super.colleagues.get("ColleagueB");
				colleagueB.self();
			}
		} else {
			if ("ColleagueA".equals(name)) {
				ColleagueA colleagueA = (ColleagueA) super.colleagues.get("ColleagueA");
				colleagueA.out();
			} else {
				ColleagueB colleagueB = (ColleagueB) super.colleagues.get("ColleagueB");
				colleagueB.out();
			}
		}
	}
}

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

public class ColleagueA extends AbstractColleague
{
    public void self()
    {
        System.out.println("同事A --> 做好自己份內的事情...");
    }

    public void out()
    {
        System.out.println("同事A --> 請求同事B 做好份內的事情");
        super.mediator.execute("ColleagueB", "self");
    }
}

package com.lzhsite.technology.designPattern.mediator.ColleagueDemo;

public class ColleagueB extends AbstractColleague
{
    public void self()
    {
        System.out.println("同事B --> 做好自己份內的事情...");
    }

    public void out()
    {
        System.out.println("同事B --> 請求同事A 做好份內的事情");
        super.mediator.execute("ColleagueA", "self");
    }
}

示例代碼：https://gitee.com/lzhcode/maven-parent/tree/master/lzh-technology/src/main/java/com/lzhsite/technology/designPattern/mediator