JAVA设计模式------构建者模式

最新推荐文章于 2024-09-01 15:30:00 发布
最新推荐文章于 2024-09-01 15:30:00 发布
阅读量362 收藏
点赞数
分类专栏： java基础 文章标签： java 设计模式 build

前言：

在阅读android框架源码的时候，经常可以见到Builder（构建者模式），鉴于这些框架都在大面积的使用这个涉及模式，所以有必要来探究一下这个设计模式的奥秘。（Okhttp的Request，OkHttpClient，Glide，AlertDialog等都使用这一涉及模式）

定义：

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

UML：

这里写图片描述
在这个示意性的系统里，最终产品Product只有两个零件，即part1和part2。相应的建造方法也有两个：buildPart1()和buildPart2()、同时可以看出本模式涉及到四个角色，它们分别是：

  • 抽象建造者（Builder）角色：给 出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者 (ConcreteBuilder)角色。具体建造者类必须实现这个接口所要求的两种方法：一种是建造方法(buildPart1和 buildPart2)，另一种是返还结构方法(retrieveResult)。一般来说，产品所包含的零件数目与建造方法的数目相符。换言之，有多少 零件，就有多少相应的建造方法。

  • 具体建造者（ConcreteBuilder）角色：担任这个角色的是与应用程序紧密相关的一些类，它们在应用程序调用下创建产品的实例。这个角色要完成的任务包括：1.实现抽象建造者Builder所声明的接口，给出一步一步地完成创建产品实例的操作。2.在建造过程完成后，提供产品的实例。

  • 导演者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。应当指出的是，导演者角色并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者角色。不一定有共同的接口，而完全可以是不相关联的。导演者角色是与客户端打交道的角色。导演者将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。具体建造者角色是做具体建造工作的，但是却不为客户端所知。

    　　一般来说，每有一个产品类，就有一个相应的具体建造者类。这些产品应当有一样数目的零件，而每有一个零件就相应地在所有的建造者角色里有一个建造方法。

源代码

　产品类Product
　

public class Product {
    /**
     * 定义一些关于产品的操作
     */
    private String part1;
    private String part2;
    public String getPart1() {
        return part1;
    }
    public void setPart1(String part1) {
        this.part1 = part1;
    }
    public String getPart2() {
        return part2;
    }
    public void setPart2(String part2) {
        this.part2 = part2;
    }
}

　抽象建造者类Builder
　

public interface Builder {
    public void buildPart1();
    public void buildPart2();
    public Product retrieveResult();
}

具体建造者类ConcreteBuilder

public class ConcreteBuilder implements Builder {

    private Product product = new Product();
    /**
     * 产品零件建造方法1
     */
    @Override
    public void buildPart1() {
        //构建产品的第一个零件
 　　　　product.setPart1("编号：9527");
    }
    /**
     * 产品零件建造方法2
     */
    @Override
    public void buildPart2() {
        //构建产品的第二个零件
 　　　　product.setPart2("名称：XXX");
    }
    /**
     * 产品返还方法
     */
    @Override
    public Product retrieveResult() {
        return product;
    }

}

导演者类Director

public class Director {
    /**
     * 持有当前需要使用的建造器对象
     */
    private Builder builder;
    /**
     * 构造方法，传入建造器对象
     * @param builder 建造器对象
     */
    public Director(Builder builder){
        this.builder = builder;
    }
    /**
     * 产品构造方法，负责调用各个零件建造方法
     */
    public void construct(){
        builder.buildPart1();
        builder.buildPart2();
    }
}

客户端类Client

public class Client {
    public static void main(String[]args){
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.retrieveResult();
        System.out.println(product.getPart1());
        System.out.println(product.getPart2());
    }
}

建造模式分成两个很重要的部分：

　　1. 一个部分是Builder接口，这里是定义了如何构建各个部件，也就是知道每个部件功能如何实现，以及如何装配这些部件到产品中去；

　　2. 另外一个部分是Director，Director是知道如何组合来构建产品，也就是说Director负责整体的构建算法，而且通常是分步骤地来执行。

　　不管如何变化，建造模式都存在这么两个部分，一个部分是部件构造和产品装配，另一个部分是整体构建的算法。认识这点是很重要的，因为在建造模式中，强调的是固定整体构建的算法，而灵活扩展和切换部件的具体构造和产品装配的方式。

　　再直白点说，建造模式的重心在于分离构建算法和具体的构造实现，从而使得构建算法可以重用。具体的构造实现可以很方便地扩展和切换，从而可以灵活地组合来构造出不同的产品对象

使用建造模式构建复杂对象

　　考虑这样一个实际应用，要创建一个保险合同的对象，里面很多属性的值都有约束，要求创建出来的对象是满足这些约束规则的。约束规则比如：保险合同通常情况下可以和个人签订，也可以和某个公司签订，但是一份保险合同不能同时与个人和公司签订。这个对象里有很多类似这样的约束，采用建造模式来构建复杂的对象，通常会对建造模式进行一定的简化，因为目标明确，就是创建某个复杂对象，因此做适当简化会使程序更简洁。大致简化如下：

　　●由于是用Builder模式来创建某个对象，因此就没有必要再定义一个Builder接口，直接提供一个具体的建造者类就可以了。

　　●对于创建一个复杂的对象，可能会有很多种不同的选择和步骤，干脆去掉“导演者”，把导演者的功能和Client的功能合并起来，也就是说,Client这个时候就相当于导演者，它来指导构建器类去构建需要的复杂对象。
　　我们来看okhttp中Request的源码：（去掉了一些代码）
　　

public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final RequestBody body;
  final Object tag;

  private volatile CacheControl cacheControl; // Lazily initialized.

  Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tag = builder.tag != null ? builder.tag : this;
  }

  public HttpUrl url() {
    return url;
  }

  public String method() {
    return method;
  }

  public Headers headers() {
    return headers;
  }

  public String header(String name) {
    return headers.get(name);
  }

  public List<String> headers(String name) {
    return headers.values(name);
  }

  public RequestBody body() {
    return body;
  }

  public Object tag() {
    return tag;
  }

  public Builder newBuilder() {
    return new Builder(this);
  }


  public static class Builder {
    HttpUrl url;
    String method;
    Headers.Builder headers;
    RequestBody body;
    Object tag;

    public Builder() {
      this.method = "GET";
      this.headers = new Headers.Builder();
    }

    Builder(Request request) {
      this.url = request.url;
      this.method = request.method;
      this.body = request.body;
      this.tag = request.tag;
      this.headers = request.headers.newBuilder();
    }

    public Builder url(HttpUrl url) {
      if (url == null) throw new NullPointerException("url == null");
      this.url = url;
      return this;
    }



    /**
     * Sets the URL target of this request.
     *
     * @throws IllegalArgumentException if the scheme of {@code url} is not {@code http} or {@code
     * https}.
     */
    public Builder url(URL url) {
      if (url == null) throw new NullPointerException("url == null");
      HttpUrl parsed = HttpUrl.get(url);
      if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
      return url(parsed);
    }


    public Builder header(String name, String value) {
      headers.set(name, value);
      return this;
    }

    public Builder addHeader(String name, String value) {
      headers.add(name, value);
      return this;
    }

    public Builder removeHeader(String name) {
      headers.removeAll(name);
      return this;
    }

    /** Removes all headers on this builder and adds {@code headers}. */
    public Builder headers(Headers headers) {
      this.headers = headers.newBuilder();
      return this;
    }

    public Builder get() {
      return method("GET", null);
    }

    public Builder head() {
      return method("HEAD", null);
    }

    public Builder post(RequestBody body) {
      return method("POST", body);
    }

    public Builder delete(RequestBody body) {
      return method("DELETE", body);
    }

    public Builder delete() {
      return delete(Util.EMPTY_REQUEST);
    }

    public Builder put(RequestBody body) {
      return method("PUT", body);
    }

    public Builder patch(RequestBody body) {
      return method("PATCH", body);
    }

    public Builder method(String method, RequestBody body) {
      if (method == null) throw new NullPointerException("method == null");
      if (method.length() == 0) throw new IllegalArgumentException("method.length() == 0");
      if (body != null && !HttpMethod.permitsRequestBody(method)) {
        throw new IllegalArgumentException("method " + method + " must not have a request body.");
      }
      if (body == null && HttpMethod.requiresRequestBody(method)) {
        throw new IllegalArgumentException("method " + method + " must have a request body.");
      }
      this.method = method;
      this.body = body;
      return this;
    }

    public Builder tag(Object tag) {
      this.tag = tag;
      return this;
    }

    public Request build() {
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
    }
  }
}

在本例中将具体建造者合并到了产品对象中，并将产品对象的构造函数私有化，防止客户端不使用构建器来构建产品对象，而是直接去使用new来构建产品对象所导致的问题。另外，这个构建器的功能就是为了创建被构建的对象，完全可以不用单独一个类。
参考自《JAVA与模式》之建造模式

YOUNGEER1
关注
专栏目录
Java Builder模式（设计模式之Builder模式）
IBM_Forever
01-17 4万+
1.设计模式之终极结合 昨天项目上线（今年是没有新需求了，那提前祝大家新年快乐），上班继续最近几期博客的编写。承接上一篇博客观察者模式，这一期我们一起来了解一下Builder模式。我们最近几期博客打算主要讲一下单例模式、观察者模式、Build模式，目的是为了方便后期为大家带来RXJava+Retrofit2.0+Okhttp3结合使用的网络请求框架。 思考了一上午，我该怎么写出Builder模...
java常用设计模式-建造者模式
08-26
-java常用设计模式-建造者模式是java中的一种创建型设计模式，它允许开发者通过一步一步地构建复杂对象来创建不同类型的对象。 建造者模式的定义 建造者模式是一种创建型设计模式，它允许开发者通过一步一步地构建...
JAVA设计模式之创建者模式
Stroller
08-08 3705
概述：      Builder模式 主要用于“构建一个复杂的对象”。把复杂对象的创建过程加以抽象，通过子类继承和重写方法，来得到具有复合属性的对象。       同时为了统一创建过程，把对象的创建操作统一封装到Director的方法中。       由于一个复杂对象的
优雅的创建对象——类Builder模式
最新发布
littleschemer的博客
09-01 372
在软件工程中，建造者模式（Builder Pattern）是一种设计模式，用于构建复杂对象。这种模式将对象的构建过程与对象的表示分离，使得同样的构建过程可以创建不同的表示。本文分别对Java与Go如何构造复杂对象
Java构建者模式
cdc的博客
06-21 284
Java构建者模式 构建者模式 将一个复杂对象的构建与它的表示分离，使用同样的构建过程可以创建不同的表示。 封装在一个单独的Builder对象中创建和组装一个复杂对象的各个部分。 类将对象创建委托给Builder对象，而不是直接创建对象。 一个类（相同的构造过程）可以委托给不同的Builder对象来创建复杂对象的不同表示。 应用实例 Retrofit Retrofit的...
java构建者模式Builder
u013359807的博客
04-10 2121
定义 Builder模式是一步步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构建过程。该模式是将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离。 作为复杂对象可能有很多组成部分，比如汽车有车轮、方向盘、发动机、变速箱还有各种小零件等，如何将这些部件组装成一台汽车，这个装配的过程漫长且复杂，对于这种情况，为了对外部隐藏实现细节，就可...
Java设计模式之构建者模式
红日
04-05 1398
一、定义： 将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。 二、角色： 构建者模式的结构图如上所示，包含的角色如下： Director：导演类(指挥者)，负责安排已有模块的顺序，然后通知Builder开始建造。 Builder：抽象Builder类，规范产品的组建，一般由子类实现。 ConcreteBuilder：具体建造者，实现抽象Builder类定义的所有方法，并且返回一个组建好的对象。 Product：具体的产品类。 三、具体实现： 我们以台式机DI
Java设计模式-图解-附代码.doc
09-19
在软件工程中，设计模式是一种被广泛接受的解决特定设计问题的...因此，深入学习和理解Java设计模式对于任何Java开发者来说都是至关重要的。通过文档中的图解和代码示例，读者可以更好地理解和掌握这些模式的实际应用。
2020版23种Java设计模式-图解-附代码.pdf
09-04
Java设计模式是软件开发中的重要概念，它是一种在特定情境下解决问题的经验总结，可以提高代码的可重用性、可维护性和灵活性。本教程详细介绍了23种经典的Java设计模式，包括创建型、结构型和行为型模式。下面将对这...
参考文档-23种JAVA设计模式和15种J2EE设计模式.zip
03-28
Java设计模式是软件开发中的重要概念，它们是解决常见编程问题的经验总结，为代码复用、模块解耦、系统扩展提供了指导原则。本资源“参考文档-23种JAVA设计模式和15种J2EE设计模式.zip”包含了Java语言和J2EE平台下...
DesignPatternsJava:Java设计模式-Udemy
03-22
Java设计模式是软件开发中的重要概念，它是一种在特定情境下解决常见问题的经验总结，能够提升代码的可读性、可维护性和复用性。在Java编程中，设计模式被视为提高软件质量的关键因素，尤其在大型项目中更是不可或缺...
java之Builder模式
〆、风神的博客
05-25 253
@Data public class Student { private String id; private String name; private String sex; private int age; private String grade; private String email; private String addr; public static class Builder { // 必须初始化的属性 private String id; private.
Builder模式 初体验
weixin_30457551的博客
05-04 118
看来Java构造器模式，决定动手体验下。构造器模式是什么？干什么用的？推荐大家看下ITEYE的一篇文章http://www.iteye.com/topic/71175 了解构造器模式对于系统的重构，也是很有帮助的。例如，可以优化多构造器类的设计。首先，我先寻找一个应用场景。拿民工和设计师来写固然可以，但觉得有点类似写Hello word的感觉。学习...
java Builder模式
qq_31386985的博客
09-18 127
java Builder模式的构造
java builder模式
贾慧玉的博客
03-21 300
java builder模式主要是用一个内部类去实例化一个对象，避免一个类出现多个构造函数，并且构造函数如果出现默认参数，就比较容易出错。 不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器，得到一个builder对象，然后客户端在builder对象上调用类似于setter的方法，来设置每个相关的可选参数，最后客户端调用无参数的build方法来生成不可变的对象。 public clas...
Java Builder模式
zdj18166896501的博客
10-30 217
当类中的参数很多，并且不知道实例化对象的时候需要用到哪些参数，就需要创建很多构造器。参数每多一个就需要添加构造器，代码维护起来很不方便，可读性也很差。 使用Builder模式实例化的时候就可以有选择的为参数赋值。 package DesignPatterns.BuilderPattern; /** * @Author: zdj * @Description: 类参数很多时，实例化对象的...
Java模式应用：SCAJ-001
《SCAJ-001 JAVA PATTERNS》是Stephen Stelting和Olav Maassen合著的一本关于Java设计模式的实战指南，首次出版于2001年，旨在帮助开发者充分利用设计模式构建更强大、可扩展、可靠且易于维护的应用程序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值