`

生成器模式

 
阅读更多
阅读《研磨设计模式》笔记。之后若有所感，再补充。
生成器模式目的：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
示例： 
/**
 * @description 描述输出到文件头的对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
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;
	}
}


/**
 * @description 描述输出数据的对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ExportDataModel {
	/**产品编号*/
	private String productId;
	/**销售价格*/
	private String price;
	/**销售数量*/
	private String amount;
	
	public String getProductId() {
		return productId;
	}
	public void setProductId(String productId) {
		this.productId = productId;
	}
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	public String getAmount() {
		return amount;
	}
	public void setAmount(String amount) {
		this.amount = amount;
	}
}


/**
 * @description描述输出到文件尾的内容的对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class ExportFooterModel {
	/**输出人*/
	private String exportUser;

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


/**
 * @description 生成器接口，定义创建一个输出文件对象所需的各个部件的操作
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
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);

}


/**
 * @description 实现导出数据到文本文件的生成器对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class TxtBuilder implements Builder{
	/**
	 * 用来记录构建的文件内容，相当于产品
	 */
	private StringBuffer buffer = new StringBuffer();
	/* (non-Javadoc)
	 * @see builder.Builder#buildHeader(builder.ExportHeaderModel)
	 */
	@Override
	public void buildHeader(ExportHeaderModel ehm) {
		buffer.append(ehm.getDepId() + "," + ehm.getExportDate() + "\n");
	}
	/* (non-Javadoc)
	 * @see builder.Builder#buildBody(java.util.Map)
	 */
	@Override
	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");
			}
		}
	}
	/* (non-Javadoc)
	 * @see builder.Builder#buildFooter(builder.ExportFooterModel)
	 */
	@Override
	public void buildFooter(ExportFooterModel efm) {
		buffer.append(efm.getExportUser());
	}
	
	public StringBuffer getResult(){
		return buffer;
	}
}


/**
 * @description实现导出数据到xml文件的生成器对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
public class XmlBuilder implements Builder{
	/**
	 * 用来记录构建的文件内容，相当于产品
	 */
	private StringBuffer buffer = new StringBuffer();
	/* (non-Javadoc)
	 * @see builder.Builder#buildHeader(builder.ExportHeaderModel)
	 */
	@Override
	public void buildHeader(ExportHeaderModel ehm) {
		buffer.append("<?xml version='1.0' encoding='GBK'?>\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");
	}
	/* (non-Javadoc)
	 * @see builder.Builder#buildBody(java.util.Map)
	 */
	@Override
	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");
	}
	/* (non-Javadoc)
	 * @see builder.Builder#buildFooter(builder.ExportFooterModel)
	 */
	@Override
	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 StringBuffer getResult(){
		return buffer;
	}
}


/**
 * @description 指导者，指导使用生成器的接口来构建输出的文件的对象
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
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);
	}
}


/**
 * @description 生成器模式：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
 * @author liuwei
 * @date 2014-4-17
 * @version 1.0
 */
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();
	       //创建指导者对象
	       Director director = new Director(txtBuilder);
	       director.construct(ehm, mapData, efm);
	       //输出文本文件内容
	       System.out.println("输出文本文件的内容：\n" + txtBuilder.getResult());
	       
	       //测试输出到xml文件
	       XmlBuilder xmlBuilder = new XmlBuilder();
	       Director director2 = new Director(xmlBuilder);
	       director.construct(ehm, mapData, efm);
	       //输出xml文件内容
	       System.out.println("输出xml文件的内容：\n" + xmlBuilder.getResult());
	}
}
分享到：
| 抽象工厂模式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    23钟设计模式之生成器模式

    生成器模式 生成器模式（Builder Pattern）是一种创造型设计模式，它将一个复杂对象的构建与它的表示分离，使得同样的构建可以创建不同的表示。这种模式可以在以下情况下使用： 1. 当创建复杂对象的算法应该独立于...

    生成器模式代码示例

    生成器模式是一种设计模式，属于创建型模式，它允许我们分步骤构建复杂对象，而无需提前知道整个对象的完整结构。这种模式的核心在于延迟初始化，它使得我们可以根据需要逐步构建对象，而不是一次性创建所有部分。在...

    java生成器模式

    生成器模式（Builder Pattern）是Java设计模式中的创建型模式之一，主要解决复杂对象的构建问题，通过将构造过程逐步分解，使得构造过程与表示分离，使得同样的构建过程可以创建不同的表示。这种模式通常用于创建...

    生成器模式源代码

    生成器模式，也被称为构建器模式，是一种软件设计模式，主要用在对象的创建过程中，它将复杂的构建过程分解为一系列简单的步骤，使得构建过程可配置，并且可以独立于对象的表示进行。在C#中，生成器模式的实现通常...

    使用生成器模式模拟实现IBM电脑的生产

    使用生成器模式模拟实现IBM电脑的生产，其中IBM电脑的主要结构用如下表示： class IBM{  string monitor=”IBM的显示器”;  string keyboard=”IBM的键盘”;  string mouse=”IBM的鼠标”;  Motherboard* MB;  ...

    生成器模式例子

    在《Head First Design Patterns》文中是这么介绍生成器模式的，“封装一个产品的构造过程，并允许按步骤构造”,感觉说得不是很清楚。而在网上查找相关资料是这么解释的，建造者模式（Builder Pattern）使用多个简单...

    生成器模式builder

    生成器模式（Builder Pattern）是一种设计模式，它允许我们分步骤构建复杂对象，而无需暴露其构造过程。这种模式在创建对象时提供了更大的灵活性，特别是当构造过程需要多个步骤或者对象有不同的构造方式时。Builder...

    iOS 生成器模式demo

    在iOS开发中，生成器模式（Builder Pattern）是一种设计模式，它允许我们分步骤构建复杂的对象，而无需暴露创建过程的复杂性。这种模式在处理需要多种构建方式或需要逐步构造对象的情况时特别有用。标题“iOS 生成器...

    C#设计模式之Builder生成器模式解决带老婆配置电脑问题实例

    本文主要介绍了C#设计模式之Builder生成器模式解决带老婆配置电脑问题，简单介绍了生成器模式的概念、功能并结合具体实例形式分析了C#生成器模式解决配电脑问题的步骤与相关操作技巧。 一、 Builder生成器模式定义 ...

    iOS 生成器模式

    生成器模式是设计模式中的一种，它属于创建型模式，主要用来处理复杂对象的构建过程。在这个“iOS生成器模式”中，我们将深入探讨如何在iOS开发中应用这个模式。 生成器模式的核心思想是将对象的创建过程和对象本身...

    【设计模式】- 生成器模式(Builder)（csdn）————程序.pdf

    生成器模式，也称为建造者模式，是一种设计模式，用于创建复杂对象，它允许你按照一系列步骤来构造对象，而这些步骤可以通过不同的实现来产生不同形式的对象。生成器模式的核心在于分离了对象的构造过程和表示细节，...

    3 生成器模式.txt

    3 生成器模式.txt

    23种设计模式（4） java生成器模式

    Java 生成器模式详解 在软件开发中，经常需要创建复杂对象，而这些对象的创建过程往往涉及多个步骤和组件。为了解决这种问题，设计模式中引入了生成器模式（Builder Pattern）。生成器模式是一种创建型模式，它将...

    C#面向对象设计模式纵横谈\4 创建型模式Builder生成器模式.zip

    在这里与各位分享本人从网络上下载的C#面向对象设计模式纵横谈系列视频，共有25节，除了第一节需要各位贡献一点资源分以作为对本人上传资源的回馈，后面的其他资源均不需要... 这是第4节：创建型模式Builder生成器模式

    JavaScript设计模式之构造器模式(生成器模式)定义与用法实例分析

    在众多的设计模式中，构造器模式（也称为生成器模式）是实现面向对象编程的一种基本方式。在构造器模式中，构造函数用于创建特定的对象，每个新创建的实例都继承构造函数的属性和方法。 构造器模式的核心概念是利用...

    C#面向对象设计模式4：生成器(Builder)

    生成器模式是一种创建型设计模式，它允许我们分步骤构建复杂对象，同时隐藏了对象组装的细节。这种模式的核心思想是将产品的构造过程与产品本身分离，使构造过程可以有不同的表示方式。生成器模式通常由四个主要角色...

    iOS设计模式-生成器

    通过这种方式，生成器模式允许我们分离产品的构造和表示，提供了更灵活的构造过程。 首先，让我们深入理解生成器模式的核心概念。生成器模式通常由四个组件构成：Director（导演）、ConcreteBuilder（具体生成器）...

Magicbox
Global site tag (gtag.js) - Google Analytics