生成器模式（Builder）
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> mapData);
/**
* 构建输出文件的Footer部分
* @param efm 文件尾的内容
*/
public void buildFooter(ExportFooterModel efm);
}
/**
* 实现导出数据到文本文件的的构建器对象
*/
public class TxtBuilder implements Builder {
/**
* 用来记录构建的文件的内容，相当于产品
*/
private StringBuffer buffer = new StringBuffer();
public void buildBody(
Map> 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> mapData) {
buffer.append(" \n");
for(String tblName : mapData.keySet()){
//先拼接表名称
buffer.append(" +tblName+"\">\n");
//然后循环拼接具体数据
for(ExportDataModel edm : mapData.get(tblName)){
buffer.append(" \n");
buffer.append(" " +edm.getProductId()+"\n");
buffer.append(" " +edm.getPrice()+"\n");
buffer.append(" " +edm.getAmount()+"\n");
buffer.append(" \n");
}
buffer.append(" \n");
}
buffer.append(" \n");
}
public void buildFooter(ExportFooterModel efm) {
buffer.append(" );
buffer.append(" " +efm.getExportUser()+"\n");
buffer.append(" \n");
buffer.append("\n");
}
public void buildHeader(ExportHeaderModel ehm) {
buffer.append("\n");
buffer.append("\n" );
buffer.append(" \n" );
buffer.append(" " +ehm.getDepId()+"\n");
buffer.append(" " +ehm.getExportDate()+"\n");
buffer.append(" \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> 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> mapData = new HashMap>();
Collection col = new ArrayList();
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();
}
}