java设计模式之建造者模式

定义：

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

对于用户而言，使用建造者模式只需指定需要创建的类型就可以获得对象，创建过程及细节不需要了解。根据建造者模式的定义，可以简单的理解为两层含义。

1. 构建与表示分离：构建代表对象创建，表示代表对象行为，方法。也就是将对象的创建与行为进行分离（对应到java代码，其实就是使用接口规定行为，然后由具体的实体类进行构建）

2. 创建不同表示：也就是具备同样的行为，但是却由于构建的行为顺序不同或其他原因可以创建出不同的表示

应用场景：

从定义来看，建造者模式和工厂模式是非常相似的，和工厂模式一样，具备创建与表示分离的特性。建造者模式唯一区别与工厂模式的是针对复杂对象的创建，也就是说，如果创建简单对象，通常使用工厂模式进行创建，而如果复杂的对象，就可以考虑使用建造者模式。

当需要创建产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，是创建产品的灵活性大大增加，建造者模式主要用于以下场景

1. 相同的方法，不同的执行顺序，产生不同的结果

2. 多个部件或零件，都可以装配到一个对象中，但是产生的结果有不相同

3. 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用

4. 初始化一个对象特别复杂，参数多，而且很多参数都具有默认值

UML类图：

 

右上图可以看到，建造者模式主要包含四个角色

1. 产品（Product）：要创建产品类对象

2. 抽象建造者（IBuilder）：建造者的抽象类，规范产品对象的各个组成部分的创建，一般由子类实现具体的创建过程

3. 建造者（ConcreteBuilder）：具体的Builder类，根据不同的业务逻辑，具体化对象的各个组成部分的创建

4. 调用者（Director）：调用具体的建造者，来创建对象的各个部分，在指导者中不涉及具体产品的信息，自负责保证对象各部分完整创建或者按照某种顺序创建。在类图中，相当于client的角色

通用写法：

package com.design.pattern.builder;
​
public class Client {
    public static void main(String[] args) {
        IBuilder builder = new ConcreteBuilder();
        System.out.println(builder.build());
    }
}
package com.design.pattern.builder;
​
public class ConcreteBuilder implements IBuilder{
    public Product product = new Product();
    @Override
    public Product build() {
        return product;
    }
}
package com.design.pattern.builder;
​
public interface IBuilder {
    Product build();
}
package com.design.pattern.builder;
​
public class Product {
    public String name;
​
    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                '}';
    }
}

使用建造者模式解决实际问题：

建造者模式的链式写法：

以课程为例，一个完整的课程有PPT课件，回放视频，课堂笔记，课后作业组成，但是这些内容的设置顺序可以随意调整，我们用建造者模式来带入理解一下。首先创建一个产品类Course

package com.design.pattern.builder;
​
import lombok.Data;
​
@Data
public class Course {
    private String name;
    private String ppt;
    private String videos;
    private String note;
​
    private String homework;
​
    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                ", ppt='" + ppt + '\'' +
                ", videos='" + videos + '\'' +
                ", note='" + note + '\'' +
                ", homework='" + homework + '\'' +
                '}';
    }
}

然后创建建造者类CourseBuilder，将复杂的创建过程封装起来，创建步骤由用户决定

package com.design.pattern.builder;
​
public class CourseBuilder {
    private Course course = new Course();
    public CourseBuilder addName(String name){
        course.setName(name);
        return this;
    }
    public CourseBuilder addPpt(String ppt){
        course.setPpt(ppt);
        return this;
    }
    public CourseBuilder addVideo(String video){
        course.setVideos(video);
        return this;
    }
    public CourseBuilder addNote(String note){
        course.setNote(note);
        return this;
    }
    public CourseBuilder addHomeWork(String homeWork){
        course.setHomework(homeWork);
        return this;
    }
    public Course builder(){
        return course;
    }
}

最后编写客户端测试代码：

package com.design.pattern.builder;
​
public class BuilderTest {
    public static void main(String[] args) {
        CourseBuilder courseBuilder = new CourseBuilder().addName("设计模式")
                .addNote("note")
                .addPpt("ppt")
                .addVideo("video")
                .addHomeWork("homeWork");
        System.out.println(courseBuilder.builder());
    }
}

静态内部类实现建造者模式

一般情况下，我们更习惯使用静态内部类的方式实现建造者模式，即一个产品类内部自动带有一个具体建造者，由它负责该产品的组装创建，不再需要Builder和director，这样产品表示与创建之间的联系更加紧密，结构更加紧凑，同时是的建造者模式的形式更加简洁

使用静态内部类的方式，前面的案例可以改写为：

package com.design.pattern.builder;
​
public class Course2 {
    private String name;
    private String ppt;
    private String videos;
    private String note;
​
    private String homework;
​
    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                ", ppt='" + ppt + '\'' +
                ", videos='" + videos + '\'' +
                ", note='" + note + '\'' +
                ", homework='" + homework + '\'' +
                '}';
    }
    public static class Builder{
        private Course course = new Course();
        public Builder addName(String name){
            course.setName(name);
            return this;
        }
        public Builder addPpt(String ppt){
            course.setPpt(ppt);
            return this;
        }
        public Builder addVideo(String video){
            course.setVideos(video);
            return this;
        }
        public Builder addNote(String note){
            course.setNote(note);
            return this;
        }
        public Builder addHomeWork(String homeWork){
            course.setHomework(homeWork);
            return this;
        }
        public Course builder(){
            return course;
        }
    }
}

客户端测试代码：

package com.design.pattern.builder;
​
public class StaticBuilderTest {
    public static void main(String[] args) {
        Course builder = new Course2.Builder().addName("设计模式")
                .addNote("note")
                .addPpt("ppt")
                .addVideo("video")
                .addHomeWork("homeWork")
                .builder();
        System.out.println(builder);
​
    }
}

这样代码看上去更加简洁，不会让人感觉到多了一个类

建造者模式与工厂模式的区别

1. 建造者模式更注重方法的调用顺序，工厂模式更注重创建对象

2. 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样

3. 关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成

4. 建造者模式根绝建造过程中的顺序不一样，最终的对象部件组成也不一样

建造者模式的优点：

1. 封装性好，构建和表示分离

2. 扩展性好，建造类之间独立，在一定程度上接偶

3. 便于控制细节，建造者可以对创建过程逐步细化，而不对其他模块产生任何影响

建造者模式的缺点：

1. 需要多创建一个Builder对象

2. 如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大