建造者模式——Builder Pattern

建造者模式的本质：分离了对象子组件的单独构造（由Builder来负责）和装配（由Director负责装配）。从而构造出复杂的对象：这个模式的适用于：某个对象的构建过程复杂的情况下使用。由于实现了构建和装配的解耦。不同的构建器、相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

下面参考一下代码看看建造者模式是如何实现的,以构建一个电脑为例：

1.首先定义电脑的各个组件以及电脑实体

package builder;


/**
 * 电脑类
 * @author acer
 */
public class Computer {

	private CPU cpu;
	private Memory memory;
	private Screen screen;
	
	public CPU getCpu() {
		return cpu;
	}
	public void setCpu(CPU cpu) {
		this.cpu = cpu;
	}
	public Memory getMemory() {
		return memory;
	}
	public void setMemory(Memory memory) {
		this.memory = memory;
	}
	public Screen getScreen() {
		return screen;
	}
	public void setScreen(Screen screen) {
		this.screen = screen;
	}
	
	public void totring() {
		System.out.println("Computer [cpu=" + cpu + ", memory=" + memory + ", screen=" + screen + "]") ;
	}
	
}

package builder;
/**
 * @author acer
 * CPU组件
 */
public class CPU {
    private String name;
    
    public CPU(String name) {
        this.name = name;
        // TODO Auto-generated constructor stub
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package builder;
/**
 * 定义内存组件
 * @author acer
 */
public class Memory {

    private String name;
    
    public Memory(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }     
}

package builder;
/**
 * 定义屏幕组件
 * @author acer
 */
public class Screen {

    private String name;
    
    public Screen(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.定义电脑的组件的建造者接口（builder）和电脑的组装接口（director）

package builder;
/**
 * 电脑组件的建造者
 * @author acer
 */
public interface ComputerBuilder {
	//建造cpu
	CPU buildCPU();
	//建造内存
	Memory buildMemory();
	//建造屏幕
	Screen buildScreen();
}

package builder;
/**
 * 电脑的组装过程
 * @author acer
 */
public interface ComputerDirector {
    /**
     * 组装电脑
     * @return
     */
    Computer createComputer();
}
 

如果我们想要建一个Acer牌的电脑，那么需要一个类来实现ComputerBuilder接口，一个类实现ComputerDirector接口：

package builder;
/**
 * Acer电脑组件的创建
 * @author acer
 */
public class AcerComputerBuilder implements ComputerBuilder{

	@Override
	public CPU buildCPU() {
		return new CPU("Acer cpu");
	}

	@Override
	public Memory buildMemory() {
		return new Memory("Acer memmory");
	}

	@Override
	public Screen buildScreen() {
		return new Screen("acer screen");
	}

}

package builder;
/**
 * acer电脑的组装类
 * @author acer
 *
 */
public class AcerComputerDirector implements ComputerDirector{
    
    //定义电脑的组件的创建者
    private ComputerBuilder builder;
    
    public AcerComputerDirector(ComputerBuilder builder) {
        this.builder = builder;
    }

    @Override
    public Computer createComputer() {
        //创建电脑的组件
        CPU cpu = builder.buildCPU();
        Memory memory = builder.buildMemory();
        Screen screen = builder.buildScreen();
        
        //组装
        Computer com = new Computer();
        com.setCpu(cpu);
        com.setMemory(memory);
        com.setScreen(screen);
        
        return com;
    }

}
 

package builder;

public class Client {
    public static void main(String[] args) {
        
        ComputerDirector director = new AcerComputerDirector(new AcerComputerBuilder());
        Computer c = director.createComputer();
        c.totring();
    }
}

上面这种创建的方式有什么好处呢，如果所有的创建细节都一样，那么这个模式的创建过程是繁琐的。但是如果不同的电脑在具体的创建细节都是不同的，但是整体的流程都是相同的，cpu,内存，屏幕，这些都是必须的，但是型号又不同。组装也是必须的，但是组装的细节又不同。所以使用建造者模式就保证了流程的确定性，而细节可以继续扩展。

想要好好的讲述一下建造者模式的精髓，但是又不够形象，在网上发现有一段解释非常精辟，借用一下

【建造者模式属于创建型模式（先记下）。顾名思义，builder的意思是建造者或者建筑工人。例如：楼房是千差万别的，楼房的外形，层数，内部房间的数量，房间的装饰都不一样。但是对于建造者来说，抽象出来的建筑流程是确定的。因为建筑一座楼房，都可以归纳为几个步骤：1打桩、2建地基、3搭框架、4内部建设。同理，建造者设计模式也是基于这样的概念而生的，这个设计模式用来解决什么样的情况呢：即流程不变，但每个流程实现的具体细节是会变化的。这样的情况，可以考虑使用建造者。就像盖房子，4个流程都必须有，但每个流程各自的实现细节，各个房子各有不同。建造者模式的好处就是保证了流程不会变化，即流程不会增加也不会遗漏，也不会产生流程次序的错误。这是非常重要的，看新闻，一些楼歪歪的事件，很多都是建设楼盘的时候，流程出现了问题导致的。（看来这些人并不知道建造者模式啊）。而建造者模式，保证了流程的确定性，而流程内部的实现细节，是可继承扩展的。从根源上解决了流程不规范的问题。

    福清有一道小吃叫海蛎饼，家家户户都会做，但各家各户做的味道都不同。虽然味道不同，但制作海蛎饼的流程步骤，大致都是一样的。一个成功的海蛎饼，外酥内嫩，滋味丰富。虽然口感各有不同，但只要流程步骤不差，都会做出好吃的海蛎饼。而一些刚嫁人的新媳妇们制作海蛎饼却不如婆婆好，因为新媳妇刚学做，不熟悉流程，难免流程常有疏漏。而如果让婆婆站在媳妇旁把控制作流程，海蛎饼就不会差。所以说，如果流程控制好了，生产出来的海蛎饼就不会差。

    写代码也是如此，如果你遇到一个需要把控流程，但流程中的实现细节各有许多的方式，你可以采用建造者模式。用一个director类把控流程，而用许多不同的builder去建造流程中的细节并产生产品。这样，生产出来的产品是绝对不会出问题的。因为流程把控好了。你可以有多个builder去负责建造生产产品，而让director去把控流程。如果有新的产品，但是流程一致，你可以再扩张出一个builder来。这样，你看，建造者模式是不是很符合OCP原则呢。】

文字来源 【http://blog.csdn.net/hello_haozi/article/details/38819935】