builder（建造者模式）

建造者模式

建造者模式将复杂产品的创建步骤分解在在不同的方法中，使得创建过程更加清晰，从而更精确控制复杂对象的产生过程；通过隔离复杂对象的构建与使用，也就是将产品的创建与产品本身分离开来，使得同样的构建过程可以创建不同的对象；并且每个具体建造者都相互独立，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

UML结构图

• 抽象建造者 Builder：相当于建筑蓝图，声明了创建 Product 对象的各个部件指定的抽象接口。
• 具体建造者ConcreteBuilder：实现Builder抽象接口，构建和装配各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
• 指挥者 Director：构建一个使用 Builder 接口的对象。主要有两个作用，一是隔离用户与对象的生产过程，二是负责控制产品对象的生产过程。
• 产品角色 Product：被构造的复杂对象。ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码测试

	package com.lq.builder;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.builder
	 * @CLASS_NAME: Product
	 * @date 2022/11/13 11:46
	 * @Description:  产品类
	 */
	public class Product {
	    private String name;
	    private String type;
	
	    public void showProduct() {
	        System.out.println("名称：" + name);
	        System.out.println("型号：" + type);
	    }
	
	    public void setName(String name) {
	        this.name = name;
	    }
	
	    public void setType(String type) {
	        this.type = type;
	    }
	}
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

	package com.lq.builder;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.builder
	 * @CLASS_NAME: Builder
	 * @date 2022/11/13 11:46
	 * @Description: 抽象建造者
	 */
	public  abstract class Builder {
	
	    public abstract void setPart(String arg1, String arg2);
	    public abstract Product getProduct();
	
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

	package com.lq.builder;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.builder
	 * @CLASS_NAME: ConcreteBuilder
	 * @date 2022/11/13 11:47
	 * @Description:  建造者
	 */
	public class ConcreteBuilder extends Builder {
	    private Product product = new Product();
	
	    @Override
	    public Product getProduct() {
	        return product;
	    }
	
	    @Override
	    public void setPart(String arg1, String arg2) {
	        product.setName(arg1);
	        product.setType(arg2);
	    }
	
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

	package com.lq.builder;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.builder
	 * @CLASS_NAME: Director
	 * @date 2022/11/13 11:48
	 * @Description:  导演类
	 */
	public class Director {
	    private Builder builder = new ConcreteBuilder();
	
	    public Product getAProduct() {
	        builder.setPart("宝马汽车", "X7");
	        return builder.getProduct();
	    }
	
	    public Product getBProduct() {
	        builder.setPart("奥迪汽车", "Q5");
	        return builder.getProduct();
	    }
	
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

	package com.lq.builder;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.builder
	 * @CLASS_NAME: Client
	 * @date 2022/11/13 11:48
	 * @Description:
	 */
	public class Client {
	    public static void main(String[] args) {
	        Director director = new Director();
	        Product product1 = director.getAProduct();
	        product1.showProduct();
	
	        Product product2 = director.getBProduct();
	        product2.showProduct();
	    }
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

结果

	名称：宝马汽车
	型号：X7
	名称：奥迪汽车
	型号：Q5
1
2
3
4

抽象工厂模式和建造者模式的区别

两者都是创建型模式，并且最终都是得到一个产品，但两者的区别在于：

1. 抽象工厂模式实现对产品族的创建，产品族指的是不同分类维度的产品组合，用抽象工厂模式不需要关心具体构建过程，只关心产品由什么工厂生产即可。而建造者模式则更关心的是对象的构建过程，要求按照指定的蓝图建造产品，主要目的是通过组装零配件而产生一个新产品。
2. 在抽象工厂模式中使用“工厂”来描述构建者，而在建造者模式中使用“车间”来描述构建者。

   （1）抽象工厂模式就好比是一个一个的工厂，宝马车工厂生产宝马SUV和宝马VAN，奔驰车工厂生产奔驰车SUV和奔驰VAN，它是从一个更高
层次去看对象的构建，具体到工厂内部还有很多的车间，如制造引擎的车间、装配引擎的车间等，但这些都是隐藏在工厂内部的细节，对外不公
布。也就是对领导者来说，他只要关心一个工厂到底是生产什么产品的，不用关心具体怎么生产。

   （2）建造者模式就不同了，它是由车间组成，不同的车间完成不同的创建和装配任务，一个完整的汽车生产过程需要引擎制造车间、引擎装
配车间的配合才能完成，它们配合的基础就是设计蓝图，而这个蓝图是掌握在车间主任（Director类）手中，它给建造车间什么蓝图就能生产什
么产品，建造者模式更关心建造过程。虽然从外界看来一个车间还是生产车辆，但是这个车间的转型是非常快的，只要重新设计一个蓝图，即可产
生不同的产品，这有赖于建造者模式的功劳。
1
2
3
4
5
6
7
8

3. 相对来说，抽象工厂模式比建造者模式的粒度要大，它关注产品整体，而建造者模式关注构建过程，所以建造者模式可以很容易地构建出一个崭新的产品，只要指挥类Director 能够提供具体的工艺流程。也正因为如此，两者的应用场景截然不同，如果希望屏蔽对象的创建过程，只提供一个封装良好的对象，则可以选择抽象工厂方法模式。而建造者模式可以用在构件的装配方面，如通过装配不同的组件或者相同组件的不同顺序，可以产生出一个新的对象，它可以产生一个非常灵活的架构，方便地扩展和维护系统。