摘要：工廠設計模式工廠設計模式，主要用于進行實例化對象時的解耦操作，避免使用關鍵字實例化對象，通過反射，根據類名稱動態創建對象示例靜態工廠模式構造方法私有化獲取指定類名稱的對象動態代理模式動態代理模式，主要用于對同一接口子類的相同邏輯進行代理操作

工廠設計模式，主要用于進行實例化對象時的解耦操作，避免使用new關鍵字實例化對象，通過反射，根據類名稱動態創建對象

示例：

package design;
/**
   *靜態工廠模式
   */
public class Factory {
/**
   *構造方法私有化
   */
private Factory (){

 }
/**
   * 獲取指定類名稱的對象
   * @param className    * @param 
   * @return T
   */
public static  T getInstance(String className){
        T object =null;
        try {
            object = (T) Class.forName(className).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return object;
    }
}

動態代理模式，主要用于對同一接口子類的相同邏輯進行代理操作

示例：

package design;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
   * 動態代理模式
   */
public class DynamicProxy implements InvocationHandler {
    private Object target;
    /**
     * 代理的目標對象
     * @param target
     * @return
     */
    public Object proxy(Object target){
        this.target=target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    /**
     * 目標方法執行前執行
     * @param object
     */
    public void before(Object object){
        System.out.println("目標方法執行前執行");
    }
    /**
     * 目標方法執行后執行
     * @param object
     */
    public void after(Object object){
        System.out.println("目標方法執行后執行");
    }
    /**
     * Processes a method invocation on a proxy instance and returns
     * the result.  This method will be invoked on an invocation handler
     * when a method is invoked on a proxy instance that it is
     * associated with.
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.before(proxy);
        Object result =method.invoke(proxy,args);
        this.after(result);
        return result;
    }
}

單例模式一：采用static final 修飾在類內部實例化的對象，保證對象的唯一性，此種方式，實在類加載的過程中實例化對象，無論是否使用，都會實例化。

示例

package design;
/**
   * 單例模式一
   */
public class SingletonOne {
    /**
     * 實例化對象唯一
     */
    private static final SingletonOne INSTANCE =new SingletonOne();
    /**
     * 構造方法私有化
     */
    private SingletonOne(){

    }
    /**
     * 獲取單例對象
     * @return
     */
    public static SingletonOne getInstance(){
        return INSTANCE;
    }
}

單例模式二：采用volatile關鍵字修飾實例化對象，并通過同步鎖（鎖Class）的形式，保證實例化對象的唯一性，此方式在第一次使用時進行實例化

volatile關鍵字修飾的變量與普通變量的讀取方式不同

 volatile定義的變量,將直接使用原始數據進行處理,更改后立即生效

示例

package design;
/**
   * 單例模式二
   */
public class SingletonTwo {
    /**
     * 使用volatile關鍵字修飾單例對象
     * volatile定義的變量,將直接使用原始數據進行處理,更改后立即生效
     */
    public static volatile SingletonTwo instance;
    /**
     * 構造方法私有化
     */
    private SingletonTwo(){

    }
    /**
     * 獲取單例對象
     * @return
     */
    public static SingletonTwo getInstance(){
        if(instance ==null){
            //通過同步鎖住當前類,來保證線程安全,并提高性能,若直接同步該方法,會大大降低性能
            synchronized (SingletonTwo.class){
                if (instance ==null){
                    instance =new SingletonTwo();
                }
            }
        }
        return instance;
    }
}

單例模式三：基于Jvm類加載機制實現單例

示例

/**
 * 單例模式三
 */
public class ClassSingletonDemo {

    /**
     * 構造方法私有化
     */
    private ClassSingletonDemo(){};

    /**
     * 靜態方法獲取實例
     */
    public static ClassSingletonDemo getInstance(){
        return SingletonHandler.singleton;
    }

    /**
     * 內部靜態類保證只初始化一次
     */
    private static class SingletonHandler {
        private static ClassSingletonDemo singleton = new ClassSingletonDemo();
        static {
            System.out.println("This"s innerClass"s static code block");
        }
    }
}

單例模式四：基于Enum類型的加載機制實現單例

示例

/**
 * 單例模式四
 */
public class EnumSingletonDemo {

    /**
     * 構造方法私有化
     */
    private EnumSingletonDemo(){}

    /**
     * 靜態方法獲取實例
     */
    public static EnumSingletonDemo getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    /**
     * 私有枚舉,只被JVM加載一次,只實例化一次
     */
    private enum Singleton{

        INSTANCE;

        private EnumSingletonDemo singleton;

        Singleton(){
            singleton = new EnumSingletonDemo();
        }

        public EnumSingletonDemo getInstance(){
            return singleton;
        }
    }

}

(轉載自喻紅葉《Java與模式-中介者模式》）

中介者模式的定義：用一個中介對象來封裝一些列的對象交互，中介者使得各對象不需要顯式地相互引用，從而使其耦合松散，而且可以獨立地改變它們之間的交互。中介者模式解決問題的思路很簡單，就是通過引入一個中介對象，讓其他對象只與中介對象交互，而中介對象知道如何和其他所有對象的交互，這樣對象之間的交互關系就沒有了，從而實現了對象之間的解耦。由此，我們也可以看出一個問題，那就是中介對象控制著整個系統的邏輯，它會過于復雜，這是一個缺點。中介者模式的本質是封裝交互：

（1）對象在自身狀態發生改變時報告給中介對象；

（2）中介對象控制著整個系統的邏輯，它知道如何與所有對象交互；

（3）對象需要對中介對象發出的請求作出回應。

中介者模式中的角色：

Mediator：中介者接口，定義各個同事之間交互所需要的方法；

ConcreteMediator：具體的中介者，它需要了解并維護各個同事對象，并負責具體的協調各同事對象的交互關系；

Colleague：所有同事對象的父類，一般實現成抽象類，主要負責約束同事對象的類型，并負責實現一些公共功能；

ConcreteMediator：具體的同事類，實現自己的業務，當需要與其他同事對象通信時，就與持有的中介者通信，中介者會負責與其他同事的交互。在標準的中介者模式中，將使用中介者來交互的那些對象叫做同事類，它們繼承自相同的父類，所以叫做同事。正是由于它們之間的交互很復雜，所以才產生了把這些交互關系分離出去，讓中介者來處理。

示例：

以電腦來看電影為例子，首先光驅從光盤中讀取數據，然后通知CPU將數據分離成音頻和視頻，CPU處理完畢后再分別將數據傳送給聲卡和顯卡進行播放。從上面的描述的中發現，光驅盒CPU是耦合的，CPU又和聲卡顯卡是耦合的，怎么解耦的呢？如果使用中介者模式，通過引入主板作為中介者，所有的對象都與主板交互，那么播放電影的流程就變成了這樣：

（1）光驅從光盤讀取到數據，通知主板，數據準備好了；

（2）主板收到光驅的請求后，將原始數據傳給CPU，讓它將數據分離成音頻和視頻；

（3）CPU將數據分離后，通知主板，數據分離完畢；

（4）主板收到CPU通知后，分別將音頻和視頻傳給聲卡和顯卡；

（5）聲卡和顯卡同時播放。

這樣一個過程中，所有的類只與主板耦合，而不與其他類保持關系，做到了解耦，而且過程很清晰。實際上計算機硬件就是這樣通信的，只不過更復雜一些，所以這些東西都是相通的，重要的是思想。

Java實現：

同事對象的父類

package design;
/**
 * 同事對象的父類，一般實現成抽象類，用于約束同事對象的類型
 * 同時實現一些功能公共方法，例如持有中介者對象
 */
public abstract class Colleague {
    //所有的同事對象都需要持有中介對象
    private Mediator mediator;

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

    public Mediator getMediator() {
        return mediator;
    }
}

中介者接口

package design;
/**
 * 中介者接口
 */
public interface  Mediator {
    /**
     * 同事對象自身狀態改變時，通過這個方法通知中介者對象
     * @param obj
     */
    public void changed(Colleague obj);

    /**
     * 中介者對象需要知道所有同事對象
     * @param instance
     */
    public void setCDDriver(CDDriver instance);
    public void setCPU(CPU instance);
    public void setVideoCard(Video instance);
    public void setSoundCard(Sound instance);
}

光驅類

package design;
/**
 * 光驅類，負責從光盤中讀取數據
 */
class CDDriver extends Colleague {
    //從光盤讀取的原始數據
    private String originData;

    public CDDriver(Mediator mediator) {
        super(mediator);
    }
    public String getOriginData() {
        return originData;
    }

    /**
     * 讀取光盤數據，一旦讀取到數據，就要通知中介者對象數據已經準備好了
     */
    public void readCD(String originData) {
        this.originData = originData;
        //通知中介對象，自己的狀態發生了改變
        getMediator().changed(this);
    }
}

CPU類

package design;
/**
 * CPU類，負責將原始數據分離成音頻和視頻
 */
public class CPU extends Colleague {

    //聲音數據
    private String soundData;
    //視頻數據
    private String videoData;

    public CPU(Mediator mediator) {
        super(mediator);
    }
    public String getSoundData() {
        return soundData;
    }
    public String getVideoData() {
        return videoData;
    }

    /**
     * 將數據分離，同時通知中介者對象，數據已經分離
     * @param originData
     */
    public void sperateData(String originData) {
        this.soundData = originData.split(",")[1];
        this.videoData = originData.split(",")[0];

        //通知中介對象，自己的狀態發生了改變
        getMediator().changed(this);
    }
}

顯卡類，播放視頻

package design;
/**
 * 顯卡類，播放視頻
 */
public class Video extends Colleague {

    public Video(Mediator mediator) {
        super(mediator);
    }
    public void showVideo(String videoData) {
        System.out.println("正在觀看：" + videoData);
    }
}

聲卡類

package design;

/**
 * 聲卡類，播放聲音
 */
public class Sound extends Colleague {

    public Sound(Mediator mediator) {
        super(mediator);
    }
    public void showSound(String soundData) {
        System.out.println("解說：" + soundData);
    }
}

主板類

package design;
/**
 * 主板類,實現中介者
 */
public class MainBoard implements Mediator {
    private CDDriver cd;
    private CPU cpu;
    private Video vc;
    private Sound sc;

    public void setCDDriver(CDDriver instance) {
        this.cd = instance;
    }
    public void setCPU(CPU instance) {
        this.cpu = instance;
    }
    public void setVideoCard(Video instance) {
        this.vc = instance;
    }
    public void setSoundCard(Sound instance) {
        this.sc = instance;
    }

    /**
     * 當同時對象自身狀態發生改變時，調用此方法通知中介者對象
     * 中介者對象在進行邏輯控制，與其他同對象交互
     */
    public void changed(Colleague obj) {
        //如果是光驅類，需要通知CPU去分離數據
        if(obj instanceof CDDriver) {
            String originData = ((CDDriver) obj).getOriginData();
            this.cpu.sperateData(originData);
        }else if(obj instanceof CPU){//如果是CPU類，需要通知聲卡和顯卡去播放
            String videoData = ((CPU) obj).getVideoData();
            String soundData = ((CPU) obj).getSoundData();
            this.vc.showVideo(videoData);
            this.sc.showSound(soundData);
        }
    }
}

客戶端

package design;
/**
 * 客戶端
 */
public class Client {
    public static void main(String[] args) {
        Mediator mediator = new MainBoard();
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        Video vc = new Video(mediator);
        Sound sc = new Sound(mediator);
        mediator.setCDDriver(cd);
        mediator.setCPU(cpu);
        mediator.setSoundCard(sc);
        mediator.setVideoCard(vc);
        //光驅讀數據，通知中介者，中介者通知CPU去分離數據，CPU分離數據完成，通知中介者，中介者通知聲卡和顯卡播放
        cd.readCD("終結者，終結者音頻");
    }
}