【设计模式】建造者模式

---

一、建造者模式

一句话总结：目的就是为了创建一个复杂的对象，也可以试试链式调用的方式使得更加的优雅

• 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，用户只需要指定需要建造的类型就可以得到它们，建造过程及细节不需要知道
• 类型：创建型
• 使用场景：如果一个对象有非常复杂的数据结构（很多属性），想把复杂的创建和使用分离
• 优点：
  • 封装性好，创建和使用分离
  • 扩展性好、建造类之间独立、一定程度上解耦
• 缺点：
  • 产生多余的Builder对象
  • 产品内部发生变化建造者都要修改，成本较大
• 和工厂模式的区别：
  • 建造者模式更注重于创建时方法的调用顺序，工厂模式注重于创建产品
  • 建造者可以创建一些复杂的产品，由各种复杂的部件组成，工厂模式创建出来的都是一个样
  • 工厂模式注重的只要把对象创建出来即可，而建造者模式不只要创建出产品，也还要知道这个产品由哪些部件组成
• Coding：

/**
 * 课程类
 */
public class Course {
    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    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("设计模式",
                "设计模式PPT",
                "设计模式视频",
                "设计模式文章",
                "设计模式问答");
        System.out.println(course);
    }
}
================================ 控制台输出 ===============================
Course{courseName='设计模式', coursePPT='设计模式PPT', courseVideo='设计模式视频', courseArticle='设计模式手记', courseQA='设计模式问答'}

• UML类图：
  
• 说明：教练（Coach）包含一个课程（Course）建造者抽象类（CourseBuilder），实际的建造者（CourseActualBuilder）继承了建造者抽象类，并且持有一个课程类

二、链式调用改造

• Coding：

public class Course {

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

    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;

        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("设计模式")
                .buildCoursePPT("设计模式精讲PPT")
                .buildCourseVideo("设计模式精讲视频")
                .build();
        System.out.println(course);
    }
}
================================ 控制台输出 ===============================
Course{courseName='设计模式', coursePPT='设计模式精讲PPT', courseVideo='设计模式精讲视频', courseArticle='null', courseQA='null'}

• UML类图：
  
• 说明：应用层（Test）只需要和建造者进行交互，设置实体类的属性，最后调用builder方法返回具体的实体类，此方式相比上面那种方式灵活很多，想要赋值什么属性直接链式调用相应builder方法即可。

三、源码中的应用

• java.lang.StringBuilder#append()

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
	...
    @Override
    public StringBuilder append(boolean b) {
        super.append(b);
        return this;
    }

    @Override
    public StringBuilder append(char c) {
        super.append(c);
        return this;
    }
    ...
}

• java.lang.StringBuffer#append() 方法也一样，只不过加了同步锁

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
	...
    @Override
    public synchronized StringBuffer append(boolean b) {
        toStringCache = null;
        super.append(b);
        return this;
    }

    @Override
    public synchronized StringBuffer append(char c) {
        toStringCache = null;
        super.append(c);
        return this;
    }
	...
}

• com.google.common.collect.ImmutableSet

Set<String> set = ImmutableSet.<String>builder().add("a").add("b").build();

• 还有很多框架源码都会用到，比如博主以前写过的 Spring Security 笔记

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.formLogin()
				// 使用自定义的表单登录页面
				.loginPage("/meicloud-signIn.html")
				// 以下这行 UsernamePasswordAuthenticationFilter 会知道要处理表单的 /authentication/form 请求，而不是默认的 /login
				.loginProcessingUrl("/authentication/form")
				.and()
				.authorizeRequests()
				// 排除对 "/meicloud-signIn.html" 的身份验证
				.antMatchers("/meicloud-signIn.html").permitAll()
				// 表示所有请求都需要身份验证
				.anyRequest()
				.authenticated()
				.and()
				.csrf().disable();// 暂时把跨站请求伪造的功能关闭掉
	}