java - 建造者模式

1，定義：

       建造者模式也叫生成器模式，將一個複雜對象的構件與它的標識分離，使得一樣的構建過程能夠構件不一樣的標識。

2，通用類圖：

3，角色

（1）產品類（構建的目標對象類）

（2）Builder抽象構造者：規範產品的組件，通常由子類實現

（3）ConcreteBuilder：具體構造者，實現抽象構造者的構造方法

（4）Director導演類：通知builder開始建造

 

4，通用僞代碼

public class Product {

    private String attr1;

    public String getAttr1() {
        return attr1;
    }

    public void setAttr1(String attr1) {
        this.attr1 = attr1;
    }
}

public abstract class Builder {

    protected abstract void setAttr();
    
    protected abstract Product build();
    
}

public class ConcreteBuilder extends Builder{

    Product product;

    public ConcreteBuilder() {
        product = new Product();
    }

    @Override
    protected void setAttr() {
        product.setAttr1("attr");
    }

    @Override
    protected Product build() {
        return product;
    }
}

public class Director {
    public static Product getProduct() {
        Builder builder = new ConcreteBuilder();
        builder.setAttr();
        return builder.build();
    }
}

5，例子

（1）做爲開發人員，IDE（開發工具）是必不可少的，當下比較流行的IDE不少，好比eclipse，idea，假如如今有一個需求，但願實現IDE的組建供程序員挑選，那麼組建過程就能夠用建造者模式

抽象產品類：

public abstract class DevelopTool {

    private String language;

    private String version;

    private String factory;

    private String buildMessage;


    public String getBuildMessage() {
        return buildMessage;
    }

    public void setBuildMessage(String buildMessage) {
        this.buildMessage = buildMessage;
    }

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getFactory() {
        return factory;
    }

    public void setFactory(String factory) {
        this.factory = factory;
    }
}

兩個具體的實現類，一個是eclipse，一個是idea

/**
eclipse 工具實現類
*/
public class EclipseTool extends DevelopTool{

    public EclipseTool() {

    }


}

/**
idea 工具實現類
*/
public class IdeaTool extends DevelopTool {

}

抽象建造者角色

public abstract class Builder {

    public abstract DevelopTool buildDevelopTool();

}

兩個具體構造者

public class EclipseToolBuilder extends Builder{


    @Override
    public DevelopTool buildDevelopTool() {

        EclipseTool eclipseTool = new EclipseTool();

        eclipseTool.setFactory("meiguo");
        eclipseTool.setLanguage("java");
        eclipseTool.setVersion("1.0.1");
        eclipseTool.setBuildMessage("build a eclipseTool");
        return eclipseTool;
    }
}

public class IdeaToolBuilder extends Builder{

    @Override
    public DevelopTool buildDevelopTool() {
        DevelopTool developTool = new IdeaTool();
        developTool.setBuildMessage("build a idea tool");
        developTool.setVersion("1.0.1");
        developTool.setLanguage("java etc");
        developTool.setFactory("American");
        return developTool;
    }
}

這裏就沒有director了 ，業務系統直接調用

public class MainClient {

    public static void main(String[] args) {
        Builder builder = new IdeaToolBuilder();
        DevelopTool developTool = builder.buildDevelopTool();
        System.out.println(developTool.getBuildMessage());
    }
}

  （2）是否是感受有點繁瑣，寫了半天才只是實現了一個對象的建立，若是你有這樣的疑問，我表示贊成，因此咱們不妨改一下寫法，將build與product融爲一體看一下

 

public class DevelopTool {

    private String language;

    private String version;

    private String factory;

    private String buildMessage;


    private DevelopTool(DevelopBuild developBuild) {
        this.language = developBuild.language;
        this.version = developBuild.version;
        this.factory = developBuild.factory;
        this.buildMessage = developBuild.buildMessage;
    }


    public String getLanguage() {
        return language;
    }

    public String getVersion() {
        return version;
    }

    public String getFactory() {
        return factory;
    }

    public String getBuildMessage() {
        return buildMessage;
    }

    public static class DevelopBuild {

        private String language;

        private String version;

        private String factory;

        private String buildMessage;

        public DevelopBuild setLanguage(String language) {
            this.language = language;
            return this;
        }

        public DevelopBuild setVersion(String version) {
            this.version = version;
            return this;
        }


        public DevelopBuild setFactory(String factory) {
            this.factory = factory;
            return this;
        }


        public DevelopBuild setBuildMessage(String buildMessage) {
            this.buildMessage = buildMessage;
            return this;
        }

        public DevelopTool build() {
            return new DevelopTool(this);
        }

    }

}

而後在業務代碼中直接調用

public class MainClient {

    public static void main(String[] args) {
        DevelopTool.DevelopBuild developBuild = new DevelopTool.DevelopBuild();
        DevelopTool developTool = developBuild.setFactory("meiguo").setLanguage("java").setVersion("1.0.1").setBuildMessage("build a eclipse").build();
        System.out.println(developTool.getBuildMessage());
    }
    
}

好了，貌似也蠻方便的，建造者模式的變種不少，還須要多多揣摩

5，優勢：

（1）封裝性：將建立對象的細節進行封裝， 調用者沒必要關心任何建立細節

（2）容易拓展：特別是對對象的細節，在builder中能夠隨便更改與變種

（3）便於控制細節風險，在builder中能夠對細節進行判斷等操做

 

6，比較

        細心地讀者能夠發現，建造者模式跟工廠模式很像，甚至能夠通用，我我的以爲這兩個設計模式最大的區別就是控制的粒度不一樣，建造者模式更關注的是對象細節的建立，而工廠模式關注的則是對象類型的選取