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，比较

        细心地读者能够发现，建造者模式跟工厂模式很像，甚至能够通用，我我的以为这两个设计模式最大的区别就是控制的粒度不一样，建造者模式更关注的是对象细节的建立，而工厂模式关注的则是对象类型的选取