Loading...
墨滴

楼仔

2021/07/16  阅读:50  主题:橙心

【设计模式系列3】builder模式

主要讲解建造者builder模式和实际应用的场景,基于java。

前言

讲解这个模式前,我先吐槽一下,我一开始是通过菜鸟教程了解这个设计模式,但是我发现,里面完全照本宣科!看得我一头雾水!!看完后我居然还是不知道怎么使用!!!我看设计模式,是为了想应用到具体的场景,不信大家可以去到菜鸟教程上看,然后我的例子中,也会展示菜鸟教程中的示例。

我们先看一下建造者builder的解释:

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

但是看完这个定义,并没有什么卵用,你依然不知道什么是Builder设计模式。在此个人的态度是学习设计模式这种东西,不要过度在意其定义,定义往往是比较抽象的,学习它最好的例子就是通过样例代码。

最low方法

我们通过一个例子来引出Builder模式。我们需要通过builder模式构建企鹅对象penguin,企鹅有很多属性,比如姓名、年龄、性别和身高,该类的定义如下:

public class penguin {
    private String  name;
    private Integer age;
    private String  sex;
    private Integer heignt;

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    };
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void setHeignt(Integer heignt) {
        this.heignt = heignt;
    };
    public void print() {
        String str = "name:" + name;
        str += (age == null) ? "" : ",age:" + age;
        str += (sex == null) ? "" : ",sex:" + sex;
        str += (heignt == null) ? "" : ",age:" + heignt;
        System.out.println(str);
    }
}

为了构建不同属性特性的企鹅,我们通常会这么写构造器:

    public penguin(String name) {
        this.name = name;
    }
    public penguin(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public penguin(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public penguin(String name, Integer age, String sex, Integer heignt) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.heignt = heignt;
    }

然后开始去初始化自己想要的企鹅对象:

public static void main(String[] args) {
    penguin penguin1 = new penguin("楼仔");
    penguin penguin2 = new penguin("楼仔"18);
    penguin penguin3 = new penguin("楼仔"18"男");
    penguin penguin4 = new penguin("楼仔"18"男"180);
    penguin1.print();
    penguin2.print();
    penguin3.print();
    penguin4.print();
}

输出结果为:

name:楼仔
name:楼仔,age:18
name:楼仔,age:18,sex:男
name:楼仔,age:18,sex:男,age:180

这种方式比较常规,但是如果我只想初始化name和hight,你可能还需要再新增新的构造器,不过有的同学可能会说“我才不用构造器初始化对象,我可以用类提供的setxxx()来设置对应的属性值”,但是这种做法不会觉得很冗余么,每个属性都用setxxx()设置一下,如果有十几个属性值,你是不是要用setxxx()全部设置一遍呢?

这时候如果换一个角度,试试Builder模式,你会发现代码的可读性一下子就上去了。

builder模式

我们给penguin增加一个静态内部类penguinBuilder类,并修改penguin类的构造函数,代码如下:

public class penguin {
    private String  name;
    private Integer age;
    private String  sex;
    private Integer heignt;

    public void print() {
        String str = "name:" + name;
        str += (age == null) ? "" : ",age:" + age;
        str += (sex == null) ? "" : ",sex:" + sex;
        str += (heignt == null) ? "" : ",age:" + heignt;
        System.out.println(str);
    }
    public penguin(penguinBuilder builder) {
        this.age = builder.age;
        this.name = builder.name;
        this.sex = builder.sex;
        this.heignt = builder.heignt;
    }
    public static class penguinBuilder {
        private String  name;
        private Integer age;
        private String  sex;
        private Integer heignt;

        public penguinBuilder setName(String name) {
            this.name = name;
            return this;
        }
        public penguinBuilder setAge(Integer age) {
            this.age = age;
            return this;
        }
        public penguinBuilder setSex(String sex) {
            this.sex = sex;
            return this;
        }
        public penguinBuilder setHeignt(Integer heignt) {
            this.heignt = heignt;
            return this;
        }
        public penguin bulid() {
            return new penguin(this);
        }
    }
}

这样,我们就不会被penguin类构造函数的各个入参搞得稀里糊涂了。 此外penguinBuilder类中的成员函数返回penguinBuilder对象自身,让它支持链式调用,使代码可读性大大增强。于是我们就可以这样创建penguin类。

public static void main(String[] args) {
    penguin penguin1 = 
    new penguin.penguinBuilder().setName("楼仔").
                                  setSex("男").
                                  setHeignt(170).
                                  setAge(18).
                                  bulid();
    penguin penguin2 = 
    new penguin.penguinBuilder().setName("楼仔").
                                  setAge(18).
                                  bulid();                                            
    penguin1.print();
    penguin2.print();
}

有没有觉得创建过程一下子就变得那么清晰了,对应的值是什么属性一目了然,可读性大大增强,输出如下:

name:楼仔,age:18,sex:男,age:170
name:楼仔,age:18

综上,我们总结一下build模式的要点:

  1. 定义一个静态内部类Builder,内部的成员变量和外部类一样;
  2. Builder类通过一系列的方法用于成员变量的赋值,并返回当前对象本身(this);
  3. Builder类提供一个外部类的创建方法(build、create……),该方法内部调用了外部类的一个私有构造函数,入参就是内部类Builder;
  4. 外部类提供一个私有构造函数供内部类调用,在该构造函数中完成成员变量的赋值,取值为Builder对象中对应的成变量的值。

吐槽的方法

这个其实是最标准的builder模式,也是菜鸟教程展示的示例,我的示例和他基本上异曲同工,我只是拿出来吐槽,不推荐大家使用,仅了解即可。

这个是菜鸟画的图,其实原理和上面讲的都一样,唯一的区别就是多了一个Director,这个Director是干啥用的呢,其实就是把组建对象的过程,都放到这里面实现,文字不好理解,我们直接看代码:

public class penguin {
    private String  name;
    private Integer age;
    private String  sex;
    private Integer heignt;

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    };
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void setHeignt(Integer heignt) {
        this.heignt = heignt;
    };
    public static class penguinBuilder {
        // 这里初始化penguin对象
        private penguin m_penguin = new penguin();
        public penguinBuilder setName(String name) {
            this.m_penguin.setName(name);
            return this;
        }
        public penguinBuilder setAge(Integer age) {
            this.m_penguin.setAge(age);
            return this;
        }
        public penguinBuilder setSex(String sex) {
            this.m_penguin.setSex(sex);
            return this;
        }
        public penguinBuilder setHeignt(Integer heignt) {
            this.m_penguin.setHeignt(heignt);
            return this;
        }
        public penguin bulid() {
            return this.m_penguin;
        }
    }
}

下面就是标准builder的重点,多了Director:

public class director {
    penguin.penguinBuilder m_builder;
    public director(penguin.penguinBuilder build) {
        this.m_builder = build;
    }
    public penguin construct(String name, Integer age, String sex, Integer height) {
        return this.m_builder.setAge(age).
                setHeignt(height).
                setName(name).
                setSex(sex).
                bulid();
    }
}

所以这个Director其实就是将builder作为对象成员,然后通过builder在Director中去构造对象,示例只是构造方式的一种,你也可以通过你自己的方式,去定制化这个penguin的构造。所以你可以理解,标准的builder是把penguin的构造放入Director中,非标准的就是直接在builder中直接构造penguin对象。最后的使用姿势如下:

public static void main(String[] args) {
    penguin.penguinBuilder builder = new penguin.penguinBuilder();
    director penguinDirector = new director(builder);
    penguin penguin1 =  penguinDirector.construct("楼仔"18,"男" , 170);
    penguin1.print();
}

这个就是菜鸟给我的示例,然后按照这种方式给我讲解builder模式,然后我居然还看到网上有同学,把这个模式按照菜鸟的讲解,自己实现了一遍,然后给大家讲解builder,如果大家对builder模式停留在这里,我敢肯定,下次代码需要重构时,你绝对不会想到用builder模式去优化你的代码。

相反,我直接通过非Director的方式实现builder模式,然后支持链式调用,这个才能真实解决我的问题。所以,设计模式不是死记硬背,引用同事告知的一句话:

不迷信设计模式,借鉴思想,好用最重要!

实际场景

这个很多场景都会使用,也就是当你需要初始化一个对象,但是对象里面有一堆成员变量,比如有10个左右,你如果给每个成员调用set方法去赋值,代码可读性就太差了,这时可以采用builder模式,让这些成员的赋值通过链式的方式去set值,然后通过bulider去生成一个完整的对象。

后记

之前看大牛用链式方式赋值成员变量,感觉很神奇,我相信我写完这篇文章之后,我以后也能很轻松写这种模式的代码。其实每写完一篇设计模式的文章,感觉收获很多,后面我还会把其它常用的设计模式写出来,总共预计写完8-10个常用的,我觉得就差不多了,也希望大家能跟着我,一起共同成长!

欢迎大家多多点赞,更多文章,请关注微信公众号“楼仔进阶之路”,点关注,不迷路~~

楼仔

2021/07/16  阅读:50  主题:橙心

作者介绍

楼仔