设计模式-建造者模式

建造者模式（Builder）

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。看一下类图：

 

成员分析：

　　　　Director：控制者类，这是控制整个组合过程，在这个类内部有个Construct()方法，这个方法的作用就是通过调用Builder内部的各个组件的生成方法来完成组装；

　　　　Builder：构建者接口，定义各部件生成的方法；

　　　　ConcreteBuilder：具体构建者类：实现Builder构建者接口，具体定义如何生成各个部件；依赖于Product成品类，其中还有获取成品组装结构的方法GetResult()方法；

　　　　Product：成品类

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

下面看一下代码：

/**
 * 一个具体的产品对象，实体
 */
@Data
public class Meal {
    private String food;
    private String drink;
}

/**
 * 抽象建造者
 */
public abstract class MealBuilder {

    Meal meal = new Meal();

    public abstract void buildFood();

    public abstract void buildDrink();

    public Meal getMeal(){
        return meal;
    }
}

 

/**
 * 具体建造者：MealA
 */
public class MealA extends MealBuilder{
    public void buildDrink() {
        meal.setDrink("可乐");
    }

    public void buildFood() {
        meal.setFood("薯条");
    }
}

/**
 * 具体建造者：MealB
 */
public class MealB extends MealBuilder{
    public void buildDrink() {
        meal.setDrink("柠檬果汁");
    }

    public void buildFood() {
        meal.setFood("鸡翅");
    }
}

 

/**
 * 指挥者：构建一个使用Builder接口的对象
 */
public class KFCServer {
    private MealBuilder mealBuilder;

    public KFCServer(MealBuilder mealBuilder) { //构造方法
        this.mealBuilder = mealBuilder;
    }

    public Meal construct(){
        //准备食物
        mealBuilder.buildFood();
        //准备饮料
        mealBuilder.buildDrink();

        //准备完毕，返回一个完整的套餐给客户
        return mealBuilder.getMeal();
    }
}

 

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {

        MealA a = new MealA();//创建MealA对象
        KFCServer waitera = new KFCServer(a);//准备MealA的服务员
        Meal mealA = waitera.construct();//获得MealA
        System.out.print("套餐A的组成部分:");
        System.out.println("食物："+mealA.getFood()+"；   "+"饮品："+mealA.getDrink());

        MealB b = new MealB();
        KFCServer waiterb = new KFCServer(b);
        Meal mealB = waiterb.construct();
        System.out.print("套餐B的组成部分:");
        System.out.println("食物："+mealB.getFood()+"；   "+"饮品："+mealB.getDrink());
    }
}

 结果：

套餐A的组成部分:食物：薯条；   饮品：可乐
套餐B的组成部分:食物：鸡翅；   饮品：柠檬果汁

 

再有一种：（这种暂时还没搞清楚，建议先不要看）

还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。

public interface Sender {
    public void send();
}

public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("MailSender");
    }
}

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("SmsSender");
    }
}

 建造者类如下：

public class Builder {
    
    private List<Sender> list = new ArrayList<Sender>();
    
    public void produceMailSender(int count){
        for(int i=0; i<count; i++){
            list.add(new MailSender());
        }
    }
    
    public void produceSmsSender(int count){
        for(int i=0; i<count; i++){
            list.add(new SmsSender());
        }
    }
}

测试类：

public class Test {
 
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}

从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工厂模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。

建造者模式的优缺点：

优点：

封装性好，创建和使用分离；无需修改原有代码，符合“开闭原则”。
拓展性好，建造类之间独立，一定程度上解耦；代码解耦，模块化，方便维护。产品本身与创建过程解耦，可以使用相同的创建过程得到不同的产品。
缺点：

产品必须有共同点，使用范围有限。建造者模式创造出来的产品，其组成部分基本相同。如果产品之间的差异较大，则不适用这个模式。
若产品内部发生变化，建造者都要修改，成本较大；若内部变化复杂，会有很多的建造类。