链式编程 & 建造者模式

---

前言

之前写了传统的建造者模式的文章。
今天突然想到：怎么实现链式编程。
然后就发现了，链式编程和创建型建造者模式，似乎很像。

我甚至不知道区别在何处，故在次记录，万一哪天悟了，说不定可以给自己解惑。

时隔半年，对之前的遗留问题有了新的认识：
建造者模式，是实现链式编程的一种方式。
1：不管是建造者模式、还是常规的链式编程。都是为了解决：得到一个复杂且麻烦的对象。
2：不管是建造者模式、还是常规的链式编程，每个复杂对象的实现代码都是一次性的
（为了拼凑出一个独特的数据结构，所以复用性很低）

建造者模式，也可以用lombook的注解实现：@Builder

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、传统的创建型建造者模式

/**
 * 手机类
 */
import com.alibaba.fastjson.JSONObject;
import lombok.Data;

@Data
public class Phone {
    
    
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    //私有构造方法
    private Phone(Builder builder) {
    
    
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainboard = builder.mainBoard;
    }


    public static final class Builder {
    
    
        private String cpu;
        private String screen;
        private String memory;
        private String mainBoard;

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

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

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

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

        //使用构建者创建Phone对象
        public Phone build() {
    
    
            return new Phone(this);
        }
    }

    public static void main(String[] args) {
    
    
        //创建手机对象   通过构建者对象获取手机对象
        Phone phone = new Phone.Builder()
                .cpu("intel")
                .screen("三星屏幕")
                .memory("金士顿内存条")
                .mainBoard("华硕主板")
                .build();
        System.out.println(JSONObject.toJSONString(phone));
    }
}
//{"cpu":"intel","mainboard":"华硕主板","memory":"金士顿内存条","screen":"三星屏幕"}

二、链式编程 - 创建简单对象

import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import lombok.experimental.Accessors;

/**
 * 手机类
 */
@Data
@Accessors(chain = true)
public class Phone2 {
    
    
    private String cpu;
    private String screen;
    private String memory;
    private String mainBoard;


    public static void main(String[] args) {
    
    
        //创建手机对象   通过构建者对象获取手机对象
        Phone2 phone = new Phone2()
                .setCpu("intel")
                .setScreen("三星屏幕")
                .setMemory("金士顿内存条")
                .setMainBoard("华硕主板");

        System.out.println(JSONObject.toJSONString(phone));
    }
}
//{"cpu":"intel","mainBoard":"华硕主板","memory":"金士顿内存条","screen":"三星屏幕"}

三、链式编程 - 修改对象里的字段

import com.alibaba.fastjson.JSONObject;

/**
 * 链式编程：精髓在于 - 对象里的方法返回对象自身
 * 例子：创建型建造者模式里是用了链式编程
 * SpringBuilder里面使用了
 *
 * @author lobsterlong
 * @date 2022/7/22
 */
public class StringB {
    
    
    public String name;

    public StringB(String name) {
    
    
        this.name = name;
    }

    public StringB addPrefix(String prefix) {
    
    
        this.name = prefix + this.name;
        return this;
    }

    public StringB addSuffix(String suffix) {
    
    
        this.name += suffix;
        return this;
    }

    public static void main(String[] args) {
    
    
        StringB b = new StringB("long");
        System.out.println(JSONObject.toJSONString(b));
        System.out.println(JSONObject.toJSONString(b.addPrefix("lobster.")));
        System.out.println(JSONObject.toJSONString(b.addSuffix("@0722")));
    }
}
//{"name":"long"}
//{"name":"lobster.long"}
//{"name":"lobster.long@0722"}

---

总结

仅从一、二来看，最终的效果是一致的。
具体的区别就不清楚了…