摘要：但它們還是具有不同的設(shè)計目的。模式構(gòu)成一個對象并為用戶提供一致的接口。另外，著重控制對象。是將需要裝飾的對象通過構(gòu)造函數(shù)的方式傳入。參考文獻大話設(shè)計模式模式與模式的異同之我見代理模式裝飾器模式

代理模式，為其他對象提供一種代理以控制對這個對象的訪問

看代碼更清晰

//Main函數(shù)
public class Main {
    public static void main(String[] args) {
        Printable p = new PrinterProxy("Alice");
        System.out.println("Print by:"+p.getPrinterName());
        p.setPrinterName("Bob");
        System.out.println("Print by:"p.getPrinterName());
        p.print("Hello, world.");
    }
}

//Printable接口
public interface Printable {
    public abstract void setPrinterName(String name);   
    public abstract String getPrinterName();            
    public abstract void print(String string);      
}

//重點來了
//PrinterProxy代理類
public class PrinterProxy implements Printable {
    private String name;            
    private Printer real;           
    public PrinterProxy() {
    }
    public PrinterProxy(String name) {      
        this.name = name;
    }
    public synchronized void setPrinterName(String name) {  
        if (real != null) {
            real.setPrinterName(name);  
        }
        this.name = name;
    }
    public String getPrinterName() {    
        return name;
    }
    public void print(String string) {  
        realize();
        real.print(string);
    }
    private synchronized void realize() {   
        if (real == null) {
            real = new Printer(name);
        }
    }
}

//Printer 
public class Printer implements Printable {
    private String name;
    public Printer() {
        heavyJob("Printer,heavyJob");
    }
    public Printer(String name) {
        this.name = name;
        heavyJob("Printer?(" + name + ")?");
    }
    public void setPrinterName(String name) {
        this.name = name;
    }
    public String getPrinterName() { 
        return name;
    }
    public void print(String string) { 
        System.out.println("=== " + name + " ===");
        System.out.println(string);
    }
    private void heavyJob(String msg) {
        System.out.print(msg);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.print(".");
        }
        System.out.println("end");
    }
}

講到proxy就不得不提到decorator裝飾模式。這兩種模式很相似，經(jīng)常會混淆。

裝飾模式，動態(tài)地給一個對象添加一些額外的職責，就增加功能來說，裝飾模式比生成子類更靈活。

對于Component來說，是無需知道Decorator的存在，Decorator是從外類來擴展Componnent類的功能。
看代碼

//Main
public class Main {
    public static void main(String[] args) {
        Display b1 = new StringDisplay("Hello, world.");
        Display b2 = new SideBorder(b1, "#");
        Display b3 = new FullBorder(b2);
        b1.show();
        b2.show();
        b3.show();
        Display b4 = 
                    new SideBorder(
                        new FullBorder(
                            new FullBorder(
                                new SideBorder(
                                    new FullBorder(
                                        new StringDisplay("hello")
                                    ),
                                    "*"
                                )
                            )
                        ),
                        "/"
                    );
        b4.show();
    }
}

//Display
public abstract class Display {
    public abstract int getColumns();               
    public abstract int getRows();                  
    public abstract String getRowText(int row);     
    public final void show() {                      
        for (int i = 0; i < getRows(); i++) {
            System.out.println(getRowText(i));
        }
    }
}

//Border
public abstract class Border extends Display {
    protected Display display;          
    protected Border(Display display) {
        this.display = display;
    }
}

//這里只舉一個實現(xiàn)類的例子
public class SideBorder extends Border {
    private char borderChar;                       
    public SideBorder(Display display, char ch) {   
        super(display);
        this.borderChar = ch;
    }
    public int getColumns() {                      
        return 1 + display.getColumns() + 1;
    }
    public int getRows() {                          
        return display.getRows();
    }
    public String getRowText(int row) {             
        return borderChar + display.getRowText(row) + borderChar;
    }
}

GoF提到它們的區(qū)別時，說到：
這兩種模式都描述了怎樣為對象提供一定程度上的間接引用，它們的實現(xiàn)部分都保留了指向另一個對象的指針，向這個對象發(fā)送請求。但它們還是具有不同的設(shè)計目的。
Proxy模式構(gòu)成一個對象并為用戶提供一致的接口。但與Decoratro模式不同的是，Proxy模式不能動態(tài)的添加或分離性質(zhì)，也不是為遞歸組合而設(shè)計的。它的目的是，當直接訪問一個不方便或不符合需要時，為這個實體提供一個替代者。

Proxy從語義上來說，就是一個代理類，我不需要知道你具體是哪個類實現(xiàn)的，我只需要能夠訪問這個提供服務的代理對象就可以。另外，Proxy著重控制對象。
Decorator更注重于裝飾。是將需要裝飾的對象通過構(gòu)造函數(shù)的方式傳入。
比較一下上述代碼。注意裝飾器和代理的初始化位置和方式
//Proxy在執(zhí)行前后可以再做其他事，增強能力，改變的是行為。
//Decorator 目的是為了改變print的內(nèi)容,先get內(nèi)容，在get內(nèi)容的方法中進行修改。

中介者模式，用一個中介對象來封裝一系列的對象交互。中介者使各對象不需要顯示地相互引用，從而使其耦合松散，而且可以獨立改變它們之間的交互。

把對象之間復雜的耦合寫到mediator中，讓mediator與其他對象的關(guān)聯(lián)是整齊統(tǒng)一的。從而提高可用性和擴展性。

都是是把復雜的東西隱藏起來，讓別人看起來比較簡單。都沒有簡單化。只是進行隱藏?！拘枰紤]代價】
mediator是把對象之間復雜的關(guān)系都聯(lián)系起來。相當于集線器。把所有東西和集線器聯(lián)系起來。邏輯更為復雜?！咀屑毢饬渴欠褚欢ㄐ枰?。否則會有很大復雜性。】
facade是把外面的東西和內(nèi)部的東西分開簡單化。類似于包裝盒。不管內(nèi)部多復雜，對外只需要一個接口，外部不需要關(guān)心內(nèi)部是如何實現(xiàn)。

參考文獻：

《大話設(shè)計模式》

Decorator模式與Proxy模式的異同之我見

代理模式 & 裝飾器模式 （Proxy & Decorator)