设计模式第三弹【Proxy,Decorator,Mediator】

摘要：但它们还是具有不同的设计目的。模式构成一个对象并为用户提供一致的接口。另外，着重控制对象。是将需要装饰的对象通过构造函数的方式传入。参考文献大话设计模式模式与模式的异同之我见代理模式装饰器模式

</>复制代码 
代理模式，为其他对象提供一种代理以控制对这个对象的访问

看代码更清晰

</>复制代码 
//Main函数
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装饰模式。这两种模式很相似，经常会混淆。

</>复制代码 
装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更灵活。

对于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;
    }
}
//这里只举一个实现类的例子
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提到它们的区别时，说到：
这两种模式都描述了怎样为对象提供一定程度上的间接引用，它们的实现部分都保留了指向另一个对象的指针，向这个对象发送请求。但它们还是具有不同的设计目的。
Proxy模式构成一个对象并为用户提供一致的接口。但与Decoratro模式不同的是，Proxy模式不能动态的添加或分离性质，也不是为递归组合而设计的。它的目的是，当直接访问一个不方便或不符合需要时，为这个实体提供一个替代者。

Proxy从语义上来说，就是一个代理类，我不需要知道你具体是哪个类实现的，我只需要能够访问这个提供服务的代理对象就可以。另外，Proxy着重控制对象。
Decorator更注重于装饰。是将需要装饰的对象通过构造函数的方式传入。
比较一下上述代码。注意装饰器和代理的初始化位置和方式
//Proxy在执行前后可以再做其他事，增强能力，改变的是行为。
//Decorator 目的是为了改变print的内容,先get内容，在get内容的方法中进行修改。

</>复制代码 
中介者模式，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立改变它们之间的交互。

把对象之间复杂的耦合写到mediator中，让mediator与其他对象的关联是整齐统一的。从而提高可用性和扩展性。

都是是把复杂的东西隐藏起来，让别人看起来比较简单。都没有简单化。只是进行隐藏。【需要考虑代价】
mediator是把对象之间复杂的关系都联系起来。相当于集线器。把所有东西和集线器联系起来。逻辑更为复杂。【仔细衡量是否一定需要。否则会有很大复杂性。】
facade是把外面的东西和内部的东西分开简单化。类似于包装盒。不管内部多复杂，对外只需要一个接口，外部不需要关心内部是如何实现。

参考文献：

《大话设计模式》

Decorator模式与Proxy模式的异同之我见

代理模式 & 装饰器模式 （Proxy & Decorator)