设计模式：创建者模式（链式调用）

我们日常会遇到一些问题，比如一个对象有很多属性，比如订单，有很多属性订单号，订单日期，订单用户姓名，订单状态啥的，我们要构建一个这个样的对象，要不断的去set，get 如下：

public class Order {
    private String orderNo;

    private Long orderId;

    private LocalDate confirmDate;

    private String templateId;

    private Integer orderStatus;
    }

在不考虑什么设计模式的情况下，这种“繁琐”的塞值怎么办，一种是创建带参数的构造函数，一种是找个别的类做转换直接转换过去。

创建带参数的构造函数时会遇到参数太多，这个函数很长看起来很不友好的情况,而且会遇到我有时候创建需要三个，有时候需要两个参数，要不然就赋予参数的值的时候，直接就按最长的来，大不了用不到的位置给个null，但是总之还是很不灵活。

一般来说，我们超过三个参数，就觉得方法参数过多设计的入参不友好。

public order(String orderNo,Long orderId,LocalDate confirmDate, String templateId,Integer orderStatus){
  //todo
}

转换那个，也就平时传参的时候VO转DO会这样，但是VO实际上也是要塞值的。

那问题来了，有没有一种方法，能像我们的linux的管道命令一样，给一个对象赋值这样：

new Order().XXX().XXX().XXX()

当然有，如果你用过都多的第三方组件，不管是接口API还是那种RPC或者其他网络调用，都会有类似的

//这是webclient的一个链式调用的
ShoppingCart checkoutInfo = webClientBuilder.build()
        .post()
        .uri("http://coupon-calculation-serv/calculator/checkout")
        .bodyValue(order)
        .retrieve()
        .bodyToMono(ShoppingCart.class)
        .block();

我们可不可以也搞一个这样的代码呢，这种模式是什么？

简单（常见的）创建者模式

答案肯定是没问题，我们首先来个简单的，这种很常见在我们第三方API或者分页插件的Page设计。

比如这个PageVO的设计

public class PageVO<T> implements Serializable {
    private static final long serialVersionUID = 34234234234985L;
    @JsonSerialize(
        using = LongSerializer.class
    )
    private long total;
    @JsonSerialize(
        using = LongSerializer.class
    )
    private long pageSize;
    @JsonSerialize(
        using = LongSerializer.class
    )
    private long pageCount;
    @JsonSerialize(
        using = LongSerializer.class
    )
    private long pageNum;
    private boolean isHasNextPage;
    private boolean isHasPreviousPage;
    private List<T> list;

    private void build(long pageSize, long pageNum, long total, long pageCount, List<?> records, Class<T> clazz) {
        this.pageSize = pageSize;
        this.pageNum = pageNum;
        this.total = total;
        this.pageCount = pageCount;
        this.isHasNextPage = pageCount > pageNum;
        this.isHasPreviousPage = pageNum != 1L;
        List<T> list = EntityConverter.convertList(records, clazz);
        this.list = list;
    }

    private void build(long pageSize, long pageNum, long total, long pageCount, List<T> records) {
        this.pageSize = pageSize;
        this.pageNum = pageNum;
        this.total = total;
        this.pageCount = pageCount;
        this.isHasNextPage = pageCount > pageNum;
        this.isHasPreviousPage = pageNum != 1L;
        this.list = records;
    }

    private void build(long pageSize, long pageNum, long total, List<?> records, Class<T> clazz) {
        this.pageSize = pageSize;
        this.pageNum = pageNum;
        this.total = total;
        this.setPageCount();
        this.isHasNextPage = this.pageCount > pageNum;
        this.isHasPreviousPage = pageNum != 1L;
        List<T> list = EntityConverter.convertList(records, clazz);
        this.list = list;
    }

    private void build(long pageSize, long pageNum, long total, List<T> records) {
        this.pageSize = pageSize;
        this.pageNum = pageNum;
        this.total = total;
        this.setPageCount();
        this.isHasNextPage = this.pageCount > pageNum;
        this.isHasPreviousPage = pageNum != 1L;
        this.list = records;
    }

    public PageVO(IPage<?> iPage, Class<T> clazz) {
        this.build(iPage.getSize(), iPage.getCurrent(), iPage.getTotal(), iPage.getPages(), iPage.getRecords(), clazz);
    }

    public PageVO(IPage<T> iPage) {
        this.build(iPage.getSize(), iPage.getCurrent(), iPage.getTotal(), iPage.getPages(), iPage.getRecords());
    }

    public PageVO(PageQuery pageQuery, long total, List<?> records, Class<T> clazz) {
        this.build(pageQuery.getPageSize(), pageQuery.getPageNum(), total, records, clazz);
    }

    public PageVO(PageQuery pageQuery, long total, List<T> records) {
        this.build(pageQuery.getPageSize(), pageQuery.getPageNum(), total, records);
    }

    public PageVO(long pageSize, long pageNum, long total, List<T> records, Class<T> clazz) {
        this.build(pageSize, pageNum, total, records, clazz);
    }

    public PageVO(long pageSize, long pageNum, long total, List<T> records) {
        this.build(pageSize, pageNum, total, records);
    }

    private void setPageCount() {
        if (this.total == 0L) {
            this.pageCount = 0L;
        } else {
            long i = this.total % this.pageSize;
            long count = this.total / this.pageSize;
            this.pageCount = i == 0L ? count : count + 1L;
        }

    }

    public PageVO() {
    }

    public long getTotal() {
        return this.total;
    }

    public void setTotal(long total) {
        this.total = total;
    }

    public long getPageSize() {
        return this.pageSize;
    }

    public void setPageSize(long pageSize) {
        this.pageSize = pageSize;
    }

    public long getPageCount() {
        return this.pageCount;
    }

    public void setPageCount(long pageCount) {
        this.pageCount = pageCount;
    }

    public long getPageNum() {
        return this.pageNum;
    }

    public void setPageNum(long pageNum) {
        this.pageNum = pageNum;
    }

    public boolean isHasNextPage() {
        return this.isHasNextPage;
    }

    public void setHasNextPage(boolean hasNextPage) {
        this.isHasNextPage = hasNextPage;
    }

    public boolean isHasPreviousPage() {
        return this.isHasPreviousPage;
    }

    public void setHasPreviousPage(boolean hasPreviousPage) {
        this.isHasPreviousPage = hasPreviousPage;
    }

    public List<T> getList() {
        return this.list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }
}

当然感觉有点看不动，参数有点多看一下我的一个简单的关于订单的demo

package com.example.test.builder;

import lombok.Data;

import java.time.LocalDate;

/**
 * @Author: zhangpeng
 * @Description:构建者模式
 * @Date: 2022/5/19
 */
@Data
public class Order {

    private String orderNo;

    private Long orderId;

    private LocalDate confirmDate;

    private String templateId;

    private Integer orderStatus;

    public static class Builder{

        private String orderNo;

        private Long orderId;

        private LocalDate confirmDate;

        private String templateId;

        private Integer orderStatus;

        public Builder(){

        }

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

        public Builder setOrderNo(String orderNo){
            this.orderNo = orderNo;
            return this;
        }

        public Builder setOrderId(Long orderId){
            this.orderId = orderId;
            return this;
        }

        public Builder setConfirmDate(LocalDate localDate){
            this.confirmDate = localDate;
            return this;
        }

        public Builder setTemplateId(String templateId){
            this.templateId = templateId;
            return this;
        }

        public Builder setOrderStatus(Integer orderStatus){
            this.orderStatus = orderStatus;
            return this;
        }
    }

    private Order(Builder builder){
        this.orderId = builder.orderId;
        this.orderNo = builder.orderNo;
        this.confirmDate = builder.confirmDate;
        this.templateId = builder.templateId;
        this.orderStatus = builder.orderStatus;
    }
}

他的简单使用

/**
 * @Author: zhangpeng
 * @Description:
 * @Date: 2022/5/19
 */
public class OrderTest {
    public static void main(String[] args) {
        OrderTest test = new OrderTest();
        Order order = new Order.Builder().setOrderNo("orderXXXX")
                .setConfirmDate(LocalDate.now())
                .setOrderStatus(1)
                .build();
        System.out.println(JSONObject.toJSONString(order));
    }
}

实际上，很简单，就是再Order里面有一个builder类，用它来创建一个Order实例（听起来是不是有点像代理模式），bulider大概分成四部分:
1 一个简单的内部类，里面的属性和Order属性相同
2 内部类的构造函数，这里我是直接搞了个空的，可以根据实际情况来处理（我后面的正规的构造者模式会用到）
3 bulid方法，真正核心的一个方法，他直接返回一个Order实例
4 属性方法，这些都是平行的方法，谁前谁后无所谓的

这里妙就妙在一个内部类，一个通过bulider对象来构建的构造方法，搭建起来这个可以链式调用的。

传统正规的创建者模式

上面的方式是我们常见的，但是真正书本上的创建者模式要更繁琐一些，不是一个类里面加一个内部类，一个内部类的构造方法就完事的。

这是我找的一个构建者模式的UML图

我们通过正规传统的构建者模式，其实更能解构出来他的大体结构和作用

由图director builder XXBuilder Product

我想要获取一个Productor的实例是这样的
我先创建一个director（director的作用就是管理Builder）
创建一个Bulider，这个Bulider是一个抽象类（我们可以根据他进行各种类型的扩展）
创建XXXBuilder，一个具体的实例（主要是生成定制化的Productor）
Prductor只是一个对象而已，中间甚至都不用去创建它，bulider的build方法就可以。

创建者模式的用处

首先针对创建对象这种，超过四个参数就要考虑用创建者模式。
创建者模式，同样正对某些工具API也是一样，我调用某个工具，需要定制某些属性，直接添加就可以，彼此之间不会有联系，像我们mybatis的lambda其实就是这样，我们可以通过这种设计，让调用变的更简单已用，而不是自己搞一个构造函数，一个个去研究参数。

 LambdaQueryWrapper<ErpBeginningConfigDO> queryErpBegin = new LambdaQueryWrapper<>();
                queryErpBegin.eq(ErpBeginningConfigDO::getErpCustomerNo,customerNo)
                        .eq(ErpBeginningConfigDO::getDataStatus, DataStatus.DATA_STATUS_ENABLE.getValue())
                        .eq(ErpBeginningConfigDO::getMerchantId,merchantId);

附上我的GitHub对应的代码
github 构造者模式