设计模式之建造者模式

建造者模式（Builder Pattern）是一种对象创建型设计模式，它旨在找到一种灵活构建复杂对象的方式。
一、概述

在建造者模式中，一个复杂对象的表示与它的构造过程分离，使得同样的构建过程可以创建差别的表示。建造者模式通常包含以下几个角色：
1、产品（Product）角色

它是被构建的复杂对象，包含多个构成部件的类（如汽车的轮胎、发动机等）。
2、抽象建造者（Builder）角色

定义一个接口，用于规范产品对象的各个构成部门的建造。一般而言，这个接口中定义了产品的创建方法和返回方法。
3、具体建造者（ConcreteBuilder）角色

实现Builder接口，完成复杂产品的具体创建。在构建过程完成后，提供产品的实例。
4、指挥者（Director）角色

负责安排复杂对象的建造序次，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造和装配方法，完成复杂对象的创建。客户端一般只必要与指挥者举行交互，以建造出复杂的产品对象。
二、建造者模式的长处

1、封装性好：

使用建造者模式可以使客户端不必知道产品内部构成的细节。
2、扩展性好：

建造者模式易于扩展，增加新的具体建造者无须修改原有类库的代码，易于遵守开闭原则。
3、便于控制细节：

如果产品类非常复杂，大概产品类中的调用顺序差别会产生差别的作用，那么使用建造者模式就非常合适，因为具体的建造者类可以对这些细节举行很好的封装。
三、建造者模式的缺点

1、产生多余的Builder对象：

由于建造者模式中的具体建造者通常是独立的，因此其创建的过程中不可避免会产生一些只包含临时数据的对象，如果建造者模式使用不当，会造成资源的浪费。
2、设计难度增加：

建造者模式的参加会使系统中类的个数增加，在一定水平上增加了系统的理解与设计难度。
四、Java代码示例

以下是一个使用建造者模式构建汽车的示例。在这个例子中，我们有一个Car类作为产品，一个CarBuilder接口作为抽象建造者，几个具体的CarBuilder实现类（如SedanBuilder、SUVBuilder等），以及一个CarDirector类作为指挥者。
1. 定义产品类（Car）

1. public class Car {  
2.     private String engine;  
3.     private String body;  
4.     private String wheels;  
5.   
6.     // 省略构造方法  
7.   
8.     // Getter 和 Setter  
9.     public String getEngine() {  
10.         return engine;  
11.     }  
12.   
13.     public void setEngine(String engine) {  
14.         this.engine = engine;  
15.     }  
16.   
17.     public String getBody() {  
18.         return body;  
19.     }  
20.   
21.     public void setBody(String body) {  
22.         this.body = body;  
23.     }  
24.   
25.     public String getWheels() {  
26.         return wheels;  
27.     }  
28.   
29.     public void setWheels(String wheels) {  
30.         this.wheels = wheels;  
31.     }  
32.   
33.     // 显示汽车信息  
34.     public void display() {  
35.         System.out.println("Engine: " + engine);  
36.         System.out.println("Body: " + body);  
37.         System.out.println("Wheels: " + wheels);  
38.     }  
39. }

复制代码

2. 定义抽象建造者（CarBuilder）

1. public interface CarBuilder {  
2.     void buildEngine();  
3.     void buildBody();  
4.     void buildWheels();  
5.   
6.     // 返回最终构建的汽车产品  
7.     Car getCar();  
8. }

复制代码

3. 定义具体建造者（SedanBuilder 和 SUVBuilder）

1. public class SedanBuilder implements CarBuilder {  
2.     private Car car = new Car();  
3.   
4.     @Override  
5.     public void buildEngine() {  
6.         car.setEngine("V6 Engine");  
7.     }  
8.   
9.     @Override  
10.     public void buildBody() {  
11.         car.setBody("Sedan Body");  
12.     }  
13.   
14.     @Override  
15.     public void buildWheels() {  
16.         car.setWheels("4 Wheels");  
17.     }  
18.   
19.     @Override  
20.     public Car getCar() {  
21.         return car;  
22.     }  
23. }  
24.   
25. public class SUVBuilder implements CarBuilder {  
26.     private Car car = new Car();  
27.   
28.     @Override  
29.     public void buildEngine() {  
30.         car.setEngine("V8 Engine");  
31.     }  
32.   
33.     @Override  
34.     public void buildBody() {  
35.         car.setBody("SUV Body");  
36.     }  
37.   
38.     @Override  
39.     public void buildWheels() {  
40.         car.setWheels("4 Wheels with All-Wheel Drive");  
41.     }  
42.   
43.     @Override  
44.     public Car getCar() {  
45.         return car;  
46.     }  
47. }

复制代码

4. 定义指挥者（CarDirector）

1. public class CarDirector {  
2.     private CarBuilder builder;  
3.   
4.     public CarDirector(CarBuilder builder) {  
5.         this.builder = builder;  
6.     }  
7.   
8.     // 构造顺序  
9.     public Car constructCar() {  
10.         builder.buildEngine();  
11.         builder.buildBody();  
12.         builder.buildWheels();  
13.         return builder.getCar();  
14.     }  
15. }

复制代码

5. 客户端代码

1. public class Client {  
2.     public static void main(String[] args) {  
3.         // 使用 SedanBuilder  
4.         CarBuilder sedanBuilder = new SedanBuilder();  
5.         CarDirector director = new CarDirector(sedanBuilder);  
6.         Car sedan = director.constructCar();  
7.         sedan.display();  
8.   
9.         // 使用 SUVBuilder  
10.         CarBuilder suvBuilder = new SUVBuilder();  
11.         director = new CarDirector(suvBuilder);  
12.         Car suv = director.constructCar();  
13.         suv.display();  
14.     }  
15. }

复制代码

6、深入解析

在上面的例子中，Car类是一个复杂的产品，包含发动机、车身和轮子等部门。CarBuilder接口定义了如何构建这些部门，而SedanBuilder和SUVBuilder是具体的建造者，分别实现了差别的构建逻辑。CarDirector类则负责按照特定的顺序调用建造者的方法，以构建出完整的汽车对象。
客户端代码通过创建差别的建造者实例，并将其传递给指挥者，来构建差别范例的汽车。这种方式使得客户端与产品的具体构建过程解耦，客户端只必要知道指挥者和建造者的接口，而不必要知道具体的实现细节。
7、建造者模式的变体

在现实应用中，建造者模式偶尔会有一些变体。例如，有些环境下可能不必要指挥者角色，而是直接在客户端代码中调用建造者的方法来构建产品。此外，还可以将建造者模式与其他设计模式结合使用，如工厂模式、单例模式等，以实现更复杂的系统设计。
五、总结

建造者模式是一种强大的设计模式，它允许我们通过组合差别的组件来构建复杂对象，同时保持构建过程的灵活性和可扩展性。通过定义抽象建造者接口和具体建造者实现类，我们可以将产品的构建过程与产品的表示分离，从而实现更好的封装和复用。此外，建造者模式还提供了很好的扩展性，使得我们可以在不修改原有代码的环境下添加新的具体建造者类来构建新的产品。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。