设计模式之——Builder模式

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/binbinqq86/article/details/79052236

转载请注明出处：http://blog.csdn.net/binbinqq86/article/details/79052236

Builder模式相信大家经常使用，可能你并不知道这个模式，但是你做Android开发，肯定天天都在使用，拿最简单的例子来说：Dialog。它里面的Builder类就是一个建造者模式，看到这些相信你一切都明白了，原来如此。。。

Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细地控制对象的构建过程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。现在很多第三方框架，比如Glide，OkHttp，Retrofit，Rxjava等等，到处都是这种链式调用，使用起来非常方便，而且当参数越来越多的时候，你就会发现这种模式真的特别方便和易读。Builder模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。

Builder模式的定义：

将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

Builder模式的使用场景：

• 相同的方法，不同的执行顺序，产生不同的事件结果时。
• 多个零部件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候Builder模式非常合适。
• 当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。

老规矩，先看UML类图：

角色介绍：

• Product产品类——产品的抽象类
• Builder——抽象Builder类，规范产品的组建，一般是由子类实现具体的组件过程
• ConcreteBuilder——具体的Builder类
• Director——统一组装过程

下面我们通过一个案例来分析一下：比如一个房子，会涉及业主，房间数量，装修风格，房屋地址等等信息，可以说非常之多，这里我们简单用以上几个属性来举例说明。下面请看示例：

package com.example.tb.designpatten.builder.base;

/**
 * Created by TianBin on 2018/1/13 17:35.
 * Description :抽象产品类
 */

public abstract class House {
    protected String host;//业主
    protected int houseNum;//房间数
    protected String style;//装修风格
    protected String address;//房屋地址

    public abstract void setHost();

    public void setHouseNum(int houseNum) {
        this.houseNum = houseNum;
    }

    public void setStyle(String style) {
        this.style = style;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "House{" +
                "host='" + host + '\'' +
                ", houseNum=" + houseNum +
                ", style='" + style + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

package com.example.tb.designpatten.builder.subclass;

import com.example.tb.designpatten.builder.base.House;

/**
 * Created by TianBin on 2018/1/13 17:42.
 * Description :我的房子
 */

public class TbHouse extends House {
    @Override
    public void setHost() {
        host="tb's house";
    }
}

package com.example.tb.designpatten.builder.base;

/**
 * Created by TianBin on 2018/1/13 17:39.
 * Description :抽象Builder类
 */

public abstract class Builder {
    public abstract void setHost();
    public abstract void setHouseNum(int houseNum);
    public abstract void setStyle(String style);
    public abstract void setAddress(String address);
    public abstract House create();
}

package com.example.tb.designpatten.builder.subclass;

import com.example.tb.designpatten.builder.base.Builder;
import com.example.tb.designpatten.builder.base.House;

/**
 * Created by TianBin on 2018/1/13 17:42.
 * Description :构造我的房子的Builder
 */

public class TbBuilder extends Builder {
    private TbHouse tbHouse=new TbHouse();
    @Override
    public void setHost() {
        tbHouse.setHost();
    }

    @Override
    public void setHouseNum(int houseNum) {
        tbHouse.setHouseNum(houseNum);
    }

    @Override
    public void setStyle(String style) {
        tbHouse.setStyle(style);
    }

    @Override
    public void setAddress(String address) {
        tbHouse.setAddress(address);
    }

    @Override
    public House create() {
        return tbHouse;
    }
}

package com.example.tb.designpatten.builder;

import com.example.tb.designpatten.builder.base.Builder;

/**
 * Created by TianBin on 2018/1/13 17:45.
 * Description :负责构造House
 */

public class Director {
    Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }
    public void construct(int houseNum,String style,String address){
        builder.setHouseNum(houseNum);
        builder.setStyle(style);
        builder.setAddress(address);
        builder.setHost();
    }
}

//测试代码
public void test5(){
        Builder builder=new TbBuilder();
        Director director=new Director(builder);
        director.construct(6,"欧美","hz");
        Log.e(TAG, "test5: "+builder.create().toString() );
    }

上述示例中，通过对具体的TbBuilder来构建房子TbHouse对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。

而在实际使用过程中，Director角色经常会被省略，而直接使用一个Builder来进行组装对象，这个Builder通常是链式调用，它的关键点在于每个setter方法都返回自身，代码如下：

package com.example.tb.designpatten.builder.subclass;

import com.example.tb.designpatten.builder.base.Builder;
import com.example.tb.designpatten.builder.base.Builder2;
import com.example.tb.designpatten.builder.base.House;

/**
 * Created by TianBin on 2018/1/13 17:42.
 * Description :构造我的房子的Builder
 */

public class TbBuilder2 extends Builder2 {
    private TbHouse tbHouse=new TbHouse();
    @Override
    public TbBuilder2 setHost() {
        tbHouse.setHost();
        return this;
    }

    @Override
    public TbBuilder2 setHouseNum(int houseNum) {
        tbHouse.setHouseNum(houseNum);
        return this;
    }

    @Override
    public TbBuilder2 setStyle(String style) {
        tbHouse.setStyle(style);
        return this;
    }

    @Override
    public TbBuilder2 setAddress(String address) {
        tbHouse.setAddress(address);
        return this;
    }

    @Override
    public House create() {
        return tbHouse;
    }
}

new TbBuilder2().setAddress("china").setHost().setHouseNum(6).setStyle("田园").create()

通过这种形式不仅去除了Director角色，整个结构也更加简单，看着更加舒服，而且对组装过程可以有更加精细的控制。我们的例子讲完了，下面就一起来看一看Android源码中的Builder模式实现。我们最常用的应该就是文章开头讲过的AlertDialog.Builder了。这里就不再进行细讲了，感兴趣的同学可以自己去翻阅源码看看实现，值得注意的是，AlertDialog的Builder模式中并没有完全按照GOF在书中描述的方式来做，而是做了一些修改，使得这个模式更易于使用，这里的AlertDialog.Builder同时扮演了上文中提到的Builder、Concterebuilder、Director的角色，简化了Builder模式的设计。当模块比较稳定，不存在一些变化时，可以在经典模式实现的基础上做出一些精简，而不是照搬GOF上的经典实现，更不要生搬硬套，使程序失去架构之美。正是由于灵活的运用设计模式，Android源码很值得我们去学习

Builder模式在我们日常开发中还是很常用的，最后来说一下它的优缺点：

• 优点
  
  1. 良好的封装性，使用Builder模式可以使客户端不必知道产品内部组成的细节
  2. 建造者独立，容易扩展
• 缺点
  
  • 会产生多余的Builder对象以及Director对象，消耗内存

好了，今天的讲解就到此结束，有疑问的同学可以在下方留言，谢谢大家~

源码下载