Android设计模式之——Builder模式

最新推荐文章于 2023-12-08 15:32:54 发布

蹲街式等待

最新推荐文章于 2023-12-08 15:32:54 发布

阅读量6.9k

点赞数

分类专栏： Android设计模式 Android 文章标签：设计模式 android

本文链接：https://blog.csdn.net/wangzhongshun/article/details/78305007

版权

Android 同时被 2 个专栏收录

70 篇文章 4 订阅

订阅专栏

Android设计模式

16 篇文章 0 订阅

订阅专栏

一、介绍

Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。

因为一个复杂的对象有很多大量组成部分，例如车，有车轮、方向盘、发动机，还有各种小零件等，如何将这些部件装配成一辆汽车，这个装配过程很漫长，也很复杂，对于这种情况，为了在构建过程中对外部隐藏实现细节，就可以使用Builder模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。

二、定义

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

三、使用场景

（1）相同的方法，不同的执行顺序，产生不同的事件结果时。

（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。

（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用建造者模式非常合适。

（4）当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。

四、Builder模式的UML类图

角色介绍：

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

这里写图片描述

五、Builder模式的简单实现

计算机的组装过程较为复杂，并且组装顺序是不固定的，为了易于理解，我们把计算机的组装过程简化为构建主机、设置操作系统、设置显示器3个部分，然后通过Director和具体的Builder来构建计算机对象。

示例代码：

/**
 * 计算机抽象类，即Product角色
 */
public abstract class Computer {

    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

    protected Computer(){}

    /**
     * 设置主板
     * @param board
     */
    public void setBoard(String board){
        this.mBoard = board;
    }

    /**
     * 设置显示器
     * @param display
     */
    public void setDisplay(String display){
        this.mDisplay = display;
    }

    /**
     * 设置操作系统
     */
    public abstract void setOS();

    @Override
    public String toString(){
        return "Computer [mBoard=" + mBoard + ", mDisplay=" + mDisplay + ", mOS=" + mOS + "]";
    }
}

/**
 * 具体的Computer类，Macbook
 */
public class Macbook extends Computer {

    protected Macbook(){}

    @Override
    public void setOS() {
        mOS = "Mac OS X 10";
    }
}

/**
 * 抽象Builder类
 */
public abstract class Builder {
    /**
     * 设置主机
     * @param board
     */
    public abstract void buildBoard(String board);

    /**
     * 设置显示器
     * @param display
     */
    public abstract void buildDisplay(String display);

    /**
     * 设置操作系统
     */
    public abstract void buildOS();

    /**
     * 创建Computer
     * @return
     */
    public abstract Computer create();
}

/**
 * 具体的Builder类，MacbookBuilder
 */
public class MacbookBuilder extends Builder {
    private Computer mComputer = new Macbook();
    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        mComputer.setOS();
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

/**
 * Director类，负责构造Computer
 */
public class Director {
    Builder mBuilder = null;

    public Director(Builder builder){
        mBuilder = builder;
    }

    /**
     * 构建对象
     * @param board 主板
     * @param display 显示器
     */
    public void construct(String board, String display){
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

/**
 * 测试代码
 */
public class Test {
    public static void main(String[] args){
        //构建器
        Builder builder = new MacbookBuilder();
        //Director
        Director pcDirector = new Director(builder);
        //封装构建过程
        pcDirector.construct("英特尔主板","Retina显示器");
        //构建计算机，输出相关信息
        System.out.println("Computer Info : " + builder.create().toString());
    }
}

输出结果：

Computer Info : Computer [mBoard=英特尔主板, mDisplay=Retina显示器, mOS=Mac OS X 10]

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

值得注意的是，在现实的开发过程中，Director角色经常会被省略。而直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this，这样就使得setter方法可以链式调用，代码大致如下：

new TestBuilder()
    .setA("A")
    .create();

通过这种形式不仅去除了Director角色，整个结构也更加简单，也能对Product对象的组装过程有更精细的控制。

六、Builder模式变种——链式调用

示例代码：

public class User {
    private final String name;         //必选
    private final String cardID;       //必选
    private final int age;             //可选
    private final String address;      //可选
    private final String phone;        //可选

    private User(UserBuilder userBuilder){
        this.name=userBuilder.name;
        this.cardID=userBuilder.cardID;
        this.age=userBuilder.age;
        this.address=userBuilder.address;
        this.phone=userBuilder.phone;
    }

    public String getName() {
        return name;
    }

    public String getCardID() {
        return cardID;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public String getPhone() {
        return phone;
    }

    public static class UserBuilder{
        private final String name;
        private final String cardID;
        private int age;
        private String address;
        private String phone;

        public UserBuilder(String name,String cardID){
            this.name=name;
            this.cardID=cardID;
        }

        public UserBuilder age(int age){
            this.age=age;
            return this;
        }

        public UserBuilder address(String address){
            this.address=address;
            return this;
        }

        public UserBuilder phone(String phone){
            this.phone=phone;
            return this;
        }

        public User build(){
            return new User(this);
        }
    }
}

需要注意的点：

User类的构造方法是私有的，调用者不能直接创建User对象。
User类的属性都是不可变的。所有的属性都添加了final修饰符，并且在构造方法中设置了值。并且，对外只提供getters方法。
Builder的内部类构造方法中只接收必传的参数，并且该必传的参数使用了final修饰符。

调用方式：

new User.UserBuilder("Jack","10086")
        .age(25)
        .address("GuangZhou")
        .phone("13800138000")
        .build();

相比起前面通过构造函数和setter/getter方法两种方式,可读性更强。唯一可能存在的问题就是会产生多余的Builder对象，消耗内存。然而大多数情况下我们的Builder内部类使用的是静态修饰的(static)，所以这个问题也没多大关系。

关于线程安全

Builder模式是非线程安全的，如果要在Builder内部类中检查一个参数的合法性，必需要在对象创建完成之后再检查

正确示例：

public User build() {
  User user = new user(this);
  if (user.getAge() > 120) {
    throw new IllegalStateException(“Age out of range”); // 线程安全
  }
  return user;
}

错误示例：

public User build() {
  if (age > 120) {
    throw new IllegalStateException(“Age out of range”); // 非线程安全
  }
  return new User(this);
}

七、用到Builder模式的例子

1、Android中的AlertDialog.Builder

private void showDialog(){
        AlertDialog.Builder builder=new AlertDialog.Builder(context);
        builder.setIcon(R.drawable.icon);
        builder.setTitle("Title");
        builder.setMessage("Message");
        builder.setPositiveButton("Button1", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                //TODO
            }
        });
        builder.setNegativeButton("Button2", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                //TODO
            }
        });

        builder.create().show();
}

2、OkHttp中OkHttpClient的创建

OkHttpClient  okHttpClient = new OkHttpClient.Builder()
                 .cache(getCache()) 
                 .addInterceptor(new HttpCacheInterceptor())
                 .addInterceptor(new LogInterceptor())
                 .addNetworkInterceptor(new HttpRequestInterceptor()) 
                 .build();

3、Retrofit中Retrofit对象的创建

Retrofit retrofit = new Retrofit.Builder()
         .client(createOkHttp())
        .addConverterFactory(GsonConverterFactory.create())
         .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
         .baseUrl(BASE_URL)
         .build();

可见在实际使用中，均省略掉了Director角色，在很多框架源码中，涉及到Builder模式时，大多都不是经典GOF的Builder模式，而是选择了结构更加简单的后者。

八、优缺点

优点：

良好的封装性，使得客户端不需要知道产品内部实现的细节
建造者独立，扩展性强

缺点：

产生多余的Builder对象、Director对象，消耗内存

参考资料

《Android源码设计模式与解析实战》

设计模式之Builder模式

蹲街式等待

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android设计模式之——Builder模式

一、介绍Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。因为一个复杂的对象有很多大量组成部分，例如车，有车轮、方向盘、发动机，还有各种小零件等，如何将这些部件装配成一辆汽车，这个装配过程很漫长，也很复杂，对于这种情况，为了在构建过程中对外
复制链接

扫一扫