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

目标实现：

要求通过构建者模式和抽象工厂模式实现“造人计划”，方便起见，我们根据颜色将人种分类——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 {@Overridepublic Head getHead(String type) {// TODO Auto-generated method stubif ("black".equals(type)) {return new BlackmanHead();}if ("white".equals(type)) {return new WhitemanHead();}

if(...){

....//生产其他颜色的人头。
}
return null;}@Overridepublic Body getBody(String type) {// TODO Auto-generated method stubreturn null;}@Overridepublic Foot getFoot(String type) {// TODO Auto-generated method stubreturn 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();@Overridepublic void buildHead() {// TODO Auto-generated method stub
//这里通过上面实行的抽象工厂来获得部件AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");whiteman.setHead(headFactory.getHead("white"));}@Overridepublic void buildBody() {// TODO Auto-generated method stub
//这里通过上面实现的抽象工厂来获得部件AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");whiteman.setBody(bodyFactory.getBody("white"));}@Overridepublic void buildFoot() {// TODO Auto-generated method stub
//这里通过上面实现的抽象工厂方法来获得部件AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");whiteman.setFoot(footFactory.getFoot("white"));}@Overridepublic Human getHuman() {// TODO Auto-generated method stubreturn this.whiteman;}}
public class BlackmanBuilder extends HumanBuilder {private Human blackman = new Human();private FactoryProducer factoryProducer = new FactoryProducer();public void buildHead() {// TODO Auto-generated method stubAbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");blackman.setHead(headFactory.getHead("black"));}public void buildBody() {// TODO Auto-generated method stubAbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");blackman.setBody(bodyFactory.getBody("black"));}public void buildFoot() {// TODO Auto-generated method stubAbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");blackman.setFoot(footFactory.getFoot("black"));}public Human getHuman() {// TODO Auto-generated method stubreturn 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图（画得有点乱）：

总结：

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

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