java学习笔记-设计模式之建造者模式

前情回顾

在前几天学习了单例模式、简单工厂模式、工厂方法模式和抽象工厂模式之后，今天主要学习的是建造者模式。

首先回顾一下工厂模式

• 简单工厂模式：

主要将实例的创建集中在一个工厂中。调用者只需要传入相应参数，即可创建出对应实例。对于普通开发者来说，简单工厂模式使用较多

优点：工厂中处理了复杂的实例创建逻辑，调用者只需要传入参数即可。造福于调用者

缺点：需要对实例创建进行扩展时需要修改工厂代码，不符合面向对象开闭原则。

• 工厂方法模式：

简单工厂模式的升级，将创建实例方法封装到接口中。创建实例的实现放到具体的实现类中。

优点：扩展容易，只需要新增一个工厂接口的实现类，符合面向对象开闭原则。

缺点：扩展越多，实现类就越多，导致文件较多，提高了复杂度。

• 抽象工厂模式

抽象工厂模式与简单工厂模式及工厂方法面对的角度是不一样的。对于工厂方法与简单工厂模式，主要面向的是实例的创建（产品的创建），而抽象工厂模式面对的是产品族的整合创建。在工厂方法的基础上增加了一个超级工厂，用于整合不同情况下的产品组合。

回顾完工厂模式，看看今天的建造者模式。

一、简介

建造者模式，使用多个简单的对象一步步构建成复杂对象。我将它理解为：将简单对象的构件与最终组装进行分离。因此就可以使用相同的组装方法，构建出不同的复杂对象。接下来一步步解释建造者模式的简单实现过程和原理。

二、简单实现

在本节中，我以电脑的组装为例，来简单描述建造者模式。

原理：电脑主板、CPU、内存、硬盘、电源、散热器等组件构成。对于用户来说，我只关注最终得到一台电脑，而不关注厂商如何生产它。如何用建造者模式来实现呢？我将电脑配件的构件，放到Builder中。将配件组装为电脑放到Director中。组装时去依赖配件的构件。比如说，我要一台联想的电脑，那么我就去调用电脑组装的方法，告诉组装的人，我需要构件的电脑是联想的。

实现过程如下：

第一步：首先定义Computer类，这是最终要建造的产品

package com.zwh.gof23.builder02;
/**
 * 电脑产品类
 * @author zwh
 *
 */
public class Computer {

	private MainBoard mainBoard;
	private CPU cpu;
	private Memory memory;
	private Disk disk;
	private Power power;
	private Radiator radiator;
	
	
	public Computer(MainBoard mainBoard, CPU cpu, Memory memory, Disk disk,
			Power power, Radiator radiator) {
		super();
		this.mainBoard = mainBoard;
		this.cpu = cpu;
		this.memory = memory;
		this.disk = disk;
		this.power = power;
		this.radiator = radiator;
	}
	public MainBoard getMainBoard() {
		return mainBoard;
	}
	public void setMainBoard(MainBoard mainBoard) {
		this.mainBoard = mainBoard;
	}
	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 Disk getDisk() {
		return disk;
	}
	public void setDisk(Disk disk) {
		this.disk = disk;
	}
	public Power getPower() {
		return power;
	}
	public void setPower(Power power) {
		this.power = power;
	}
	public Radiator getRadiator() {
		return radiator;
	}
	public void setRadiator(Radiator radiator) {
		this.radiator = radiator;
	}
	
}
/**
 * 主板类
 * @author zwh
 *
 */
class MainBoard{
	private String name;

	public String getName() {
		return name;
	}

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

	public MainBoard(String name) {
		super();
		this.name = name;
	}
	
}

/**
 * CPU类
 * @author zwh
 *
 */
class CPU{
	private String name;

	public CPU(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}

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

/**
 * 内存类
 */
class Memory{
	private String name;

	public Memory(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}

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

/**
 * 硬盘类
 */
class Disk{
	private String name;

	public Disk(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}

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

/**
 * 电源类
 */
class Power{
	private String name;

	public Power(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}

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

/**
 * 散热器类
 * @author zwh
 *
 */
class Radiator{
	private String name;

	public Radiator(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}

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

在Computer类中，为了表达更加形象，在这个文件中创建了CPU、内存等组件的类。Computer由这些组件构成。

第二步：创建电脑配件的构建接口

package com.zwh.gof23.builder02;
/**
 * 电脑构建接口
 * @author zwh
 *
 */
public interface IComputerBuilder {
	/**
	 * 构建主板
	 * @return
	 */
	MainBoard buildMainBoard();
	
	/**
	 * 构建CPU
	 * @return
	 */
	CPU buildCPU();
	
	/**
	 * 构建内存
	 * @return
	 */
	Memory buildMemory();
	
	/**
	 * 构建硬盘
	 * @return
	 */
	Disk buildDisk();
	
	/**
	 * 构建电源
	 * @return
	 */
	Power buildPower();
	
	/**
	 * 构建散热器
	 * @return
	 */
	Radiator buildRadiator();
}

这个接口定义了电脑包含的这些配件的构建方法。

第三步：定义联想电脑的配件构建实现类

package com.zwh.gof23.builder02;

/**
 * 联想电脑组装
 * @author zwh
 *
 */
public class LenovoComputerBuilder implements IComputerBuilder {

	@Override
	public MainBoard buildMainBoard() {
		return new MainBoard("华硕主板");
	}

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

	@Override
	public Memory buildMemory() {
		return new Memory("金士顿内存条");
	}

	@Override
	public Disk buildDisk() {
		return new Disk("Lenovo硬盘");
	}

	@Override
	public Power buildPower() {
		return new Power("长城电源");
	}

	@Override
	public Radiator buildRadiator() {
		return new Radiator("酷冷至尊散热器");
	}

}

通过这个实现类中的方法，就可以构建出联想电脑所需的全部配件。

第四步：创建组装电脑的类

package com.zwh.gof23.builder02;

/**
 * 联想电脑组装实现类，根据传入的builder参数来决定构建什么型号的电脑。
 * @author zwh
 *
 */
public class ComputerDirector{

	private IComputerBuilder builder;
	
	public ComputerDirector(IComputerBuilder builder) {
		super();
		this.builder = builder;
	}
	
	
	public Computer directorComputer() {
		CPU cpu=builder.buildCPU();
		MainBoard mainBoard=builder.buildMainBoard();
		Memory memory=builder.buildMemory();
		Disk disk=builder.buildDisk();
		Power power=builder.buildPower();
		Radiator radiator=builder.buildRadiator();
		
		/*使用构造器来讲组件组装成电脑 */
		Computer computer=new Computer(mainBoard, cpu, memory, disk, power, radiator);
		return computer;
	}

}

在本类中，通过构造器，在初始化时传入ComputerBuilder对象，告诉Director要组装什么电脑。然后在组装电脑的方法（directorComputer）中调用对应的配件构建方法创建配件实例。最终通过构造器将构建好的配件组装为电脑。

三、测试

package com.zwh.gof23.builder02;

public class TestClient {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		IComputerBuilder builder=new LenovoComputerBuilder();
		ComputerDirector director=new ComputerDirector(builder);
		//得到组装的电脑
		Computer computer=director.directorComputer();
		
		System.out.println("==============组装好的电脑配件信息==============");
		System.out.println("主板："+computer.getMainBoard().getName());
		System.out.println("CPU："+computer.getCpu().getName());
		System.out.println("内存："+computer.getMemory().getName());
		System.out.println("硬盘："+computer.getDisk().getName());
		System.out.println("电源："+computer.getPower().getName());
		System.out.println("散热器："+computer.getRadiator().getName());
		
		
	}

}

大致运行过程：先创建builder的实例，将builder实例对象作为参数传给director，由director去指挥builder构建相应配件，并最终组装为电脑。

运行结果：

==============组装好的电脑配件信息==============
主板：华硕主板
CPU：Intel CPU
内存：金士顿内存条
硬盘：Lenovo硬盘
电源：长城电源
散热器：酷冷至尊散热器

四、总结

建造者模式主要意图是将一个复杂的构建与其表示相分离，根据Builder对象的不同，使得同样的构建过程可以创建不同的表示。适合于在产品基本组成没有大改变的时候使用。

优点：容易扩展、符合面向对象开闭原则

缺点：要建造的产品必须有共同点，不同之处由范围限制。如果产品类型多，则会产生许多建造类。