了解设计模式 之 创建模式(二) -- 建造者模式

 

下面来看看第二个创建模式，建造者模式。

2. 建造者模式(Builder Pattern)

建造者模式是为了把创建复杂对象的过程与构建它的各个部件的过程解耦和而产生的。单说这个感觉很抽象，还是用例子来说明吧。

还是举上边的那个方便面厂的例子吧。这里主要不是讲怎么创建不懂地域口味的方便面了，主要描述制作方便面的过程。

首先，应用建造者模式需要三个基本元素，Builder、Director和Product。客户端是通过Builder来获取Product的，而Director来控制Builder创建的各个部件的组装。实现了不同的部件创建和对象创建的分离。不过这么说还是很抽象，下面来具体看看。

首先，定义一个Builder接口，它负责生产方便面。

Java代码  

1. public Interface Builder{   
2.     public void buildInstantNoodle();// 制造面饼部件   
3.   
4.     public void buildCondiment();// 制造调味品部件   
5.   
6.     public BaggedInstantNoodle getProduct();// 得到袋装方便面   
7. }  

public Interface Builder{
	public void buildInstantNoodle();// 制造面饼部件

	public void buildCondiment();// 制造调味品部件

	public BaggedInstantNoodle getProduct();// 得到袋装方便面
}

然后来定义一个Director。

Java代码  

1. public class Director{   
2.     Builder builder = null;   
3.     public Director(Builder builder){   
4.         this.builder = builder;   
5.     }   
6.   
7.     public assemble(){// 组装部件   
8.         builder.buildInstantNoodle();   
9.         builder.buildCondiment();   
10.     }   
11. }  

public class Director{
	Builder builder = null;
	public Director(Builder builder){
		this.builder = builder;
	}

	public assemble(){// 组装部件
		builder.buildInstantNoodle();
		builder.buildCondiment();
	}
}

接下来是一个Builder的实现类，一个北京口味方便面的Builder

Java代码  

1. public class BeijingBaggedInstantNoodleBuilder implements Builder{   
2.     InstantNoodle noodle;   
3.     Condiment condiment;   
4.     public void buildInstantNoodle(){// 制造面饼部件   
5.         noodle = new BeijingInstantNoodle();   
6.     }   
7.   
8.     public void buildCondiment(){// 制造调味品部件   
9.         condiment =  new BeijingCondiment();   
10.     }   
11.   
12.     public BaggedInstantNoodle getProduct(){// 得到袋装方便面   
13.         return new BaggedInstantNoodle(noodle, condiment);   
14.     }   
15. }  

public class BeijingBaggedInstantNoodleBuilder implements Builder{
	InstantNoodle noodle;
	Condiment condiment;
	public void buildInstantNoodle(){// 制造面饼部件
		noodle = new BeijingInstantNoodle();
	}

	public void buildCondiment(){// 制造调味品部件
		condiment =  new BeijingCondiment();
	}

	public BaggedInstantNoodle getProduct(){// 得到袋装方便面
		return new BaggedInstantNoodle(noodle, condiment);
	}
}

最后是客户端的程序了：

Java代码  

1. public class Client{   
2.     public static void main(String[] args){   
3.         test();   
4.     }   
5.     public static void test() {   
6.         // 制作北京口味的方便面   
7.         Builder builder = new BeijingBaggedInstantNoodleBuilder();// 实例化Builder   
8.         Director director = new Director(builder);//实例化Director   
9.         director.assemble();//组装部件   
10.         BaggedInstantNoodle = builder.getProduct();//得到产品   
11.     }   
12. }  

public class Client{
	public static void main(String[] args){
		test();
	}
	public static void test() {
		// 制作北京口味的方便面
		Builder builder = new BeijingBaggedInstantNoodleBuilder();// 实例化Builder
		Director director = new Director(builder);//实例化Director
		director.assemble();//组装部件
		BaggedInstantNoodle = builder.getProduct();//得到产品
	}
}

通过上边的代码可以看出，Builder其实就是工人，他具备一切生产产品部件的能力。但是他不会将生产的部件进行组装，这个时候就需要一个Director出现了，他控制了Builder的部件的组装过程。所以应用了这个模式之后，Builder只管专心的负责他的部件生产(例如buildInstantNoodle()和buildCondiment()方法)，至于怎么将部件组装起来自然会有Director来指导(例如assemble()方法)。最后，客户端会向Builder来索要产品(Product，上例中是BaggedInstantNoodle)而不是Director，因为Director只负责过程的组装，他并没有最终产品。

这样，通过Builder模式，就实现了部件的生产(Builder的各个build方法)和部件的构建过程的解耦和，它可以使用在创建复杂对象的算法应该独立于该对象的组成部分和装配方式，还有构造过程要求被构造的对象可变的场合。比如构建一个“汽车”这种对象，组成汽车的各个部分就是可变的，而装配汽车的方法与汽车部件也是确实相对独立的。

当然，在Builder中直接使用一个assemble()方法也可以实现这个过程，但是，Builder的职责就不再单一了(不再是单一的部件生产者)，加入Director可以实现类的单一职责。还有最主要的因素还是实现部件生产和构建的解耦和，这两个过程可以独立的变化而不会影响其他的部分。举个例子，

比如一个装配汽车的程序，同一个系列的汽车可能组装过程相同，但是部件可能会有所不同，这样，他们就可以重用的Director，而使用不同的Builder了。同样也存在重用Builder而更换Director的情况，这个就要具体情况具体分析了。

它的类图如下所示：

• 
• 大小: 13.2 KB

• 查看图片附件