设计模式之建造者模式

什么是建造者模式

    建造者模式将客户端与包含多个组成部分的复杂对象的创建过程分离，客户端无需知道复杂对象的内部组成部分与装配方式。它关注如何一步步创建一个复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便。
    建造者模式是指将一个复杂对象的构建与它的表示相分离，使得同样的构建过程可以创建不同的表示。
    建造者模式包含以下几个角色：
        Builder(抽象建造者)：它为创建一个产品对象的各个部件指定抽象接口，在该接口中一般声明两个类方法，一类是buildPart()，用于创建复杂对象的各个部件；另一个是getResult()，用于返回复杂对象。Builder即可以是接口也可以是抽象类。
        ConcreteBuilder(具体建造者)：实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂对象。
        Product(产品)：被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义他的装配过程。
        Director(指挥者)：负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联，可以在建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要跟指挥者交互，在客户端确定具体建造者的类型，并实例化具体建造者对象。
    建造者模式与抽象工厂模式有点相似，但是建造者模式返回一个完整的复杂产品，而抽象工厂模式返回一系列相关的产品。在抽象工厂模式中，客户端通过选择具体工厂来生成所需对象，而在建造者模式中，客户端通过指定具体建造者类型并指导Driector类如何去创建对象，侧重于一步步构造一个复杂对象。

建造者模式的优缺点

优点

1. 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的对象。
2. 每一个具体建造者都相互独立，因此可以很方便的替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者就可以得到不同的产品对象。由于指挥者类针对抽象建造者编程，系统扩展方便，符合开闭原则。
3. 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。

缺点

1. 创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不同，不适合使用建造者模式，因此使用范围受到一定的限制。
2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得庞大。

建造者模式的应用场景

1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
2. 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
3. 对象的创建过程独立与创建该对象的类。在建造者模式中通过引入指挥者类，将创建过程封装在指挥者类中，而不是在建造者类或客户端中。
4. 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

建造者模式案例

/**
 * 抽象的建造者
 **/
public abstract class HouseBuilder {

	protected House house = new House();

	public abstract void buildBasic();

	public abstract void buildWalls();

	public abstract void roofed();

	public House buildHouse() {
		return house;
	}

}


/**
 * 具体建造者
 **/
public class CommonHouse extends HouseBuilder {

    @Override
    public void buildBasic() {
        System.out.println(" 普通房子打地基5米 ");
    }

    @Override
    public void buildWalls() {
        System.out.println(" 普通房子砌墙10cm ");
    }

    @Override
    public void roofed() {
        System.out.println(" 普通房子屋顶 ");
    }

}

/**
 * 产品对象
 **/
@Data
public class House {

    private String baise;

    private String wall;

    private String roofed;

}

/**
 * 指挥者，这里去指定制作流程，返回产品
 **/
public class HouseDirector {

    HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    /**
     * 如何处理建造房子的流程，交给指挥者
     *
     * @return House
     */
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

/**
 * 客户端
 **/
public class Client {
    public static void main(String[] args) {

        //盖普通房子
        CommonHouse commonHouse = new CommonHouse();
        //准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commonHouse);

        //完成盖房子，返回产品(普通房子)
        House house = houseDirector.constructHouse();
    }
}

建造者模式在源码中的应用

StringBuilder

/**
 *  Appendable 接口为抽象建造者，定义了多个 append 方法，
 **/
public interface Appendable {

    Appendable append(CharSequence csq) throws IOException;


    Appendable append(CharSequence csq, int start, int end) throws IOException;

    Appendable append(char c) throws IOException;
}

/**
 *  AbstractStringBuilder 为具体建造者，完成了抽象建造者中方法的具体实现，这里与上面描述的区别是该类是抽象类，无法实例化。
 通过源码可以发现 StringBuilder 继承了该类做具体的操作。
 StringBuilder 即使指挥者也是具体建造者，
 **/
abstract class AbstractStringBuilder implements Appendable, CharSequence {
        // Documentation in subclasses because of synchro difference
    @Override
    public AbstractStringBuilder append(CharSequence s) {
        if (s == null)
            return appendNull();
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof AbstractStringBuilder)
            return this.append((AbstractStringBuilder)s);

        return this.append(s, 0, s.length());
    }
    
    @Override
    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                + s.length());
        int len = end - start;
        ensureCapacityInternal(count + len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }
    
    @Override
    public AbstractStringBuilder append(char c) {
        ensureCapacityInternal(count + 1);
        value[count++] = c;
        return this;
    }
    
}

public final class StringBuilder extends AbstractStringBuilder implements Serializable, CharSequence {
    ......
}

BeanDefinition

/**
 * 抽象建造者，定义了各种Bean对象的属性
 **/
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	void setFactoryBeanName(@Nullable String factoryBeanName);

	void setBeanClassName(@Nullable String beanClassName);
    ......
}

/**
 * 具体建造者
 **/
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {
	@Override
	public void setFactoryBeanName(@Nullable String factoryBeanName) {
		this.factoryBeanName = factoryBeanName;
	}

	@Override
	public void setBeanClassName(@Nullable String beanClassName) {
		this.beanClass = beanClassName;
	}
	......	    
}

/**
 * 指挥者，使用多个简单的对象一步一步构建成一个复杂的对象
 **/
public final class BeanDefinitionBuilder {
	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 */
	public static BeanDefinitionBuilder genericBeanDefinition() {
		return new BeanDefinitionBuilder(new GenericBeanDefinition());
	}
		/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 * @param beanClassName the class name for the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder genericBeanDefinition(String beanClassName) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClassName(beanClassName);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 * @param beanClass the {@code Class} of the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClass(beanClass);
		return builder;
	}
	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}.
	 * @param beanClassName the class name for the bean that the definition is being created for
	 * @param factoryMethodName the name of the method to use to construct the bean instance
	 */
	public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName, @Nullable String factoryMethodName) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
		builder.beanDefinition.setBeanClassName(beanClassName);
		builder.beanDefinition.setFactoryMethodName(factoryMethodName);
		return builder;
	}
	......
}

---