建造者模式的解读与思考

在上次的博客中我解读并用自己的方式去理解了一下工厂模式，可以说略有所得，而这次我来看建造者模式，可以看到这两次都是关于对象创建这方面的模式，为什么呢，其实是因为我之前看了装饰者模式之后，我一直想用自己的方式设计一下我们公司锁屏的实现方式，可以说我们主管写的实现方式是很不错的，但是，我总觉得有点不足，所以准备自己写一个，看看能否让自己满意

建造者模式的基本原理

由于我不知道怎么画图，又贪图省事，所以把别人的图拿过来做了一些注解

那么进入正题，这次我去解读的是建造者模式，首先来个建造者模式的范例

这是需要创建的产品

public class Product {
    /**
     * 定义一些关于产品的参数
     */
    private String part1;
    private String part2;
    public String getPart1() {
        return part1;
    }
    public void setPart1(String part1) {
        this.part1 = part1;
    }
    public String getPart2() {
        return part2;
    }
    public void setPart2(String part2) {
        this.part2 = part2;
    }
}

接下来是创建者的接口

public interface Builder {
    public void buildPart1();
    public void buildPart2();
    public Product getProduct();
}

public class ConcreteBuilder implements Builder {

    private Product product = new Product();
    /**
     * 产品零件建造方法1
     */
    @Override
    public void buildPart1() {
        //构建产品的第一个零件
 　　　　product.setPart1("部件1");
    }
    /**
     * 产品零件建造方法2
     */
    @Override
    public void buildPart2() {
        //构建产品的第二个零件
 　　　　product.setPart2("部件2");
    }
    /**
     * 产品返还方法
     */
    @Override
    public Product getProduct() {
        return product;
    }

}

接下来是导演类

public class Director {
    /**
     * 持有当前需要使用的建造器对象
     */
    private Builder builder;
    /**
     * 构造方法，传入建造器对象
     * @param builder 建造器对象
     */
    public Director(Builder builder){
        this.builder = builder;
    }
    /**
     * 产品构造方法，负责调用各个零件建造方法
     */
    public void construct(){
        builder.buildPart1();
        builder.buildPart2();
    }
}

这样就是一个简单的建造者模式了

建造者模式与工厂模式的比较

那么既然有了建造者模式的基本原理，我就可以拿它与工厂模式做一番比较

首先，工厂模式专注于对象的创建，但是可以发现，抽象工厂模式与建造者模式是十分相似的

1、初步的区别

他们唯一的区别在于，抽象工厂模式缺少了一个导演类，就是说，与建造者模式相比，工厂模式是少了一个

类的各个部分创建的控制

2、适用的范围

在初步的区别之后可以发现，工厂模式适用于对于创建对象中各个参数的定制需求相对来说不是那么细的情况

而建造者模式则是针对创建对象内部参数的区别定制有了一个很好的扩展

3、由两种模式的相似点与不同点引发的代码编写思维

上次在思考工厂模式的时候，我发现了依赖倒置原则的使用，那么在建造者模式，我们也可以发现这种原则的使用，毕竟代码基本是差不多的，建造者模式可以说是针对工厂模式的一种进一步的针对需求的细化，并且再结合这两种模式的方式之后，我总结发现了一下几点

①、功能单一原则，可以发现，从策略模式到工厂模式到建造者模式，所有的优化都是将原本会需要变化的部分单独封装起来管理，不是在原来基础上修改，而是让其更加单一

②、组合代替继承，比较目前的一些设计模式，会发现很多需要细化的功能都是在拆分成很单一的模块时候，同过各种方式组合起来

③、需求扩展，需要将原本比较简单的不会改变的地方修改成会需要经常修改需求时，也不要修改原本实现的方法，而是扩展，尽量不去修改，这一点从一开始设计时就需要考虑到

总的来说，目前可以发现，从代码的不断优化总是带有一个不断地拆分代码的过程，让每一个功能简单、简单、再简单，复杂应该体现在上层的控制层

如果我来写这些模式时，我会怎么写

如果结合策略模式来写的话，我会将原本的创建者接口写成这样

public abstract class Builder {
	
	
	public Part1CreateInterface mPart1;
	public Part2CreateInterface mPart2;
	
    public void buildPart1(){
    	mProduct.setPart1(mPart1.build());
    }
    public void buildPart2(){
    	mProduct.setPart2(mPart2.build());
    }
    
    /**
     * 初始化part1建造接口
     */
    public abstract void initPart1Create();
    
    /**
     * 初始化part2建造接口
     */
    public abstract void initPart2Create();
    
    public Product getProduct();
}

可以看到，我将初始化部件的方法又封装成了接口，这样这些接口的实现类可以复用，还可以灵活地替换，这是结合了策略模式

但是其核心思想还是单一化功能+组合+依赖倒置原则

这是从策略模式+工厂模式+建造者模式学习到的，以后需要多多使用，本篇就到这里