设计模式之（五）建造者（生成器）模式（Builder）

　　考虑这样一种业务场景，我们构建一个业务对象，但是这个业务对象及其复杂。为了代码的根号的可读性，我们会把这个对象的构建过程根据精密联系的程度来拆分成几个类来完成。最后再放到一起使用来生成复杂对象。这个业务场景非常常见，接下来就分析一下解决这个问题更灵活的方式，即：建造者模式。

　　建造者模式定义及规范代码

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

　　看到这个定义以后，肯定有很多读者会有疑问，【复杂对象的创建】的创建好理解，但是【它（复杂对象）的表示】是什么意思呢，这里为了解决读者可能出现猴急的心情，先大概解释一下。首先看建造者模式的结构图

            

　　Builder：生成器接口，定义创建一个产品所需要的的各个部分的操作。

　　ConcreateBuilder：具体的生成器实现，这个产品在组装过程中各个部分所需要的共同的操作。并且还提供一个供用户获取组装完产品的对象。

　　Director：指导者，主要用来使用 builder 接口，以一个统一的过程来构建所需要的 Product 对象

　　Product：产品，表示被生成器构建的复杂对象，包含多个部件。

　　接下来说下我的理解。建造者模式在创建相似的复杂对象使用，其中 Builder 定义创建这个复杂对象的过程，把创建过程分为不同的部分，也可以说是不同的组成部分。而 ConcreateBuilder 则是对复杂对象创建每部分共同的部分实现出来。

　    相似复杂对象的每步骤相似部分在 ConcreateBuilder 创建，而不同部分则另外创建，以参数形式传入相应的部分。这个具体如何组装，则是在 Director 中来完成。在这个初步理解的基础上。通过以下例子来具体分析。

/**
 * 生成器接口，定义创建一个输出文件对象所需的各个部件的操作
 * @author Administrator
 */
public interface Builder {
    
    //构建输出的文件头内容
    public void builderHeader(ExportHeaderModel ehm);
    
    //构建输出的文件正文数据内容
    public void BuilderBody(Map<String,Collection<ExportDataModel>> bodyData);
    
    //构建文件尾内容
    public void builderFooter(ExportFooterModel efm);
}

/**
 * 描述输出到文件头部内容的对象
 */
public class ExportHeaderModel {
    
    /**
     * 分公司或门市店的编号
     */
    private String DepID;
    
    /**
     * 导出数据的日期
     */
    private String exportDate;

    public String getDepID() {
        return DepID;
    }

    public void setDepID(String depID) {
        DepID = depID;
    }

    public String getExportDate() {
        return exportDate;
    }

    public void setExportDate(String exportDate) {
        this.exportDate = exportDate;
    }
}

/**
 * 描述生成文件输的对象
 * @author Administrator
 *
 */
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 Administrator
 *
 */
public class ExportFooterModel {
    
    /**
     * 输出人
     */
    private String exportUser;

    public String getExportUser() {
        return exportUser;
    }

    public void setExportUser(String exportUser) {
        this.exportUser = exportUser;
    }
}

/**
 * 相当于 ConcreteBuilder
 * @author Administrator
 *
 */
public class TxtBuilder implements Builder {

    //用来构建文件的内容，相当于产品
    private StringBuffer buffer = new StringBuffer();
    
    @Override
    public void builderHeader(ExportHeaderModel ehm) {
        // TODO Auto-generated method stub
        buffer.append("分公司编号："+ehm.getDepID()+"，导入日期："+ehm.getExportDate()+"
");
    }

    @Override
    public void BuilderBody(Map<String, Collection<ExportDataModel>> bodyData) {
        // TODO Auto-generated method stub
        for(String tblName:bodyData.keySet()){
            buffer.append(tblName+"
");
            for(ExportDataModel edm:bodyData.get(tblName)){
                buffer.append(edm.getProductID()+",  "+edm.getPrice()+", "+edm.getAmount()+"
");
            } 
        }
    }

    @Override
    public void builderFooter(ExportFooterModel efm) {
        // TODO Auto-generated method stub
        buffer.append(efm.getExportUser()+"
");
    }
    
    public StringBuffer getResult(){
        return buffer;
    }
}


/**
 * 相当于 ConcreteBuilder
 * @author Administrator
 *
 */
public class XmlBuilder implements Builder {

    //用来构建文件的内容，相当于产品
    private StringBuffer buffer = new StringBuffer();
    
    @Override
    public void builderHeader(ExportHeaderModel ehm) {
        // TODO Auto-generated method stub
        buffer.append("<?xml verson='1.0' encoding='gb2312'?>
");
        buffer.append("<Report>
");
        buffer.append("   <Header>
");
        buffer.append("      <DeptID>"+ehm.getDepID()+"</DeptID>
");
        buffer.append("         <ExportDate>"+ehm.getExportDate()+"</ExportDate>
");
        buffer.append("   </Header>
");
    }

    @Override
    public void BuilderBody(Map<String, Collection<ExportDataModel>> bodyData) {
        // TODO Auto-generated method stub
        buffer.append("   <Body>
");
        for(String tblname:bodyData.keySet()){
            buffer.append("   <Dates TableName = ""+tblname+"">
");
            for(ExportDataModel edm:bodyData.get(tblname)){
                buffer.append("   <Date>
");
                buffer.append("       <ProductID> "+edm.getProductID()+"</ProductID>
");
                buffer.append("       <Price> "+edm.getPrice()+"</Price>
");
                buffer.append("       <Amount> "+edm.getAmount()+"</Amount>
");
            }
        }
        buffer.append("   <Body>
");
    }

    @Override
    public void builderFooter(ExportFooterModel efm) {
        // TODO Auto-generated method stub
        buffer.append("    <Footer>
");
        buffer.append("        <User>"+efm.getExportUser()+"</User>
");
        buffer.append("    </Footer>
");
        buffer.append("</Report>
");
    }
    
    public StringBuffer getResult(){
        return buffer;
    }

}


public class Director {
    
    private Builder builder;
    
    public Director(Builder builder){
        this.builder = builder;
    }
    
    public void construct(ExportHeaderModel ehm,Map<String,Collection<ExportDataModel>> bodyData,ExportFooterModel efm){
        builder.builderHeader(ehm);
        
        builder.BuilderBody(bodyData);
        
        builder.builderFooter(efm);
    }
}


public class Client {
    
    public static void main(String[] args) {
        ExportHeaderModel ehm = new ExportHeaderModel();
        ehm.setDepID("0001");
        ehm.setExportDate("2019-04-26");
        
        ExportDataModel edm = new ExportDataModel();
        edm.setProductID("cp001");
        edm.setPrice(5.56);
        edm.setAmount(133333);
        
        ExportDataModel edm2 = new ExportDataModel();
        edm2.setProductID("cp001");
        edm2.setPrice(5.56);
        edm2.setAmount(133333);
        
        Map<String,Collection<ExportDataModel>> data = new HashMap<String,Collection<ExportDataModel>>();
        Collection<ExportDataModel> collect = new ArrayList<ExportDataModel>();
        
        collect.add(edm);
        collect.add(edm2);
        
        data.put("bodys", collect);
        
        ExportFooterModel efm = new ExportFooterModel();
        efm.setExportUser("pwg");
        
        TxtBuilder tb = new TxtBuilder();
        Director dr = new Director(tb);
        
        dr.construct(ehm, data, efm);
        
        System.out.println("输出到文本文件："+tb.getResult());
        
        XmlBuilder xml = new XmlBuilder();
        Director dr2 = new Director(xml);
        dr2.construct(ehm, data, efm);
        
        System.out.println("输出到 xml 文件：
"+xml.getResult());
    }
    
    
}

        上面的代码例子展示了建造者模式的功能。其中为了比较好的展示实现了两个不同的产品，实现了两个不同的表示，而 Director 只是实现了一个，但是通过例子可以看出，如果需要。也可以实现不同 Director ，即产品的组装过程。这样产品就是很灵活的扩展性，并且产品的表示和组建过程解耦。

　　 进而分析出建造者模式的本事是区分 复杂对象的创建  和  它的表示  。这两个在代码中的体现是 Director  和   XmlBuilder  TxtBuilder。

 分析建造者生成器模式

       建造者模式应用场景：可以灵活的、易扩展的创建复杂对象。而解决的办法就是分离构建算法和具体构造实现。这样在扩展的时候可以根据需要切换 构建算法（Director  ）和 具体构造实现 （Builder）。只要抓住了这点，基本就理解了生成器的本质了。