图说设计模式笔记#3

建造者模式

模式定义

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

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要指定内部的具体构建细节。建造者模式又可以被称为生成器模式。

模式结构

  • Builder：抽象建造者
  • ConcreteBuilder：具体建造者
  • Director：指挥者
  • Product：产品角色

在线编辑

代码实现

抽象建造者

1
2
3
4
5
6
7
public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getResult();
}

具体建造者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ConcreteBuilder extends Builder {

    private Product product = new ProductB();

    @Override
    public void buildPartA() {
        product.setParts((product.getParts() == null ? "" : product.getParts()) + "A");
    }

    @Override
    public void buildPartB() {
        product.setParts((product.getParts() == null ? "" : product.getParts()) + "B");
    }

    @Override
    public void buildPartC() {
        product.setParts((product.getParts() == null ? "" : product.getParts()) + "C");
    }

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

指挥者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Director {

    private Builder builder;

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

    public Product constuct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

测试

1
2
3
4
5
6
@Test
public void testBuilder() {
    Director director = new Director();
    director.setBuilder(new ConcreteBuilder());
    Assert.assertEquals(director.constuct().getParts(), "ABC");
}

模式分析

  • 抽象建造者类中定义产品的创建方法和返回方法
  • 建造者模式中引入了一个指挥者类，该类的作用主要有：隔离客户与生产过程；它负责控制产品的生产过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象

实例

KFC套餐：套餐是一个复杂对象，服务员更具顾客要求，一步一步装配套餐组成需要的食品，构造完一份完整的套餐，饭后返回个客户。

优缺点

  • 优点
    • 客户端不需要知道产品内部组成细节，将产品本身与产品构建过程解耦，使得相同的创建过程可以创建不同的产品对象
    • 每一个具体建造者都相对独立，可以很方便地替换或增加具体创建者，用户使用不同的具体建造者即可得到不同的产品对象
    • 可以更加精细化地控制产品的创建过程
    • 增加新的具体建造者无需修改原有类库的代码，指挥者针对抽象建造者类编程，系统扩展方便，符合开闭原则
  • 缺点
    • 建造者模式所创建的产品一般要具有较多的共同点，其组成部分相似，若产品差异性很大，则不适合使用建造者模式
    • 若产品内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

适用环境

  • 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性
  • 需要生成的产品对象的属性相互依赖，需要指定其生成顺序
  • 对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中
  • 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品

模式应用

一般游戏中的场景、任务角色等可以使用建造者模式对齐进行设计

模式拓展

  • 省略抽象建造者角色：当系统中只需要一个具体建造者时
  • 省略指挥者角色：当只有一个具体建造者，且抽象建造者已被省略时，可以省略指挥者角色，让建造者扮演指挥者和建造者双重角色

原型模式

又可以称为克隆模式

模式动机

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

模式定义

实现了一个原型接口，该接口用于创建当前对象的克隆

模式结构

在线编辑

代码实现

Shape

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
public abstract class Shape implements Cloneable {

    private String id;
    protected String type;

    abstract void draw();

    public String getId() {
        return id;
    }

    public String getType(){
        return type;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }

}

Rectangle

1
2
3
4
5
6
7
8
9
10
11
public class Rectangle extends Shape {

    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    void draw() {
        System.out.println("Rectangle::draw()");
    }
}

Circle

1
2
3
4
5
6
7
8
9
10
11
public class Circle extends Shape {

    public Circle() {
        type = "Circle";
    }

    @Override
    void draw() {
        System.out.println("Circle::draw()");
    }
}

ShapeCache

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ShapeCache {

    private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    public static void putShape(Shape shape) {
        shapeMap.put(shape.getId(), shape);
    }

}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void testPrototype() {
    Shape shape1 = new Rectangle();
    shape1.setId("1");
    ShapeCache.putShape(shape1);
    Shape shape2 = new Circle();
    shape2.setId("2");
    ShapeCache.putShape(shape2);
    Shape shape = ShapeCache.getShape("1");
    Assert.assertNotEquals(shape1, shape);
    Assert.assertEquals(shape1.getType(), shape.getType());
    Assert.assertEquals(shape1.getId(), shape.getId());
}

模式优缺点

  • 优点
    • 性能提高
    • 逃避构造函数的约束
  • 缺点
    • 实现克隆方法需要对类的功能进行通盘考虑，对一个全新的类比较容易，对于已有的类不一定很容易
    • 必须实现 Cloneable 接口

使用场景

  • 资源优化场景
  • 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等
  • 性能和安全要求的场景
  • 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
  • 一个对象多个修改者的场景
  • 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用
  • 在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用
学习笔记
#笔记 #设计模式
图说设计模式笔记#3
https://blog.kedr.cc/posts/77324109/
作者
zhuweitung
发布于
2022年6月30日
许可协议