lusiqi

设计模式-建造者模式，介绍建造者模式，及代码实现。

简介

建造者模式，又叫生成器模式，是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。如果我们用了建造者模式，那么用户就只需指定需要建造的类型就可以得到他们，而具体的细节就不需知道了。

角色

现有需求：需要创建一种产品，这个产品有两个部件A、B。建造者模式完成此需求，参与的角色为：

抽象建造类

抽象建造类Builder是为创建产品Product对象的各个部件指定抽象接口。如果类比工地搬砖的话，Builder则为包工头，实际干活的则为包工头手下的小工。

具体建造者

具体建造者ConcreteBuilder实现Builder接口，构造和装配各个部件，即为具体搬砖的小工。

产品

产品Product即为整个过程中具体建造者操作的具体产品，也即为工地中小工搬的砖。

指挥者

指挥者Director是提出需求指挥构造者们开始工作的角色，也是工地中指挥包工头的幕后老板。

代码实现

产品类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @description 产品类，由多个部件组成
 * @author dxy
 * @date 20200306
 */
public class Product {
    List<String> parts = new ArrayList<String>();

    // 添加产品部件
    public void add(String part) {
        parts.add(part);
    }

    // 列举所有的产品部件
    public void show() {
        System.out.println("---产品 创建---");

        for (String part : parts) {
            System.out.println(part);
        }
    }
}

抽象构造类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * @description 抽象构造类
 * @author dxy
 * @date 20200306
 */
public abstract class Builder {

    /**
     * 构造A部分
     */
    public abstract void buildPartA();

    /**
     * 构造B部分
     */
    public abstract void buildPartB();

    /**
     * 构造整个产品
     * @return
     */
    public abstract Product getBuildResult();
}

具体构造类

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
/**
 * @description 具体建造者类
 * @author dxy
 * @date 20200306
 *
 */
public class ConcreteBuilder1 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
	product.add("部件A");
    }

    @Override
    public void buildPartB() {
	product.add("部件B");
    }

    @Override
    public Product getBuildResult() {
	return product;
    }

}

/**
 * @description 具体建造者类，建造的对象时Product，通过build使Product完善
 * @author dxy
 * @date 20200306
 *
 */
public class ConcreteBuilder2 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
	product.add("部件X");
    }

    @Override
    public void buildPartB() {
	product.add("部件Y");
    }

    @Override
    public Product getBuildResult() {
	return product;
    }

}

指挥者类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * @description 指挥者类，用来指挥建造过程
 * @author dxy
 * @date 20200306
 */
public class Director {

    /**
     * 指挥者指挥构造整个产品
     * @param builder
     */
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

建造客户端类

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
/**
 * @description 建造客户端
 * @author dxy
 * @date 20200306
 */
public class BuilderClient {

    public static void main(String[] args) {

        //指挥者
        Director director = new Director();
        //建造者1
        Builder builder1 = new ConcreteBuilder1();
        //建造者2
        Builder builder2 = new ConcreteBuilder2();

        //指挥建造者1建造产品
        director.construct(builder1);
        //获得建造结果
        Product product1 = builder1.getBuildResult();
        product1.show();

        //指挥建造者2建造产品
        director.construct(builder2);
        //获得建造结果
        Product product2 = builder2.getBuildResult();
        product2.show();

    }

}

建造者模式主要用于创建一些复杂的对象，这些对象内部构建顺序通常稳定，但对象内部的构建通常面临着复杂的变化，建造者模式的好处就是使得建造代码与表示代码分离，由于建造则会隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要在定义一个具体的建造者就可以了。

 上一篇

 评论