建造者模式

本文最后更新于 2025年7月24日 下午

建造者模式 是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

本质上建造者模式是向对象创建过程中加入了软件构建理念

Builder : 抽象层的建造者定义

ConcreteBuilder ： 具体的产品创建过程，对应了软件中的执行过程。

Product ： 具体的产品，对应了软件中的业务描述者

Director ： 指挥建造者去建造目标，对应了软件中的执行器

优点

  1. 客户不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
  2. 每一个具体建造者是独立的，因此可以方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象
  3. 可以更加精细地控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
  4. 增加新的创建则，无需修改原有类库的代码，指挥者类针对建造者类编程，系统扩展方便

缺点

  1. 当建造者过多时，会产生很多类
  2. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，若产品间差异过大，则不适合该模式
  3. 若产品内部变化复杂，可能需要定义很多具体建造者类来实现这种变化

创建建造者模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 定义原型数据类
public class Computer {
		private String cpu ;
		private String memory ;
		private String hardDisk ;
		private String keyboard ;
		private String mouse ;
		private String display ;
	
		public String getCpu(){
			return cpu ;
		}
		public void setCpu(String cpu){
			this.cpu = cpu ;
		}
		public String getMemory(){
			return memory ;
		}
		public void setMemory(String memory){
			this.memory = memory;
		}
		public String getHardDisk(){
			return hardDisk;
		}
		public void setHardDisk(String hardDisk){
			this.hardDisk = hardDisk  ;
		}
		public String getKeyboard(){
			return keyboard ;
		}
		public void setKeyboard(String keyboard){
			this.keyboard = keyboard ;
		}
		public String getMouse(){
			return mouse ;
		}
		public void setMouse(String mouse){
			this.mouse = mouse ;
		}
		public String getDisplay(){
			return display ;
		}
		public void setDisplay(String display){
			this.display = display ;
		}
		@Override 
		public String toString(){
			return "Computer{" +
				"cpu=\\'"+ cpu + "\\',"+
				"memory=\\'" + memory + "\\'," +
				"hardDisk=\\'" + hardDisk + "\\'," +
				"keyboard=\\'" + keyboard + "\\'," +
				"mouse=\\'" + mouse + "\\'," +
				"display=\\'" + display + "\\'," + 
				'}';
			
		}

}
1
2
3
4
5
6
7
8
9
10
11
12
//定义建造者接口，规定所需要执行的方法
public interface ComputerConfigBuilder {
		void buildCpu();
		void buildMemory();
		void buildHardDisk();
		void buildKeyboard();
		void buildMouse();
		void buildDisplay();
	
		Computer build();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 定义ConcreteBuilder 即Builderd的实现类
public class LowComputerConfigBuilder implements ComputerConfigBuilder{
	private Computer computer = null;
	public LowComputerConfigBuilder(){
		this.computer = new Computer();
	}

	@Override
	public void buildCpu(){
		computer.setCpu("2核");
	}
	@Override
	public void buildMemory(){
		computer.setMemory("4GB");
	}
	@Override
	public void buildHardDisk(){
		computer.setHardDisk("20GB");
	}
	@Override
	public void buildKeyboard(){
		computer.setKeyboard("普通键盘");
	}
	@Override
	public void buildMouse(){
		computer.setMouse("普通鼠标");
	}
	@Override
	public void buildDisplay(){
		computer.setDisplay("普通显示器");
	}

	@Override
	public Computer build(){
		return computer ;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 定义ConcreteBuilder 即Builderd的实现类
public class HighComputerConfigBuilder implements ComputerConfigBuilder{
	private Computer computer = null;
	public HighComputerConfigBuilder(){
		this.computer = new Computer();
	}

	@Override
	public void buildCpu(){
		computer.setCpu("8核");
	}
	@Override
	public void buildMemory(){
		computer.setMemory("16GB");
	}
	@Override
	public void buildHardDisk(){
		computer.setHardDisk("500GB");
	}
	@Override
	public void buildKeyboard(){
		computer.setKeyboard("高端键盘");
	}
	@Override
	public void buildMouse(){
		computer.setMouse("高端鼠标");
	}
	@Override
	public void buildDisplay(){
		computer.setDisplay("高端显示器");
	}

	@Override
	public Computer build(){
		return computer ;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//定义指挥者，定义配置逻辑
public class Director{
	private ComputerConfigBuilder builder ;

	public  void setBuilder(ComputerConfigBuilder builder){
		this.builder = builder ;
	}

	public void createComputer(){
		builder.buildCpu();
		builder.buildDisplay();
		builder.buildHardDisk();
		builder.buildKeyboard();
		builder.buildMemory();
		builder.buildMouse();
	}

	public Computer getComputer(){
		return builder.build();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// 调用
public class Customer{
	public static void main(String[] args){
		//创建装机人员
		Director director = new Director();
	
		//
		director.setBuilder(new LowComputerConfigBuilder());
		director.createComputer();
		Computer computer = director.getComputer();
		System.out.println("计算机配置:" + computer.toString());	
	}
}

建造者模式通过将 对象定义，对象调用和对象的生命周期 托管给不同的类进行管理。这样可以灵活自由的对对象进行预配置，自定义配置和对象创建。

Java中的建造者模式

在java中一般通过私有类定义+暴露get/set方法来完成对配置类的预定义和自定义类配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class NutritionFacts {
	private final int servingSize ;
	private final int servings ;
	private final int calories ;
	private final int fat ;
	private final int sodium ;
	private final int carbohydrate ;

	public static class Builder {
		private final int servingSize ;
		private final int servings ;
		private int calories = 0 ;
		private int fat = 0 ;
		private int sodium = 0 ;
		private int carbohydrate = 0 ;
	
		public Builder( int servingSize , int servings ){
			this.servingSize = servingSize ;
			this.servings = servings ;
		}
		public Builder calories(int val){
			calories = val ;
			return this ;
		}
		public Builder fat(int val){
			fat = val ;
			return this ;
		}
		public Builder sodium(int val){
			sodium = val ;
			return this ;
		}
		public Builder carbohydrate(int val){
			carbohydrate = val ;
			return this ;
		}
		public NutritionFacts build(){
			return new NutritionFacts(this);
		}
	}
	private NutritionFacts(Builder builder){
		servingSize = builder.servingSize ;
		servings = builder.servings ;
		calories = builder.calories ;
		fat = builder.fat ;
		sodium = builder.sodium ;
		carbohydrate = builder.carbohydrate ;
	}
}

Spring中的建造者模式应用

BeanDefinitionBuilder是用于构建Bean定义的构造器

1
2
3
4
5
public final class BeanDefinitionBuilder{
	public static BeanDefinitionBuilder genericBeanDefinition(){
		return new BeanDefinitionBuilder(new GenericBeanDefinition());
	}
}

BeanDefinitionBuilder 提供了构建BeanDefinition对象的一系列方法，代码如下所示

1
2
3
4
5
6
7
8
9
public BeanDefinitionBuilder setParentName(String parentName){
	this.beanDefinition.setParentName(parentName);
	return this ;
}

public BeanDefinitionBuilder setFactoryMethod(String factoryMethod){
	this.beanDefinition.setFactoryMethodName(factoryMethod);
	return this ;
}

总结

建造者模式不仅是经典的设计模式之一，更是现代软件系统中构建复杂对象的一种 工程化解耦思想 。通过抽象构建步骤、分离产品结构与构建过程，建造者模式可以大幅提升代码的清晰度、可维护性和扩展性。

在 Java 和 Spring 生态中，从 NutritionFacts 的静态 Builder 到 BeanDefinitionBuilder 的 API 构造方式，我们可以看到建造者模式已经深入各类框架与工具的底层设计，是真正值得掌握和理解的核心模式之一。

设计模式
#设计模式
建造者模式
http://gadoid.io/2025/07/24/建造者模式/
作者
Codfish
发布于
2025年7月24日
许可协议