构建者模式和抽象工厂模式的结合使用

目标实现：

要求通过构建者模式和抽象工厂模式实现“造人计划”，方便起见，我们根据颜色将人种分类——Yellowman， Whiteman，Blackman，Redman，Greenman and so on。

设计思路：

一、 生成一个完整的人主要经历两个主要环节，1、人体部件的生产。 2、人体部件的组装。先说说人体部件的生产，不管哪类人种，身体部件的数量都是一样的，他们的差异主要是在身体部件的形态上的差异，这里假设只存在颜色上的差异，这里假设将人只划分为Head，Body，Foot三部件，不同人种的部件上存在颜色上的差异。uml图如下。

Human类：

public class Human {

	private Head head;
	private Body body;
	private Foot foot;
	public Head getHead() {
		return head;
	}
	public void setHead(Head head) {
		this.head = head;
	}
	public Body getBody() {
		return body;
	}
	public void setBody(Body body) {
		this.body = body;
	}
	public Foot getFoot() {
		return foot;
	}
	public void setFoot(Foot foot) {
		this.foot = foot;
	}

	
}

Foot抽象类：

public abstract class Foot {

	public abstract void function();
}

Head抽象类：

public abstract class Head {

	public abstract void function();
}

Body抽象类：

public abstract class Body {

	public abstract void function();
}

继承的具体类：这里就不写，随便重写一下父类function()方法，输出不同的颜色值就可以了。

接着，我们改用抽象工厂模式来生成人体部件。为什么要用抽象工厂而不是普通工厂？我们都知道，抽象工厂模式相对于工厂模式多了一个叫做产品族的东西，在这里，人头，人躯，人脚都是产品，而它们的组合就叫是产品族了。如下就是抽象工厂的uml图。

1.FactoryProducer:  用于创建并获得工厂，也就是工厂的工厂。

public class FactoryProducer {

	public AbstractHumanComponentFactory getFactory(String type) {
		if ("head".equals(type)) {
			return new HeadFactory();
		}
		if ("body".equals(type)) {
			return new BodyFactory();
		}
		if ("foot".equals(type)) {
			return new FootFactory();
		}
		return null;
	}
}

2.AbstractHumanComponentFactory： 作为生产人体部件的抽象工厂，其子类是用于创建某一具体身体部件的工厂。

public abstract class AbstractHumanComponentFactory {

	abstract public Head getHead(String type);
	abstract public Body getBody(String type);
	abstract public Foot getFoot(String type);
}

3.具体的人体部件工厂类,以生产人头的工厂

HeadFactory为例：

public class HeadFactory extends AbstractHumanComponentFactory {

	@Override
	public Head getHead(String type) {
		// TODO Auto-generated method stub
		if ("black".equals(type)) {
			return new BlackmanHead();
		}
		if ("white".equals(type)) {
			return new WhitemanHead();
		}

		if(...){

			....//生产其他颜色的人头。

		}
		return null;
	}

	@Override
	public Body getBody(String type) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Foot getFoot(String type) {
		// TODO Auto-generated method stub
		return null;
	}

}


二、人体部件的工厂已经可以正常生产了，接下去要考虑人体的组装了。在这里创建者模式就能很好得发挥它的用场了，以下是菜鸟教程中对于该模式的介绍：

介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

乍一看，云里雾里，似懂非懂，但是有一句深入人心，那就是“将变与不变分离开”。在“造人计划”中，人体结构始终都是不变的，一个人体结构始终由一个头，一个躯体，一双脚组成。但是变化的部分就是头，躯体，脚的差异性，正是这些差异构成了不同的人。这里已经我们把不变的部分给提取出来了，也就是上面的Human类。变化的部分也给提取出来了，它们是身体组件类的各个子类。但是我们如何把变化的部分与不变的部分衔接起来，组成我们想要的人，这里我们就需要构建者模式中另外两个角色来参与了——Builder和Director。Builder负责提供组装部件和返回成品的方法，但它自身不负责组装的执行，组装的执行交给Director来做。

Builder:

public abstract class HumanBuilder {

	public abstract void buildHead();
	public abstract void buildBody();
	public abstract void buildFoot();
	public abstract Human getHuman();
}

ConcreteBuilder:

      
      

public class WhitemanBuilder extends HumanBuilder{

	private Human whiteman = new Human();
	private FactoryProducer factoryProducer = new FactoryProducer();
	
	@Override
	public void buildHead() {
		// TODO Auto-generated method stub
		//这里通过上面实行的抽象工厂来获得部件
		AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");
		whiteman.setHead(headFactory.getHead("white"));
	}

	@Override
	public void buildBody() {
		// TODO Auto-generated method stub
		//这里通过上面实现的抽象工厂来获得部件
		AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");
		whiteman.setBody(bodyFactory.getBody("white"));
	}

	@Override
	public void buildFoot() {
		// TODO Auto-generated method stub
		//这里通过上面实现的抽象工厂方法来获得部件
		AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");
		whiteman.setFoot(footFactory.getFoot("white"));
	}

	@Override
	public Human getHuman() {
		// TODO Auto-generated method stub
		return this.whiteman;
	}

}
public class BlackmanBuilder extends HumanBuilder {

	private Human blackman = new Human();
	private FactoryProducer factoryProducer = new FactoryProducer();

	public void buildHead() {
		// TODO Auto-generated method stub
		AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");
		blackman.setHead(headFactory.getHead("black"));
	}

	public void buildBody() {
		// TODO Auto-generated method stub
		AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");
		blackman.setBody(bodyFactory.getBody("black"));
	}

	public void buildFoot() {
		// TODO Auto-generated method stub
		AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");
		blackman.setFoot(footFactory.getFoot("black"));
	}

	public Human getHuman() {
		// TODO Auto-generated method stub
		return this.blackman;
	}

}

Director:

public class HumanDirector {

	private HumanBuilder humanBuilder;

	public void setHumanBuilder(HumanBuilder humanBuilder) {
		this.humanBuilder = humanBuilder;
	}

	public HumanDirector() {
		super();
	}

	public HumanDirector(HumanBuilder humanBuilder) {
		super();
		this.humanBuilder = humanBuilder;
	}

	// 只负责构建不负责返回
	public void construct() {
		humanBuilder.buildHead();
		humanBuilder.buildBody();
		humanBuilder.buildFoot();
	}

}

客户端调用：

	public static void main(String[] args) {
		BlackmanBuilder blackmanBuilder = new BlackmanBuilder();
		HumanDirector blackmanDirector = new HumanDirector(blackmanBuilder);
		blackmanDirector.construct();
		Human blackman = blackmanBuilder.getHuman();
		System.out.println("black man performs------------");
		blackman.getHead().function();
		blackman.getBody().function();
		blackman.getFoot().function();
		WhitemanBuilder whitemanBuilder = new WhitemanBuilder();
		HumanDirector whitemanDirector = new HumanDirector(whitemanBuilder);
		whitemanDirector.construct();
		Human whiteman = whitemanBuilder.getHuman();
		System.out.println("white man performs------------");
		whiteman.getHead().function();
		whiteman.getBody().function();
		whiteman.getFoot().function();
	}

构建者模式的uml图：

构建者模式和抽象工厂模式整合后的uml图（画得有点乱）：

总结：

傻傻地加一条工厂方法模式和构建者模式之间的差别吧：

    我门可以观察到，工厂模式返回的多个对象中，对象与对象之间存在着类的差异，通常不同的对象都是不同子类的实例化。而构建者模式返回的多个对象，这些对象通常都是同一个类的实例化，只是这些对象内部的组合存在着差异。