设计模式-建造者模式

定义与类型

将一个复杂类型的构建与它的标示分离，使得同样的构建过程可以创建不同的表示。
用户只需指定需要建造的类型就可以得到它们，建造过程及细节不需要知道。
类型：创建型

建造者-适用场景

1. 一个对象有非常复杂的内部结构（很多属性）。
2. 想把复杂对象的创建与使用分离。

建造者-优点

1. 封装性好，创建和使用分离。
2. 扩展性好，建造类之间独立、一定程度上解耦。

建造者缺点

1. 产生多余的Builder对象。
2. 产品内部发生变化，建造者都要修改，成本较大。

建造者与工厂模式的区别

1. 建造者强调调用方法的顺序，工厂模式强调创建产品。
2. 创建对象的粒度不同，建造者可以创建复杂的产品，由各种复杂的构件组成，工厂模式创建出来的都是一个样子。
3. 工厂模式关注的只要把产品创建出来就OK了，而建造者模式还关注产品由哪些构件组成的。
4. 两者最大的区别在于，当创建一个产品需要复杂的步骤时适用建造者模式，而当创建的产品只需要简单的方法创建整个对象时适用于工厂模式。

代码示例

以创建课程的业务为例，制作一个完整的课程需要输出视频、手记、QA、PPT等。

课程类，课程由课程名字、PPT、QA、视频、手记构成。

public class Course {
    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    //question & answer
    private String courseQA;

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCoursePPT() {
        return coursePPT;
    }

    public void setCoursePPT(String coursePPT) {
        this.coursePPT = coursePPT;
    }

    public String getCourseVideo() {
        return courseVideo;
    }

    public void setCourseVideo(String courseVideo) {
        this.courseVideo = courseVideo;
    }

    public String getCourseArticle() {
        return courseArticle;
    }

    public void setCourseArticle(String courseArticle) {
        this.courseArticle = courseArticle;
    }

    public String getCourseQA() {
        return courseQA;
    }

    public void setCourseQA(String courseQA) {
        this.courseQA = courseQA;
    }

    @Override
    public String toString() {
        return "Course{" +
                "courseName='" + courseName + '\'' +
                ", coursePPT='" + coursePPT + '\'' +
                ", courseVideo='" + courseVideo + '\'' +
                ", courseArticle='" + courseArticle + '\'' +
                ", courseQA='" + courseQA + '\'' +
                '}';
    }
}

抽象的课程制作类

public abstract class CourseBuilder {

    public abstract void buildCourseName(String courseName);
    public abstract void buildCoursePPT(String coursePPT);
    public abstract void buildCourseVideo(String courseVideo);
    public abstract void buildCourseArticle(String courseArticle);
    public abstract void buildCourseQA(String courseQA);

    public abstract Course makeCourse();

}

具体的课程制作类

public class CourseActualBuilder extends CourseBuilder {

    private Course course = new Course();


    @Override
    public void buildCourseName(String courseName) {
        course.setCourseName(courseName);
    }

    @Override
    public void buildCoursePPT(String coursePPT) {
        course.setCoursePPT(coursePPT);
    }

    @Override
    public void buildCourseVideo(String courseVideo) {
        course.setCourseVideo(courseVideo);
    }

    @Override
    public void buildCourseArticle(String courseArticle) {
        course.setCourseArticle(courseArticle);
    }

    @Override
    public void buildCourseQA(String courseQA) {
        course.setCourseQA(courseQA);
    }

    @Override
    public Course makeCourse() {
        return course;
    }
}

课程指挥官，通过调用课程制作类来制作课程

public class Coach {
    private CourseBuilder courseBuilder;

    public void setCourseBuilder(CourseBuilder courseBuilder) {
        this.courseBuilder = courseBuilder;
    }

    public Course makeCourse(String courseName,String coursePPT,
                             String courseVideo,String courseArticle,
                             String courseQA){
        this.courseBuilder.buildCourseName(courseName);
        this.courseBuilder.buildCoursePPT(coursePPT);
        this.courseBuilder.buildCourseVideo(courseVideo);
        this.courseBuilder.buildCourseArticle(courseArticle);
        this.courseBuilder.buildCourseQA(courseQA);
        return this.courseBuilder.makeCourse();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        CourseBuilder courseBuilder = new CourseActualBuilder();
        Coach coach = new Coach();
        coach.setCourseBuilder(courseBuilder);

        Course course = coach.makeCourse("Java设计模式",
                "Java设计模式PPT",
                "Java设计模式视频",
                "Java设计模式手记",
                "Java设计模式问答");
        System.out.println(course);

    }
}

上述场景中，课程指挥官通过注入课程创建创建工厂构建课程，这个课程工厂可以灵活的扩展，根据不同的课程，实现不同的逻辑。
我们针对上述场景再进行演进，创建课程指挥官可能不是必须的，此时使用建造者模式进行演进，V2版本的代码如下。

将建造者类作为一个内部类放在实体类当中，代码的关键在于内部类的方法返回的都是其本身，以供后续方法的链式调用，通过建造者的build方法，调用对象的构造方法返回course对象。

public class Course {

    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    //question & answer
    private String courseQA;

    public Course(CourseBuilder courseBuilder) {
        this.courseName = courseBuilder.courseName;
        this.coursePPT = courseBuilder.coursePPT;
        this.courseVideo = courseBuilder.courseVideo;
        this.courseArticle = courseBuilder.courseArticle;
        this.courseQA = courseBuilder.courseQA;
    }


    @Override
    public String toString() {
        return "Course{" +
                "courseName='" + courseName + '\'' +
                ", coursePPT='" + coursePPT + '\'' +
                ", courseVideo='" + courseVideo + '\'' +
                ", courseArticle='" + courseArticle + '\'' +
                ", courseQA='" + courseQA + '\'' +
                '}';
    }

    public static class CourseBuilder{
        private String courseName;
        private String coursePPT;
        private String courseVideo;
        private String courseArticle;

        //question & answer
        private String courseQA;

        public CourseBuilder buildCourseName(String courseName){
            this.courseName = courseName;
            return this;
        }


        public CourseBuilder buildCoursePPT(String coursePPT) {
            this.coursePPT = coursePPT;
            return this;
        }

        public CourseBuilder buildCourseVideo(String courseVideo) {
            this.courseVideo = courseVideo;
            return this;
        }

        public CourseBuilder buildCourseArticle(String courseArticle) {
            this.courseArticle = courseArticle;
            return this;
        }

        public CourseBuilder buildCourseQA(String courseQA) {
            this.courseQA = courseQA;
            return this;
        }

        public Course build(){
            return new Course(this);
        }



    }
}

public class Test {
    public static void main(String[] args) {
        Course course = new Course.CourseBuilder().buildCourseName("Java设计模式").buildCoursePPT("Java设计模式PPT").
                buildCourseVideo("Java设计模式视频").build();
        System.out.println(course);
    }
}

通过链式调用，可以很灵活的组装对象所需要的属性。

源码解析

1. JDK中的StringBuilder中的append方法，返回的就是其对象本身，方便后续的链式调用，还有StringBuffer都是很典型的建造者模式的应用。
   
2. guava中的ImmutableSet中的Builder也是使用了建造者模式的思想进行创建对象。