当前位置:首页 > 开发 > 编程语言 > 设计模式 > 正文

读《研磨设计模式》-代码笔记-生成器模式-Builder

发表于: 2012-08-21   作者:bylijinnan   来源:转载   浏览:
摘要: 声明: 本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 生成器模式的意图在于将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示(GoF) * 个人理解: * 构建一个复杂的对象,对于创建者(Builder)来说,一是要有数据来源(rawData),二是要返回构
声明:
本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/




/**
 * 生成器模式的意图在于将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示(GoF)
 * 个人理解:
 * 构建一个复杂的对象,对于创建者(Builder)来说,一是要有数据来源(rawData),二是要返回构建好的对象(product)
 * 那么AbstractBuilder就自然持有了rawData和product对象
 * 然后将创建过程分成相对不变的几个步骤,这几个步骤交由子类去实现,那就实现了不同的Builder能“创建不同的表示”
 * 另外,定义一个Director,将Builder创建产品的几个步骤封装到一个方法里,向外提供统一的接口而不暴露细节
 * 
 * 书上考虑了一个数据导出到文件的问题。假设要生成的HTML和XML文件都只包含header和body
 */

abstract class AbstractBuilder {
	
	//构造产品的原始数据。也可以写成方法参数传递:buildHeader(String rawData);buildBody(String rawData);
	protected String rawData;
	
	protected FileProduct product;

	public abstract void buildHeader();

	public abstract void buildBody();

	public FileProduct getProduct() {
		return product;
	}
	
}

class HTMLBuilder extends AbstractBuilder {
	
	public HTMLBuilder(String rawData) {
		this.rawData = rawData;
		this.product = new FileProduct();
	}
	
	@Override
	public void buildHeader() {
		String[] rawDatas = rawData.split(",");
		product.setHeader("<html:header>" + rawDatas[0] + "</html:header>");
	}

	@Override
	public void buildBody() {
		String[] rawDatas = rawData.split(",");
		product.setBody("<html:body>" + rawDatas[1] + "</html:body>");
	}

}

class XMLBuilder extends AbstractBuilder {
	
	public XMLBuilder(String rawData) {
		this.rawData = rawData;
		this.product = new FileProduct();
	}
	
	@Override
	public void buildHeader() {
		String[] rawDatas = rawData.split(",");
		product.setHeader("<xml:header>" + rawDatas[0] + "</xml:header>");
	}

	@Override
	public void buildBody() {
		String[] rawDatas = rawData.split(",");
		product.setBody("<xml:body>" + rawDatas[1] + "</xml:body>");
	}

}


class FileProduct {

    private String header;
    private String body;

    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }
    
    public String toString() {
        return  header + "\n" + body;
    }

}


class Director {
	
	private AbstractBuilder builder;

	public Director(AbstractBuilder builder) {
		this.builder = builder;
	}
	
	public void build() {
		builder.buildHeader();
		builder.buildBody();
	}
	
}


public class BuilderPattern {

	public static void main(String[] args) {
		String rawData = "xx,yy";
		
		AbstractBuilder xmlBuilder = new XMLBuilder(rawData);
		Director director = new Director(xmlBuilder);
		director.build();
		System.out.println(xmlBuilder.getProduct());
		
		AbstractBuilder htmlBuilder = new HTMLBuilder(rawData);
		Director director2 = new Director(htmlBuilder);
		director2.build();
		System.out.println(htmlBuilder.getProduct());
		
		//测试:用Builder模式创建对象
		MassiveObject data = new MassiveObject.Builder("001").name("Tom").position("CEO").build();
		System.out.println(data);
	}

}



/**
 * 创建有约束的复杂对象。可以在两个地方加上约束:
 * 1、在InsuranceContract的构造函数时加约束
 * 2、在Builder的setter里面加约束
 */
class InsuranceContract {
    
    private String id;
    private String name;
    private String position;
    
    /*
     * 访问类别是default,不支持包外的其他类直接利用构造函数来创建InsuranceContract,
     * 但也带来一个问题是,同包的其他类可能会直接调用构造函数来创建InsuranceContract
     * 因此,较好的办法是像Effective Java里面建议的那样,把Builder做成inner class
     */
    //1.可以这里加约束
    InsuranceContract(ConcreteBuilder builder) {
        this.id = builder.getId();
        this.name = builder.getName();
        this.position = builder.getPosition();
    }
    
    public String toString() {
        return "id = " + id + ",name = " + name + ",position = " + position;
    }
    
    public void otherOperation() {
        
    }
    
}


class ConcreteBuilder {
    
    private String id;
    private String name;
    private String position;
    
    public InsuranceContract build() {
        return new InsuranceContract(this);
    }
    
    //假设id是必填数据,其他为选填数据
    public ConcreteBuilder(String id) {
        this.id = id;
    }
    
    //将ConcreteBuilder返回
    public ConcreteBuilder setName(String name) {
      //2.可以这里加约束
        this.name = name;
        return this;
    }

    public ConcreteBuilder setPosition(String position) {
        this.position = position;
        return this;
    }
    
    public String getPosition() {
        return position;
    }

    public String getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
}



/**
 * Effective Java里面建议:
 * 在生成一个复杂对象(field很多,造成构造函数的参数列表很长且顺序易出错)时,考虑用Builder模式
 */
class MassiveObject {
	private String id;
	private String name;
	private String position;

	private MassiveObject(Builder builder) {
		this.id = builder.id;
		this.name = builder.name;
		this.position = builder.position;
	}

	public String toString() {
		return "id=" + id + ",name=" + name + ",position=" + position;
	}
	
	public static class Builder {
		private String id;
		private String name;
		private String position;

		public Builder(String id) {
			this.id = id;
		}

		public Builder name(String name) {
			this.name = name;
			return this;
		}
		
		public Builder position(String position) {
			this.position = position;
			return this;
		}

		public MassiveObject build() {
			return new MassiveObject(this);
		}
	}
}



读《研磨设计模式》-代码笔记-生成器模式-Builder

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
生成器模式: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 结构图
1. 意图 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 2.适用性
8.2 解决方案 8.2.1 生成器模式来解决 用来解决上述问题的一个合理的解决方案就是生成器模式。那么
8.3 模式讲解 8.3.1 认识生成器模式 (1)生成器模式的功能 生成器模式的主要功能是构建复杂的产品
1.1 BUILDER生成器 1、 意图 将一个复杂对象的构建和它的表示分离,使得同样的构建过程可以创建不同
  生成器模式又称建造者模式,定义一个抽象的建造者的角色(Builder),规定所有具体的建造者都应
转载自:http://blog.csdn.net/top_code/article/details/8469297 定义:将一个复杂对象的构建与它
Java 设计模式之 生成器模式(Builder) 2011-06-15 22:49:37| 分类: Java 设计模式 | 标签:java
作用:一个类可以有不同的部件供选择,这些部件变化频繁,但是有稳定的算法来组合它们。 实现要点:
问题聚焦: 生成器模式是对象创建型模式的一种 它将一个复杂的对象的构建与它的表示分离,使得同样
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号