生成器模式(Builder)

原创 2016年07月09日 22:44:41

1. 模式的定义

不管是输出成文本文件,还是输出到XML文件,在实现的时候,步骤基本都是一样的,大致可以分为以下四步:
1)先拼接文件头的内容
2)然后拼接文件体的内容
3)再拼接文件尾的内容
4)最后拼接好的内容输出称为文件

换句话说,也就是构建每种格式的数据文件的处理过程,应该和具体的步骤实现分开,这样能够复用处理过程。

生成器模式的定义:将一个复杂对象的构建过程与它的表示分离,使得同样的构建过程可以创建不同的表示。

2. UML图

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

代码:
对同一个构建过程,只要配置不同的生成器实现,就会生成不同实现的对象。

/**
 * 描述输出到文件头的内容的对象
 */
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;
    }
}


/**
 * 描述输出数据的对象
 */
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;
    }

}

/**
 * 描述输出到文件尾的内容的对象
 */
public class ExportFooterModel {
    /**
     * 输出人
     */
    private String exportUser;

    public String getExportUser() {
        return exportUser;
    }

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

}

/**
 * 构建器接口,定义创建一个输出文件对象所需的各个部件的操作
 */
public interface Builder {
    /**
     * 构建输出文件的Header部分
     * @param ehm 文件头的内容
     */
    public void buildHeader(ExportHeaderModel ehm);
    /**
     * 构建输出文件的Body部分
     * @param mapData 要输出的数据的内容
     */
    public void buildBody(Map<String,Collection<ExportDataModel>> mapData);
    /**
     * 构建输出文件的Footer部分
     * @param efm 文件尾的内容
     */
    public void buildFooter(ExportFooterModel efm);
}

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

/**
 * 实现导出数据到XML文件的的构建器对象
 */
public class XmlBuilder implements Builder {
    /**
     * 用来记录构建的文件的内容,相当于产品
     */
    private StringBuffer buffer = new StringBuffer();
    public void buildBody(
            Map<String, Collection<ExportDataModel>> mapData) {
        buffer.append("  <Body>\n");
        for(String tblName : mapData.keySet()){
            //先拼接表名称
            buffer.append("    <Datas TableName=\""+tblName+"\">\n");
            //然后循环拼接具体数据
            for(ExportDataModel edm : mapData.get(tblName)){
                buffer.append("      <Data>\n");
                buffer.append("        <ProductId>"+edm.getProductId()+"</ProductId>\n");
                buffer.append("        <Price>"+edm.getPrice()+"</Price>\n");
                buffer.append("        <Amount>"+edm.getAmount()+"</Amount>\n");
                buffer.append("      </Data>\n");
            }
            buffer.append("    </Datas>\n");
        }
        buffer.append("  </Body>\n");
    }

    public void buildFooter(ExportFooterModel efm) {
        buffer.append("  <Footer>\n");
        buffer.append("    <ExportUser>"+efm.getExportUser()+"</ExportUser>\n");
        buffer.append("  </Footer>\n");
        buffer.append("</Report>\n");
    }

    public void buildHeader(ExportHeaderModel ehm) {
        buffer.append("<?xml version='1.0' encoding='gb2312'?>\n");
        buffer.append("<Report>\n");
        buffer.append("  <Header>\n");
        buffer.append("    <DepId>"+ehm.getDepId()+"</DepId>\n");
        buffer.append("    <ExportDate>"+ehm.getExportDate()+"</ExportDate>\n");
        buffer.append("  </Header>\n");
    }
    public StringBuffer getResult(){
        return buffer;
    }

}


/**
 * 指导者,指导使用构建器的接口来构建输出的文件的对象
 */
public class Director {
    /**
     * 持有当前需要使用的构建器对象
     */
    private Builder builder;
    /**
     * 构造方法,传入构建器对象
     * @param builder 构建器对象
     */
    public Director(Builder builder) {
        this.builder = builder;
    }
    /**
     * 指导构建器构建最终的输出的文件的对象
     * @param ehm 文件头的内容
     * @param mapData 数据的内容
     * @param efm 文件尾的内容
     */
    public void construct(ExportHeaderModel ehm,Map<String,Collection<ExportDataModel>> mapData,ExportFooterModel efm) {
        //1:先构建Header
        builder.buildHeader(ehm);
        //2:然后构建Body
        builder.buildBody(mapData);
        //3:然后构建Footer
        builder.buildFooter(efm);
    }
}

public class Client {
    public static void main(String[] args) {
        //准备测试数据
        ExportHeaderModel ehm = new ExportHeaderModel();
        ehm.setDepId("一分公司");
        ehm.setExportDate("2010-05-18");

        Map<String,Collection<ExportDataModel>> mapData = new HashMap<String,Collection<ExportDataModel>>();
        Collection<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(99);
        edm2.setAmount(55);     
        //把数据组装起来
        col.add(edm1);
        col.add(edm2);      
        mapData.put("销售记录表", col);

        ExportFooterModel efm = new ExportFooterModel();
        efm.setExportUser("张三");

        //测试输出到文本文件
        TxtBuilder txtBuilder = new TxtBuilder();//1
        //创建指导者对象
        Director director = new Director(txtBuilder);
        director.construct(ehm, mapData, efm);
        //把要输出的内容输出到控制台看看
        System.out.println("输出到文本文件的内容:\n"+txtBuilder.getResult());
        //测试输出到xml文件
        XmlBuilder xmlBuilder = new XmlBuilder();//2
        Director director2 = new Director(xmlBuilder);
        director2.construct(ehm, mapData, efm);
        //把要输出的内容输出到控制台看看
        System.out.println("输出到XML文件的内容:\n"+xmlBuilder.getResult());
    }
}

3. 研磨设计模式

生成器模式重在一步一步解决构造复杂对象的问题。这个构建过程是统一的,固定不变的,变化的部分放到生成器部分了,只要配置不同的生成器,那么同样的构建过程,就能构建出不同的产品来。

生成器模式的重心在于分离构建算法与具体的构造实现。

生成器模式的本质:分离整体构建算法和部件构建

构建保险合同对象:

/**
 * 保险合同的对象
 */
public class InsuranceContract {
    /**
     * 保险合同编号
     */
    private String contractId;
    /**
     * 被保险人员的名称,同一份保险合同,要么跟人员签订,要么跟公司签订,
     * 也就是说,"被保险人员"和"被保险公司"这两个属性,不可能同时有值
     */
    private String personName;
    /**
     * 被保险公司的名称
     */
    private String companyName;
    /**
     * 保险开始生效的日期
     */
    private long beginDate;
    /**
     * 保险失效的日期,一定会大于保险开始生效的日期
     */
    private long endDate;
    /**
     * 示例:其它数据
     */
    private String otherData;

    /**
     * 构造方法,访问级别是私有的
     */
    private InsuranceContract(ConcreteBuilder builder){
        this.contractId = builder.contractId;
        this.personName = builder.personName;
        this.companyName = builder.companyName;
        this.beginDate = builder.beginDate;
        this.endDate = builder.endDate;
        this.otherData = builder.otherData;
    }

    /**
     * 构造保险合同对象的构建器
     */
    public static class ConcreteBuilder {
        private String contractId;
        private String personName;
        private String companyName;
        private long beginDate;
        private long endDate;
        private String otherData;
        /**
         * 构造方法,传入必须要有的参数
         * @param contractId 保险合同编号
         * @param beginDate 保险开始生效的日期
         * @param endDate 保险失效的日期
         */
        public ConcreteBuilder(String contractId,long beginDate,long endDate){
            this.contractId = contractId;
            this.beginDate = beginDate;
            this.endDate = endDate;
        }
        /**
         * 选填数据,被保险人员的名称
         * @param personName  被保险人员的名称
         * @return 构建器对象
         */
        public ConcreteBuilder setPersonName(String personName){
            this.personName = personName;
            return this;
        }
        /**
         *  选填数据,被保险公司的名称
         * @param companyName 被保险公司的名称
         * @return 构建器对象
         */
        public ConcreteBuilder setCompanyName(String companyName){
            this.companyName = companyName;
            return this;
        }
        /**
         * 选填数据,其它数据
         * @param otherData 其它数据
         * @return 构建器对象
         */
        public ConcreteBuilder setOtherData(String otherData){
            this.otherData = otherData;
            return this;
        }
        /**
         * 构建真正的对象并返回
         * @return 构建的保险合同的对象
         */
        public InsuranceContract build(){
            if(contractId==null || contractId.trim().length()==0){
                throw new IllegalArgumentException("合同编号不能为空");
            }
            boolean signPerson = personName!=null && personName.trim().length()>0;
            boolean signCompany = companyName!=null && companyName.trim().length()>0;
            if(signPerson && signCompany){
                throw new IllegalArgumentException("一份保险合同不能同时与人和公司签订");
            }       
            if(signPerson==false && signCompany==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);
        }
    }

    /**
     * 示意:保险合同的某些操作
     */
    public void someOperation(){
        System.out.println("Now in Insurance Contract someOperation=="+this.contractId);
    }
}

public class Client {
    public static void main(String[] args) {
        //创建构建器
        InsuranceContract.ConcreteBuilder builder = new InsuranceContract.ConcreteBuilder("001",12345L,67890L);
        //设置需要的数据,然后构建保险合同对象
        InsuranceContract contract = builder.setPersonName("张三").setOtherData("test").build();
        //操作保险合同对象的方法
        contract.someOperation();
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Builder生成器(创建型模式)

如果使用最直观的设计方法,每一个房屋部分的变化,都将导致房屋构建的重新修正... 分析,构建房屋的组成结构是稳定的,但是房屋的窗口,门的风格可能并不固定 动机(Mo...

生成器(Builder)设计模式

将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式。 如下图所示:   生成器模式的参与者包括 Builder、ConcreteBuild...

创建型模式-生成器(builder)

生成器将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.实例main.cc:/* design_patterns:"builder" In the production of ...

生成器模式(Builder Pattern )

一. 生成器模式简介   生成器模式也有称为建造者模式。生成器模式的意图在于将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示(GoF)。在软件设计中,有时候面临着一个非常复杂的对...

设计模式(2)—— 生成器 (Builder)

Builder解决的问题 Builder(生成器)的模式用于用多个部件生成不同产品的问题: Builder模式适用于: 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时 当构...

1.2 Builder(生成器) -- 对象创建型模式

在内蒙古这辽阔的草原上,放养着成千上万的奶牛。蒙牛集团在这里崛起,迅速抢占中国大半牛奶市场,造就了一个商业帝国。蒙牛集团牛奶生产流程大致是这样的: 放养奶牛--->牛奶加工--->牛奶包装--->销售...

三、Builder 生成器模式(创建型)

三、Builder 生成器模式(创建型) 1、意图:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。 2、场景:在电脑城装机总有这样的经历。我们到了店里,先会有一个销售人员来...

Builder(生成器模式)

名  称 Builder(生成器模式) 意  图 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 适  用 环  境 当创建复杂对象的算法应该独立于该对象的组成部分以及它们...
  • wkcgy
  • wkcgy
  • 2011年06月22日 08:36
  • 186

设计模式---生成器(Builder)

目的:在软件开发的过程中不可避免地会碰到一些复杂的对象。如果直接去创建这些复杂的对象,会使代码变得难于理解和维护,而且对于大多数用户而言他们并不关心对象各个成员的创建过程。Builder的作用就是将对...

设计模式 - 生成器 Builder

1. 意图 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 2.适用性 在以下情况使用Builder模式 当创建复杂对象的算法应该独立与该对象的组成部分及他...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:生成器模式(Builder)
举报原因:
原因补充:

(最多只允许输入30个字)