Java设计模式笔记之Builder模式

目录
  • Builder模式是怎么来的
  • 关于Builder的一点说明
    • 线程安全问题
  • 经典的Builder模式
  • 总结

当我第一次使用Picasso的时候,看见下面的官网示例时,我和我的小伙伴都惊呆了!

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

如此简洁明了的使用方式,如此灵活多变的链式调用,让我深深地迷住了,然后我一直苦苦追求它,奈何天资愚笨,不知如何掀起它的神秘面纱...

不好意思,中二病又犯了,重来一遍。经过不懈的努力,终于发现它就是传说中的Builder(建造者)模式,并学会了如何与它亲密相处。

Builder模式是怎么来的

不知道是哪位贤人曾经说过,存在即为合理。Builder模式在众多的框架以及android原生代码中存在(比如AlertDialog),就一定有其价值,用来解决某些需求。

考虑这样一个场景,假如有一个类(****User****),里面有很多属性,并且你希望这些类的属性都是不可变的(final),就像下面的代码:

public class User {
    private final String firstName;     // 必传参数
    private final String lastName;      // 必传参数
    private final int age;              // 可选参数
    private final String phone;         // 可选参数
    private final String address;       // 可选参数
}

在这个类中,有些参数是必要的,而有些参数是非必要的。就好比在注册用户时,用户的姓和名是必填的,而年龄、手机号和家庭地址等是非必需的。那么问题就来了,如何创建这个类的对象呢?

一种可行的方案就是实用构造方法。第一个构造方法只包含两个必需的参数,第二个构造方法中,增加一个可选参数,第三个构造方法中再增加一个可选参数,依次类推,直到构造方法中包含了所有的参数。

    public User(String firstName, String lastName) {
        this(firstName, lastName, 0);
    }

    public User(String firstName, String lastName, int age) {
        this(firstName, lastName, age, "");
    }

    public User(String firstName, String lastName, int age, String phone) {
        this(firstName, lastName, age, phone, "");
    }

    public User(String firstName, String lastName, int age, String phone, String address) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.phone = phone;
        this.address = address;
    }

这样做的好处只有一个:可以成功运行。但是弊端很明显:

  • 参数较少的时候问题还不大,一旦参数多了,代码可读性就很差,并且难以维护。
  • 对调用者来说也很麻烦。如果我只想多传一个address参数,还必需给age、phone设置默认值。而且调用者还会有这样的困惑:我怎么知道第四个String类型的参数该传address还是phone?

第二种解决办法就出现了,我们同样可以根据JavaBean的习惯,设置一个空参数的构造方法,然后为每一个属性设置setters和getters方法。就像下面一样:

public class User {
    private String firstName;     // 必传参数
    private String lastName;      // 必传参数
    private int age;              // 可选参数
    private String phone;         // 可选参数
    private String address;       // 可选参数

    public User() {
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getPhone() {
        return phone;
    }

    public String getAddress() {
        return address;
    }
}

这种方法看起来可读性不错,而且易于维护。作为调用者,创建一个空的对象,然后只需传入我感兴趣的参数。那么缺点呢?也有两点:

  • 对象会产生不一致的状态。当你想要传入5个参数的时候,你必需将所有的setXX方法调用完成之后才行。然而一部分的调用者看到了这个对象后,以为这个对象已经创建完毕,就直接食用了,其实User对象并没有创建完成。
  • ****User****类是可变的了,不可变类所有好处都不复存在。

终于轮到主角上场的时候了,利用Builder模式,我们可以解决上面的问题,代码如下:

public class User {
    private final String firstName;     // 必传参数
    private final String lastName;      // 必传参数
    private final int age;              // 可选参数
    private final String phone;         // 可选参数
    private final String address;       // 可选参数

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getPhone() {
        return phone;
    }

    public String getAddress() {
        return address;
    }

    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age;
        private String phone;
        private String address;

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

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

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

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

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

有几个重要的地方需要强调一下:

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

相比于前面两种方法,Builder模式拥有其所有的优点,而没有上述方法中的缺点。客户端的代码更容易写,并且更重要的是,可读性非常好。唯一可能存在的问题就是会产生多余的Builder对象,消耗内存。然而大多数情况下我们的Builder内部类使用的是静态修饰的(static),所以这个问题也没多大关系。

现在,让我们看看如何创建一个User对象呢?

new User.UserBuilder("王", "小二")
                .age(20)
                .phone("123456789")
                .address("亚特兰蒂斯大陆")
                .build();

相当整洁,不是吗?你甚至可以用一行代码完成对象的创建。

关于Builder的一点说明

线程安全问题

由于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模式

上面介绍的Builder模式当然不是“原生态”的啦,经典的Builder模式的类图如下:

builder

其中:

  • Product 产品抽象类。
  • Builder 抽象的Builder类。
  • ConcretBuilder 具体的Builder类。
  • Director 同一组装过程。

当然,之前实例中的Builder模式,是省略掉了Director的,这样结构更加简单。所以在很多框架源码中,涉及到Builder模式时,大多都不是经典GOF的Builder模式,而是省略后的。

总结

到此这篇关于Java设计模式笔记之Builder模式的文章就介绍到这了,更多相关Java设计模式Builder模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java Builder模式实现原理及优缺点解析

    Builder 模式中文叫作建造者模式,又叫生成器模式,它属于对象创建型模式,是将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.建造者模式是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节.下图是建造者模式的通用类图: 在建造者模式中,有如下4种角色: Product:产品角色 Builder:抽象建造者,定义产品接口 ConcreteBuilder:具体建造者,实现Builder定义的接口,并且返回组

  • Java设计模式之建造者模式(Builder模式)介绍

    Builder模式定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到. 为何使用建造者模式 是为了将构建复杂对象的过程和它的部件解耦.注意:是解耦过程和部件. 因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮.方向盘.发动机,还

  • Java设计中的Builder模式的介绍

    概述 Builder模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 使用场景 相同的方法,不同的执行顺序,产生不同的事件结果 多个部件或零件,都可以装配到一个对象中,但产生的运行结果又不相同时 产品类非常复杂,或者产品类中的调用顺序不同产生不同的作用 当初始化一个对象特别复杂,如参数多,且很多参数都具有默认值时 下面从一个Person例子进行分析重叠构造器模式.JavaBeans模式.Builder模式的使用.Person类有两个必要参数(id和name),有5

  • Android中用Builder模式自定义Dialog的方法

    前言 我们开发人员在实际项目过程中遇到的需求是多种多样的,有时我们要匹配APP自己的设计风格,有时我们会觉得系统的对话框使用起来不够自由,因此自己定义一个适合自己的Dialog是很有必要的. 为什么要用Builder模式 Builder设计模式是一步步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细地控制对象的构造流程.它的优点就在于将对象的构建和表示分离从而解耦.我们都知道Android系统自身的对话框如AlertDialog就采用了Builder模式,因此可见

  • Java中Builder模式的实现详解

    前言 本文主要给大家介绍了关于如何实现Builder模式,大家在构建大对象时,对象的属性比较多,我们可以采用一个构造器或者使用空的构造器构造,然后使用setter方法去设置.在使用者使用这些方法时,会很多冗长的构造器参数列表或者setter方法.我们可以使用Builder模式来简化大对象的构造,提高代码的简洁性,同时提高使用者的编码体验. 下面我们将介绍在Java8之前.使用极简代码利器Lombok.Java8之后的Builder模式. Pre Java8 我们先来看下在Java8之前的Buil

  • Java Builder模式构建MAP/LIST的实例讲解

    我们在构建一个MAP时,要不停的调用put,有时候看着觉得很麻烦,刚好,看了下builder模式,觉得这思路不错,于是乎,照着用builder模式写了一个构建MAP的示例, 代码如下: import java.util.HashMap; import java.util.Map; public class MapBuilder<T> { public Builder<T> b; public MapBuilder(Builder<T> b){ this.b = b; }

  • Java设计模式笔记之Builder模式

    目录 Builder模式是怎么来的 关于Builder的一点说明 线程安全问题 经典的Builder模式 总结 当我第一次使用Picasso的时候,看见下面的官网示例时,我和我的小伙伴都惊呆了! Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView); 如此简洁明了的使用方式,如此灵活多变的链式调用,让我深深地迷住了,然后我一直苦苦追求它,奈何天资愚笨,不知如何掀起它的神秘面纱... 不好

  • java设计模式笔记之代理模式

    代理(Proxy)模式: 代理模式是对象的结构模式.代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用. 核心作用: 通过代理,控制对对象的访问. 可以详细控制访问某个(某类)对象的方法,在调用这个方法之前做前置处理,在调用这个方法之后做后置处理.即AOP的微观实现. AOP(Aspect Oriented Programming面向切面编程)的核心实现机制. 生活中的场景: 所谓代理,就是一个人或者机构代表另一个人或者机构采取行动.在一些情况下,一个客户不想或者不能够直接引用

  • Java设计模式笔记之抽象工厂代码示例

    上一篇说到了工厂模式,那么学习了工厂模式,抽象工厂也得学习一下.实际上,抽象工厂模式实际上就是在工厂模式的基础上再嵌套一层工厂模式而已,通过父工厂制造子工厂.只是,也并不完全是嵌套一层,各个工厂会被抽象成一个集多个工厂共同点的抽象类.通过工厂制造器,创建出该抽象工厂的子类. 好比如说,一个博客页面有个换肤系统.那么假如有两套风格,黑和白.那么,我选择了黑色风格的,实际这步就相当通过换肤系统这个工厂制造器,创建出一个黑色主题的工厂,该黑色主题的工厂内可以生产各种黑色风格的产品,比如黑色头像挂饰,黑

  • 快速理解Java设计模式中的组合模式

    组合模式是一种常见的设计模式(但我感觉有点复杂)也叫合成模式,有时又叫做部分-整体模式,主要是用来描述部分与整体的关系. 个人理解:组合模式就是将部分组装成整体. 定义如下: 将对象组合成树形结构以表示"部分-整体"的层次结构,使得用户对单个对象和组合对象的使用具有一致性. 通用类图如下: 组合模式的包含角色: ● Component 抽象构件角色 定义参加组合对象的共有方法和属性,可以定义一些默认的行为或属性. ● Leaf 叶子构件 叶子对象,其下再也没有其他的分支,也就是遍历的最

  • 一文搞懂Java设计模式之责任链模式

    简述: 前端时间再看一些类库的源码,发现责任链模式的强大之处,尤其是和建造者模式的结合后强大的动态可扩展性更是牛逼的一塌糊涂.接下来赶紧了解一下吧! 我们先来了解一下什么是责任链模式: 职责链模式(Chain of Responsibility):使多个对象都有机会处理同一个请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. 应用场景: 为完成同一个请求,如果存在多个请求处理器以及未知请求处理器个数或者请求处理器可动态配置的

  • Java设计模式之构建者模式知识总结

    一.构建者模式 1.1 定义 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 1.2 主要作用 在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象. 用户只需要给出指定复杂对象的类型和内容: 建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来) 1.3 解决的问题 方便用户创建复杂的对象(不需要知道实现过程) 代码复用性 & 封装性(将对象构建过程和细节进行封装 & 复用) 例子:造汽车 & 买汽车. 工厂(建造者模式):负责制

  • Java设计模式之责任链模式的示例详解

    目录 应用场景 实际代码案例 无模式情况下的代码 采用责任链模式优化代码 采用建造者+责任链模式优化代码 责任链模式优缺点 责任链模式是将链中的每一个节点看做是一个对象,每个节点处理的请求均不相同,且内部自动维护下一个节点对象,当一个请求从链式的首段发出时,会沿着链的路径依次传递给每一个节点对象,直至有对象处理这个请求位置,属于行为模式. 这里需要注意的是每个节点都能对对象进行一定的处理(也可以不处理),处理完成之后节点再进行判断还要进行后续处理还是说传递给下一个节点. 应用场景 首先举一个日常

  • java 设计模式之State(状态模式)

    java 设计模式之State(状态模式) 在状态模式中,一个类的行为基于它的状态的改变而改变.状态模式归属于行为型模式. 在下面的实例中,我们创建了一个接口State,定义了一个操作方法,两个实现类StartState和StopState.另外,创建了一个上下文类Context,这个类关联到State类.UML类图如下所示: //状态类 public interface State { public void doAction(Context context); } //实现类StartSta

  • Java设计模式之中介者模式(Mediator Pattern)简介

    Java设计模式的中介者模式是行为模式之一.定义一个中介对象来封装系列对象之间的交互.中介者使各个对象不需要显式地相互引用,从而使其耦合性松散,并且可以独立地改变他们之间的交互. 如下图所示: 生产者.消费者.代理商之间的中介模式实例: public abstract class PersonColleague { protected Mediator mediator; public Mediator getMediator() { return mediator; } public void

  • Java设计模式之工厂方法模式实例简析

    本文实例讲述了Java设计模式之工厂方法模式.分享给大家供大家参考,具体如下: 工厂方法模式使用的频率非常高,在我们日常的开发中总能遇见到它的身影.其定义为:Define an interface for creating an object, but let subclass decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.(定义一个用于创建对象的接口

随机推荐