生成器模式（Builder）

冷不防 2022-05-28 04:38 189阅读 0赞

### 1. 定义 ###

> 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

### 2.结构 ###

![这里写图片描述][70]  
\- Builder：生成器接口，定义创建一个Product对象所需要的各个部件的操作。  
\- ConcreteBuilder：具体的生成器实现，实现各个部件的创建，并负责组装Product对象的各个部件，同时还提供一个让用户获取组装完成后的产品对象的方法。  
\- Director：指导者，也被称导向者，主要用来使用Builder接口，以一个统一的过程来构建所需要的Product对象。  
\- Product：产品，表示被生成器构建的复杂对象，包含多个部件。

### 3. 实例 ###

下面以导出数据为例来使用生成器模式：通常在导出数据上，会有一些约束的方式，比如导出成文本格式、数据库备份形式、Excel格式、Xml格式等。通常对于具体的导出内容和格式是有要求的，加入现在有如下要求，简单描述一下：  
\- 导出的文件，不管是什么格式，都分成3个部分，分别是文件头、文件体、文件尾。  
\- 在文件头部分，需要描述如下信息：分公司或者门市编号、导出数据的日期。  
\- 在文件体部分，需要描述如下信息：表名称，然后分条描述数据。  
\- 在文件尾部分，需要描述如下信息：输出人。

1.  下面将描述文件各个部分的数据对象定义出来。

/** * 描述输出到文件头的内容的对象 * @author lijun * @since 2018-03-29 10:10 */
    public class ExportHeaderModel { 
        /** * 分公司或者门市编号 */
        private String depId;
        /** * 导出数据的日期 */
        private String exportDate;
    
        public String getDepId() {
            return depId;
        }
        public void setDepId(String depId) {
            this.depId = depId;
        }
        public String getExportDate() {
            return exportDate;
        }
        public void setExportDate(String exportDate) {
            this.exportDate = exportDate;
        }
    }

/** * 描述输出数据的对象 * @author lijun * @since 2018-03-29 10:11 */
    public class ExportDataModel { 
        /** * 产品编号 */
        private String productId;
        /** * 销售价格 */
        private double price;
        /** * 销售数量 */
        private double amount;
    
        public String getProductId() {
            return productId;
        }
        public void setProductId(String productId) {
            this.productId = productId;
        }
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            this.price = price;
        }
        public double getAmount() {
            return amount;
        }
        public void setAmount(double amount) {
            this.amount = amount;
        }
    }

/** * 描述输出到文件尾的内容的对象 * @author lijun * @since 2018-03-29 10:12 */
    public class ExportFooterModel { 
        /** * 输出人 */
        private String exportUser;
    
        public String getExportUser() {
            return exportUser;
        }
    
        public void setExportUser(String exportUser) {
            this.exportUser = exportUser;
        }
    }

1.  定义Builder接口，主要是把导出各种格式文件的处理过程的步骤定义出来，每个步骤负责构建最终导出文件的一部分。示例代码如下：

**
     * 生成器接口，定义创建一个输出文件对象所需的各个部件的操作
     * @author lijun
     * @since 2018-03-29 10:17
     */
    public interface Builder { 
        /** * 构建输出文件的Header部分 * @param ehm */
        public void buildHeader(ExportHeaderModel ehm);
    
        /** * 构建输出文件的Body部分 * @param mapData */
        public void buildBody(Map<String,List<ExportDataModel>> mapData);
    
        /** * 构建输出文件的Footer部分 * @param efm */
        public void buildFooter(ExportFooterModel efm);
    }

1.  具体的生成器实现。

导出到文本文件的的生成器实现。示例代码如下：

/** * 实现导出文件到文本文件的生成器对象 * @author lijun * @since 2018-03-29 10:24 */
    public class TxtBuilder implements Builder { 
        /** * 用来记录构建的文件的内容，相当于产品 */
        private StringBuffer buffer = new StringBuffer();
    
        @Override
        public void buildHeader(ExportHeaderModel ehm) {
            buffer.append(ehm.getDepId() + "," + ehm.getExportDate() + "\n");
        }
    
        @Override
        public void buildBody(Map<String, List<ExportDataModel>> mapData) {
            for (String tablName : mapData.keySet()) {
    
                //先拼接表名
                buffer.append(tablName + "\n");
                //然后循环拼接具体数据
                for (ExportDataModel edm : mapData.get(tablName)) {
                    buffer.append(edm.getProductId() + "," + edm.getPrice() + "," + edm.getAmount() + "\n");
                }
            }
        }
    
        @Override
        public void buildFooter(ExportFooterModel efm) {
            buffer.append(efm.getExportUser());
        }
    
        public StringBuffer getResult() {
            return buffer;
        }
    
    }

导出到Xml文件的的生成器实现。示例代码如下：

/** * 实现导出文件到Xml文件的生成器对象 * * @author lijun * @since 2018-03-29 10:27 */
    public class XmlBuilder implements Builder { 
        /** * 用来记录构建的文件的内容，相当于产品 */
        private StringBuffer buffer = new StringBuffer();
    
        @Override
        public void buildHeader(ExportHeaderModel ehm) {
            buffer.append("<?xml version='1.0' encoding='UTF-8'?>\n");
            buffer.append("<Report>\n");
            buffer.append("\t<Header>\n");
            buffer.append("\t\t<DepId>" + ehm.getDepId() + "</DepId>\n");
            buffer.append("\t\t<ExportDate>" + ehm.getExportDate() + "</ExportDate>\n");
    
            buffer.append("\t</Header>\n");
        }
    
        @Override
        public void buildBody(Map<String, List<ExportDataModel>> mapData) {
            buffer.append("\t<Body>\n");
            for (String tablName : mapData.keySet()) {
                //先拼接表名
                buffer.append("\t\t<Datas TableName=\"" + tablName + "\">\n");
                //然后循环拼接具体数据
                for (ExportDataModel edm : mapData.get(tablName)) {
    
                    buffer.append("\t\t\t<Data>\n");
    
                    buffer.append("\t\t\t\t<ProductId>" + edm.getProductId() + "</ProductId>\n");
                    buffer.append("\t\t\t\t<Price>" + edm.getPrice() + "</Price>\n");
                    buffer.append("\t\t\t\t<Amount>" + edm.getAmount() + "</Amount>\n");
    
                    buffer.append("\t\t\t</Data>\n");
                }
    
                buffer.append("\t\t</Datas>\n");
            }
            buffer.append("\t</Body>\n");
        }
    
        @Override
        public void buildFooter(ExportFooterModel efm) {
            buffer.append("\t<Footer>\n");
            buffer.append("\t\t<ExportUser>" + efm.getExportUser() + "</ExportUser>\n");
            buffer.append("\t</Footer>\n");
            buffer.append("</Report>\n");
        }
    
        public StringBuffer getResult() {
            return buffer;
        }
    
    }

1.  指导者。有了具体的生成器实现后，需要由指导者来指导它进行具体的产品构建。示例代码如下：

/** * 指导者，指导使用生成器的接口来构建输出的文件对象 * @author lijun * @since 2018-03-29 10:29 */
    public class Director { 
        /** * 持有当前需要的使用的生成器对象 */
        private Builder builder;
    
        /** * 构造方法，传入生成器对象 * * @param builder */
        public Director(Builder builder) {
            this.builder = builder;
        }
    
        public void construct(ExportHeaderModel ehm,
                              Map<String, List<ExportDataModel>> mapData, ExportFooterModel efm) {
            //1.先构建Header
            builder.buildHeader(ehm);
    
            //2.然后构建Body
            builder.buildBody(mapData);
    
            //3.再构建Footer
            builder.buildFooter(efm);
        }
    }

1.  客户端测试代码如下：

/** * @author lijun * @since 2018-03-29 10:31 */
    public class Client { 
        /** * @param args */
        public static void main(String[] args) {
    
            //准备测试数据
            ExportHeaderModel ehm = new ExportHeaderModel();
            ehm.setDepId("一分公司");
            ehm.setExportDate("2018-03-29");
    
            Map<String, List<ExportDataModel>> mapData = new HashMap<String, List<ExportDataModel>>();
            List<ExportDataModel> col = new ArrayList<ExportDataModel>();
    
            ExportDataModel edm1 = new ExportDataModel();
            edm1.setProductId("产品001号");
            edm1.setPrice(100);
            edm1.setAmount(80);
    
            ExportDataModel edm2 = new ExportDataModel();
            edm2.setProductId("产品002号");
            edm2.setPrice(120);
            edm2.setAmount(280);
    
            ExportDataModel edm3 = new ExportDataModel();
            edm3.setProductId("产品003号");
            edm3.setPrice(320);
            edm3.setAmount(380);
    
            col.add(edm1);
            col.add(edm2);
            col.add(edm3);
    
            mapData.put("销售记录表", col);
    
            ExportFooterModel efm = new ExportFooterModel();
            efm.setExportUser("LIJUN");
    
            //测试输出到文本文件
            TxtBuilder txtBuilder = new TxtBuilder();
            //创建指导者对象
            Director director = new Director(txtBuilder);
            director.construct(ehm, mapData, efm);
    
            //把要输出的内容输出到控制台看看
            System.out.println("输出到文本文件的内容:" + txtBuilder.getResult().toString());
    
            XmlBuilder xmlBuilder = new XmlBuilder();
            Director director2 = new Director(xmlBuilder);
            director2.construct(ehm, mapData, efm);
    
            //把要输出的内容输出到控制台看看
            System.out.println("输出到Xml文件的内容:" + xmlBuilder.getResult().toString());
        }
    
    }

使用生成器模式构建复杂对象。

> 考虑这样一个实际应用，要创建一个保险合同的对象，里面有很多属性的值都有约束，要求创建出来的对象满足这些约束规则，约束规则比如，保险合同通常情况下可以和个人签订，也可以和某个公司签订，但是一份保险合同不能同时与个人和公司签订。这个对象里面有很多类似这样的约束，那么如何来创建这个对象呢？  
> 要想简洁直观，安全性好，又具有很好的扩展性的来创建这个对象的话，一个比较好的选择就是用Builder模式，把复杂的创建过程通过Builder来实现。  
> 采用Builder模式来构建复杂的对象，通常会对Builder模式进行一定的简化，因为目标明确，就是创建某个复杂对象，因此做适当简化会使程序更加简洁。大致简化如下:  
> \- 使用Builder模式来创建某个对象，因此就没有必要再定义一个Builder接口，直接提供一个具体的构建器类就可以了。  
> \- 对于创建一个复杂的对象，可能会有很多种不同的选择和步骤，干脆去掉“指导者”，把指导者的功能和Client的功能合并起来，也就是说,Client这个时候就相当于指导者，它来指导构建器类去构建需要的复杂对象。为了实例简单，先不去考虑约束的实现，只是考虑如何通过Builder模式来构建复杂对象。  
> 1. 使用Builder模式来构建复杂对象，先不考虑带约束。

（1）保险合同对象

/** * 保险合同对象 * * @author lijun * @since 2018-03-29 13:18 */
    public class Insurancecontract { 
    
        /** * 保险合同编号 */
        private String contractId;
    
        /** * 被保人名称 同一份保险合同，要么跟人员签订，要么跟公司签订，也就是说，“被保险人员”和“被保公司" * 这个两个属性不可能同时有值。 */
        private String personName;
    
        /** * 被保公司 */
        private String companyName;
    
        /** * 保险开始生效的时间 */
        private long beginDate;
    
        /** * 保险失效时间 */
        private long endDate;
    
    
        /** * 其他数据 */
        private String otherData;
    
    
         Insurancecontract(ConcreteBuilder concreteBuilder) {
           this.contractId = concreteBuilder.getContractId();
           this.beginDate = concreteBuilder.getBeginDate();
           this.companyName = concreteBuilder.getCompanyName();
           this.endDate = concreteBuilder.getEndDate();
           this.otherData = concreteBuilder.getOtherData();
           this.personName = concreteBuilder.getPersonName();
        }
    
        /** * 保险合同的某些操作 */
        public void someOperation() {
            System.out.println("一些操作 " + this.contractId);
        }
    }

（1）构建保险合同对象的构建器 ConcreteBuilder

/** * 构建保险合同对象的构建器 * * @author lijun * @since 2018-03-29 14:11 */
    public class ConcreteBuilder { 
    
        /** * 保险合同编号 */
        private String contractId;
    
        /** * 被保人名称 同一份保险合同，要么跟人员签订，要么跟公司签订，也就是说，“被保险人员”和“被保公司" * 这个两个属性不可能同时有值。 */
        private String personName;
    
        /** * 被保公司 */
        private String companyName;
    
        /** * 保险开始生效的时间 */
        private long beginDate;
    
        /** * 保险失效时间 */
        private long endDate;
    
    
        /** * 其他数据 */
        private String otherData;
    
        public ConcreteBuilder(String contractId, long beginDate, long endDate) {
            this.contractId = contractId;
            this.beginDate = beginDate;
            this.endDate = endDate;
        }
    
        public ConcreteBuilder setPersonName(String personName) {
            this.personName = personName;
            return this;
        }
    
        public ConcreteBuilder setCompanyName(String companyName) {
            this.companyName = companyName;
            return this;
        }
    
        public ConcreteBuilder setOtherData(String otherData) {
            this.otherData = otherData;
            return this;
        }
    
        public String getContractId() {
            return contractId;
        }
    
        public void setContractId(String contractId) {
            this.contractId = contractId;
        }
    
        public String getPersonName() {
            return personName;
        }
    
    
        public String getCompanyName() {
            return companyName;
        }
    
    
        public long getBeginDate() {
            return beginDate;
        }
    
        public void setBeginDate(long beginDate) {
            this.beginDate = beginDate;
        }
    
        public long getEndDate() {
            return endDate;
        }
    
        public void setEndDate(long endDate) {
            this.endDate = endDate;
        }
    
        public String getOtherData() {
            return otherData;
        }
    
        /** * 构建真正的对象并返回 * * @return 构建的保险合同对象 */
        public Insurancecontract build() {
            return new Insurancecontract(this);
        }
    
    }

（3）Client

public class Client {
        public static void main(String[] args) {
    
            ConcreteBuilder concreteBuilder = new ConcreteBuilder("1000", 8999L, 67890L);
            Insurancecontract insurancecontract = concreteBuilder.setPersonName("LIJUN").setOtherData("Test").build();
            insurancecontract.someOperation();
        }
    }

1.  使用Builder模式来构建复杂对象，考虑带约束规则。  
    带约束规则的实现和刚才实现的并没有什么不同，只是需要在刚才的实现上把约束加上去。仅仅需要在ConcreteBuilder的方法build加上约束。

/** * 构建真正的对象并返回 * * @return 构建的保险合同对象 */
        public Insurancecontract build() {
            if (contractId == null || contractId.trim().length() == 0) {
                throw new IllegalArgumentException("合同编号不能为空！");
            }
            boolean personIs = personName == null || personName.trim().length() == 0;
            boolean companyIs = companyName == null || companyName.trim().length() == 0;
    
            if (personIs && companyIs) {
                throw new IllegalArgumentException("一份合同不能同时和个人和公司同签！");
            }
    
            if (personIs == false && companyIs == false) {
                throw new IllegalArgumentException("一份合同不能没有签订对象");
            }
    
            if (beginDate <= 0) {
                throw new IllegalArgumentException("保险合同必须有开始日期");
            }
            if (endDate<= 0) {
                throw new IllegalArgumentException("保险合同必须有失效日期");
            }
            if (endDate<= beginDate) {
                throw new IllegalArgumentException("保险合同失效日期必须大于生效日期");
            }
    
            return new Insurancecontract(this);
        }

1.  进一步，把构建对象和被构建对象合并。  
    把构建器合并到合同对象中作为内部类。

/** * 保险合同对象 * * @author lijun * @since 2018-03-29 13:18 */
    public class InsurancecontractMergeBuilder { 
    
        /** * 保险合同编号 */
        private String contractId;
    
        /** * 被保人名称 同一份保险合同，要么跟人员签订，要么跟公司签订，也就是说，“被保险人员”和“被保公司" * 这个两个属性不可能同时有值。 */
        private String personName;
    
        /** * 被保公司 */
        private String companyName;
    
        /** * 保险开始生效的时间 */
        private long beginDate;
    
        /** * beginDate< endDate * 保险失效时间 */
        private long endDate;
    
    
        /** * 其他数据 */
        private String otherData;
    
    
       private   InsurancecontractMergeBuilder(ConcreteBuilder concreteBuilder) {
           this.contractId = concreteBuilder.getContractId();
           this.beginDate = concreteBuilder.getBeginDate();
           this.companyName = concreteBuilder.getCompanyName();
           this.endDate = concreteBuilder.getEndDate();
           this.otherData = concreteBuilder.getOtherData();
           this.personName = concreteBuilder.getPersonName();
        }
    
    
        /** *构建保险合同对象的构建器 作为保险合同的类级内部内 */
        public static class ConcreteBuilder { 
    
            /** * 保险合同编号 */
            private String contractId;
    
            /** * 被保人名称 同一份保险合同，要么跟人员签订，要么跟公司签订，也就是说，“被保险人员”和“被保公司" * 这个两个属性不可能同时有值。 */
            private String personName;
    
            /** * 被保公司 */
            private String companyName;
    
            /** * 保险开始生效的时间 */
            private long beginDate;
    
            /** * 保险失效时间 */
            private long endDate;
    
    
            /** * 其他数据 */
            private String otherData;
    
            public ConcreteBuilder(String contractId, long beginDate, long endDate) {
                this.contractId = contractId;
                this.beginDate = beginDate;
                this.endDate = endDate;
            }
    
            public ConcreteBuilder setPersonName(String personName) {
                this.personName = personName;
                return this;
            }
    
            public ConcreteBuilder setCompanyName(String companyName) {
                this.companyName = companyName;
                return this;
            }
    
            public ConcreteBuilder setOtherData(String otherData) {
                this.otherData = otherData;
                return this;
            }
    
            public String getContractId() {
                return contractId;
            }
    
            public void setContractId(String contractId) {
                this.contractId = contractId;
            }
    
            public String getPersonName() {
                return personName;
            }
    
    
            public String getCompanyName() {
                return companyName;
            }
    
    
            public long getBeginDate() {
                return beginDate;
            }
    
            public void setBeginDate(long beginDate) {
                this.beginDate = beginDate;
            }
    
            public long getEndDate() {
                return endDate;
            }
    
            public void setEndDate(long endDate) {
                this.endDate = endDate;
            }
    
            public String getOtherData() {
                return otherData;
            }
    
            /** * 构建真正的对象并返回 * * @return 构建的保险合同对象 */
            public InsurancecontractMergeBuilder build() {
                if (contractId == null || contractId.trim().length() == 0) {
                    throw new IllegalArgumentException("合同编号不能为空！");
                }
                boolean personIs = personName == null || personName.trim().length() == 0;
                boolean companyIs = companyName == null || companyName.trim().length() == 0;
    
                if (personIs && companyIs) {
                    throw new IllegalArgumentException("一份合同不能同时和个人和公司同签！");
                }
    
                if (personIs == false && companyIs == false) {
                    throw new IllegalArgumentException("一份合同不能没有签订对象");
                }
    
                if (beginDate <= 0) {
                    throw new IllegalArgumentException("保险合同必须有开始日期");
                }
                if (endDate<= 0) {
                    throw new IllegalArgumentException("保险合同必须有失效日期");
                }
                if (endDate<= beginDate) {
                    throw new IllegalArgumentException("保险合同失效日期必须大于生效日期");
                }
    
                return new InsurancecontractMergeBuilder(this);
            }
    
        }
    
    
        /** * 保险合同的某些操作 */
        public void someOperation() {
            System.out.println("一些操作 " + this.contractId);
        }
    }

ClientMergeBuilder

public class ClientMergeBuilder {
        public static void main(String[] args) {
            InsurancecontractMergeBuilder.ConcreteBuilder concreteBuilder = new InsurancecontractMergeBuilder
                    .ConcreteBuilder("2000", 1234L, 4567L);
            InsurancecontractMergeBuilder insurancecontractMergeBuilder = concreteBuilder.setCompanyName("X")
                    .setOtherData("OF").build();
            insurancecontractMergeBuilder.someOperation();
        }
    }

### 4. 本质 ###

> 分离整体构建算法和部件构造。

### 5. 总结 ###

*  优点  
    
    
     *  松散耦合  
        生成器模式可以用同一个构建算法构建出表现上完全不同的产品，实现产品构建和产品表现上的分离。生成器模式正是把产品构建的过程独立出来，使它和具体产品的表现分松散耦合，从而使得构建算法可以复用，而具体产品表现也可以很灵活地、方便地扩展和切换。
     *  可以很容易的改变产品的内部表示  
        在生成器模式中，由于Builder对象只是提供接口给Director使用，那么具体部件创建和装配方式是被Builder接口隐藏了的，Director并不知道这些具体的实现细节。这样一来，要想改变产品的内部表示，只需要切换Builder接口的具体实现即可，不用管Director，因此变得很容易。
     *  更好的复用性  
        生成器模式很好的实现构建算法和具体产品实现的分离。这样一来，使得构建产品的算法可以复用。同样的道理，具体产品的实现也可以复用，同一个产品的实现，可以配合不同的构建算法使用。

### 6. 参考 ###

> 本文参考了《研磨设计模式》

[源码地址][Link 1] builder-pattern

[70]: /images/20220528/89b9d95bc45745a1b87c52021de0453f.png
[Link 1]: https://github.com/ljmomo/learn-pattern