当前位置：移动技术网 > IT编程>软件设计>设计模式 > Java Builder 模式,你搞明白了么？

Java Builder 模式,你搞明白了么？

2019年09月03日 | 移动技术网IT编程 | 我要评论

builder 模式定义

builder 模式中文叫作建造者模式，又叫生成器模式，它属于对象创建型模式，是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。下图是建造者模式的通用类图：
建造者模式uml图
在建造者模式中，有如下４种角色：

product：产品角色
builder：抽象建造者，定义产品接口
concretebuilder：具体建造者，实现builder定义的接口，并且返回组装好的产品
director：指挥者，属于这里面的老大，你需要生产什么产品都直接找它。

建造者模式应用举例

家装

家装不管是精装还是简装，它的流程都相对固定，所以它适用于建造者模式。我们就以家装为例，一起来学习了解一下建造者模式。下图是家装建造者模式简单的 uml 图。

家装建造者模式简单的 uml 图

1、家装对象类

/**
 * 家装对象类
 */
public class house {
    // 买家电
    private string jiadian;

    // 买地板
    private string diban;
    // 买油漆
    private string youqi;

    public string getjiadian() {
        return jiadian;
    }

    public void setjiadian(string jiadian) {
        this.jiadian = jiadian;
    }

    public string getdiban() {
        return diban;
    }

    public void setdiban(string diban) {
        this.diban = diban;
    }

    public string getyouqi() {
        return youqi;
    }

    public void setyouqi(string youqi) {
        this.youqi = youqi;
    }

    @override
    public string tostring() {
        return "house{" +
                "jiadian='" + jiadian + '\'' +
                ", diban='" + diban + '\'' +
                ", youqi='" + youqi + '\'' +
                '}';
    }
}

2、抽象建造者 builder 类

/**
 * 抽象建造者
 */
public interface housebuilder {
    // 买家电
    void dojiadian();
    // 买地板
    void dodiban();
    // 买油漆
    void doyouqi();

    house gethouse();
}

3、具体建造者－简装建造者类

/**
 * 简装创建者
 */
public class jianzhuangbuilder implements housebuilder {

    private house house = new house();

    @override
    public void dojiadian() {
        house.setjiadian("简单家电就好");
    }

    @override
    public void dodiban() {
        house.setdiban("普通地板");
    }

    @override
    public void doyouqi() {
        house.setyouqi("污染较小的油漆就行");
    }

    @override
    public house gethouse() {
        return house;
    }
}

4、具体建造者－精装建造者类

/**
 * 精装创建者
 */
public class jingzhuangbuilder implements housebuilder {

    private house house = new house();

    @override
    public void dojiadian() {
        house.setjiadian("二话不说，最好的");
    }

    @override
    public void dodiban() {
        house.setdiban("二话不说，实木地板");
    }

    @override
    public void doyouqi() {
        house.setyouqi("二话不说，给我来0污染的");
    }

    @override
    public house gethouse() {
        return house;
    }
}

5、指挥官－家装公司类

/**
 * 家装公司，值需要告诉他精装还是简装
 */
public class housedirector {

    public house builder(housebuilder housebuilder){
        housebuilder.dodiban();
        housebuilder.dojiadian();
        housebuilder.doyouqi();
        return housebuilder.gethouse();
    }
}

6、测试

public class app {
    public static void main(string[] args) {
        house();
    }

    public static void house(){
        housedirector housedirector = new housedirector();
        // 简装
        jianzhuangbuilder jianzhuangbuilder = new jianzhuangbuilder();
        system.out.println("我要简装");
        system.out.println(housedirector.builder(jianzhuangbuilder));

        // 精装
        jingzhuangbuilder jingzhuangbuilder = new jingzhuangbuilder();
        system.out.println("我要精装");
        system.out.println(housedirector.builder(jingzhuangbuilder));

    }
}

输出结果

测试结果

我们以家装为例，实现了两个具体的建造者，一个简装建造者、一个精装建造者。我们只需要告诉家装公司，我是需要简装还是精装，他会去帮我们安排，我不需要知道里面具体的细节。怎么样，建造者模式学回了吗？

对象构建

在日常开发中，你是不是会经常看到下面这种代码:

return new docket(documentationtype.swagger_2)
        .apiinfo(apiinfo())
        .select()
        .apis(requesthandlerselectors.basepackage("com.curry.springbootswagger.controller"))
        .paths(pathselectors.any())
        .build();

是不是很优美？学会了 builder 模式之后，你也可以通过这种方式进行对象构建。它是通过变种的 builder 模式实现的。先不解释了，我们先用 builder 模式来实现跟上述的对象构建，使用学生类为例。

学生对象代码：

public class student {

    private string name;

    private int age;

    private int num;

    private string email;

    // 提供一个静态builder方法
    public static student.builder builder() {
        return new student.builder();
    }
    // 外部调用builder类的属性接口进行设值。
    public static class builder{
        private string name;

        private int age;

        private int num;

        private string email;

        public builder name(string name) {
            this.name = name;
            return this;
        }

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

        public builder num(int num) {
            this.num = num;
            return this;
        }

        public builder email(string email) {
            this.email = email;
            return this;
        }

        public student build() {
            // 将builder对象传入到学生构造函数
            return new student(this);
        }
    }
    // 私有化构造器
    private student(builder builder) {
        name = builder.name;
        age = builder.age;
        num = builder.num;
        email = builder.email;
    }

    @override
    public string tostring() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", num=" + num +
                ", email='" + email + '\'' +
                '}';
    }
}

调用代码：

    public static void student(){
        student student = student.builder().name("平头哥").num(1).age(18).email("平头哥@163.com").build();
        system.out.println(student);
    }

可以看到，变种 builder 模式包括以下内容：

在要构建的类内部创建一个静态内部类 builder
静态内部类的参数与构建类一致
构建类的构造参数是静态内部类，使用静态内部类的变量一一赋值给构建类
静态内部类提供参数的 setter 方法，并且返回值是当前 builder 对象
最终提供一个 build 方法构建一个构建类的对象，参数是当前 builder 对象

可能你会说，这种写法实现太麻烦了，确实需要我们写很多额外的代码，好在前辈们已经开发出了lombok来拯救我们，我们只需要引入lombok插件，然后在实体类上添加@builder注解，你就可以实用 builder 模式构建对象了。

建造者模式的优缺点

优点

在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”

缺点

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

文章不足之处，望大家多多指点，共同学习，共同进步

最后

打个小广告，欢迎扫码关注微信公众号：「平头哥的技术博文」，一起进步吧。

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

十分钟学会设计模式（一）：单例模式

设计模式（一）：单例模式单例模式（Singleton Pattern）：无法直接new对象，只能通过该类提供的全... [阅读全文]
Flume面试题

文章目录什么是flume？基本架构SourceChannelSink拦截器选择器负载均衡与故障转移什么是flum... [阅读全文]
设计模式之状态

一.简介程序设计中有些对象是有状态的对象。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行... [阅读全文]
工厂设计(Factory)----设计模式

设计模式----工厂设计模式(Factory)文章目录设计模式----工厂设计模式(Factory)什么是工厂设... [阅读全文]
【面试题】研究过tomcat的NioEndpoint源码吗？请阐述下Reactor多线程模型在tomcat中的实现。

tomcat的底层网络NIO通信基于主从Reactor多线程模型。它有三大线程组分别用于处理不同的逻辑：Acce... [阅读全文]
什么是soa

SOA:面向服务的软件架构（Service Oriented Architecture）,是一种计算机软件的设计... [阅读全文]
安卓实战之如何快速搭建app架构

前言最近公司的另一个项目又要立项了，作为公司的唯一安卓工程师任务来了（新来的移动端的老大说项目还是主要你负责，我... [阅读全文]
荐厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略

前言根据百度指数搜索“中台”，可以发现中台这个概念从2019年5月21日起突然火了起来，并持续火爆。如果对201... [阅读全文]
Rabbit MQ 集群架构下的几种模式

Rabbit MQ 集群架构下的几种模式1、主备模式1、主备模式主备模式 :实现 RabbitMQ 的高可用集群... [阅读全文]
设计模式（一）之七大原则

文章目录单一职责原则接口隔离原则依赖倒转原则里氏替换原则开闭原则迪米特法则合成复用原则单一职责原则一个类只负责一... [阅读全文]