简介

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。建造者模式又被称为生成器模式，建造模式等，实际上建造者模式的核心就在于把对象的构造过程抽象出来。
让我们举个例子，比如我们常常在电视上看到做菜的节目，做一道菜出来，必须是要经过洗菜，炒菜，放盐，放调料……吧啦吧啦一套程序下来，才能变成我们吃的美味的菜，但是轮到我们自己做的时候，可能就已经不是很记得清步骤了，到底是要先放盐呢还是要先加水呢？这个时候我们就会想到把这个做菜的步骤记录下来，然后自己就可以一步一步按照步骤来做菜了，也许在细致一点，我们还可以把放多少盐加多少水都记下来，这样我们自己做的菜就和电视里面的菜相差无几了。

该模式的主要优点如下:

各个具体的建造者相互独立，有利于系统的扩展。
客户端不必知道产品内部组成的细节，便于控制细节风险。

其缺点如下︰

产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，该模式会增加很多的建造者类。

建造者(Builder )模式和工厂模式的关注点不同:建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

应用实例:写作文

首先定义写作文的步骤有哪些，写标题，写开头，写内容，写结尾，那么先定义一个接口，列举所有的步骤，
取名为CompositionBuilder。

package com.mori.design.pattern.builder;
/**
 * 作文
 *
 * @author mori
 */
public interface CompositionBuilder {
    /**
     * 写标题
     *
     * @return {@link String}
     */
   String writeTitle();
    /**
     * 写开头
     *
     * @return {@link String}
     */
   String writeTheBeginning();
    /**
     * 写内容
     *
     * @return {@link String}
     */
    String writeContent();
    /**
     * 写结尾
     *
     * @return {@link String}
     */
   String writeTheEnd();
}

作文有不同的主题，对于不同的主题，实现是不同的。比如一个是春游，一个是看电影。

package com.mori.design.pattern.builder;
/**
 * 春游作文
 * @author mori
 */
public class SpringOutingCompositionBuilder implements CompositionBuilder {
    @Override
    public String writeTitle() {
        return "春游";
    }
    @Override
    public String writeTheBeginning() {
        return "今天，我们几个人去春游。";
    }
    @Override
    public String writeContent() {
        return "我们去了哪里，看到什么风景，怎么怎么样。";
    }
    @Override
    public String writeTheEnd() {
        return "啊！春游真好！真有意义啊！";
    }
}

package com.mori.design.pattern.builder;
/**
 * 看电影作文
 * @author mori
 */
public class WatchingMovieCompositionBuilder implements CompositionBuilder{
    @Override
    public String writeTitle() {
        return "看电影";
    }
    @Override
    public String writeTheBeginning() {
        return "今天，我们几个人一起去看电影。";
    }
    @Override
    public  String writeContent() {
        return "去哪个电影院，看什么电影，有什么感触。。。";
    }
    @Override
    public String writeTheEnd() {
        return "啊！电影真好看，下次还想看！";
    }
}

接下来是建造者模式的核心点，无论什么类型的作文，我们写作文的步骤是一样的，我们用一个执行者定义对象的构建步骤，然后传入不同的builder，即可根据相同的步骤构建出我们需要的对象。

package com.mori.design.pattern.builder;
/**
 * 学生类，具体创建对象的执行者
 *
 * @author mori
 */
public class Student {
    /**
     * 写作文,传入不同的builder，总是根据相同的过程构造对象
     *
     * @return {@link String}
     */
    public String writeComposition(CompositionBuilder builder) {
        String title = builder.writeTitle();
        String theBeginning = builder.writeTheBeginning();
        String content = builder.writeContent();
        String theEnd = builder.writeTheEnd();
        return title + "\n" + theBeginning + "\n" + content + "\n" + theEnd;
    }
}

测试

package com.mori.design.pattern.test.builder;
import com.mori.design.pattern.builder.SpringOutingCompositionBuilder;
import com.mori.design.pattern.builder.Student;
import com.mori.design.pattern.builder.WatchingMovieCompositionBuilder;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
 * 建造者模式测试
 *
 * @author mori
 * @date 2021/07/19
 */
@DisplayName("建造者测试用例")
public class BuilderTest {
    @Test
    public void test(){
        Student s1 = new Student();
        System.out.println(s1.writeComposition(new SpringOutingCompositionBuilder()));
        System.out.println("------------下一篇作文--------------");
        System.out.println(s1.writeComposition(new WatchingMovieCompositionBuilder()));
    }
}

控制台输出结果：

春游
今天，我们几个人去春游。
我们去了哪里，看到什么风景，怎么怎么样。
啊！春游真好！真有意义啊！
------------下一篇作文--------------
看电影
今天，我们几个人一起去看电影。
去哪个电影院，看什么电影，有什么感触。。。
啊！电影真好看，下次还想看！