Java链式编程、什么是链式编程、链式编程怎么调用，链式编程的使用形式，Builder模式实现链式编程（保姆级教程）

一、大致了解链式编程

1.1 概念

链式编程（或链式调用）是一种编程风格，其中方法调用通过返回对象本身来连接在一起，以便可以在单一表达式中连续调用多个方法。链式编程的核心在于方法的返回值是对象本身，这使得可以在同一行代码中进行多个操作。这种编程风格可以使代码更加简洁和可读。

1.2 实现链式编程的关键

要实现链式编程，你需要遵循以下几个步骤：

1. 方法返回当前对象：每个方法都需要返回当前对象（通常是this），这样可以在调用后继续调用其他方法。
2. 方法设置实例状态：方法通常会设置对象的某些状态或执行操作，并且这些方法不应该返回新的对象实例，而是返回当前对象。
3. 合理设计 API：确保 API 的方法设计可以自然地组合起来，并且每个方法执行的操作是有意义的。

二、Java中的链式编程（看这个即可）

2.1 精简理解链式编程

1、链式编程的特点是可以通过一个方法调用多个方法，将多个方法调用链接起来，形成一条“链式”，从而提高代码的可读性。

2、在链式编程中，每个方法的返回类型 应该是调用该方法的对象类型，这样才能够在调用完一个方法后直接接着调用下一个方法。

2.2 普通方式使用链式编程

下面代码给出了一个普通例子，可以根据理解来理解：

public class Test{
    public static void main(String[] args){
        Test test = new Test();
        test.method1().method2().method3()......
    }

    public Test method1(){
        return new Test();
    }
    
    public Test method2(){
        return new Test();
    }
    
    public Test method3(){
        return new Test();
    }
    ....
    ....
    public void method4(){

    }
}

代码分析：上面的代码就可以搞成链式调用：test.method1().method2().method3()...... 因为你调完 method1() 后，返回的还是一个对象，刚好这个对象能够调用剩余的方法，然后就这样反复进行，直到终点。假如：test.method1().method4().method3()...... 这样就不行了，因为你调 method4() 后，还咋调。

2.3 Builder模式实现Java链式编程

Builder模式是一种对象创建模式，允许我们创建一个对象，并设置其属性值。下面代码给出了一个例子，可以根据理解来理解：

public class Test {

    private String paramOne;
    private String paramTwo;

    private Test() {
    }  //无参构造

    public static SampleBuilder builder() {
        return new SampleBuilder();
    }

    //内部类-----------
    public static class SampleBuilder {
        private Test sample = new Test();

        public SampleBuilder withParamOne(String paramOne) {
            sample.paramOne = paramOne;
            return this;
        }

        public SampleBuilder withParamTwo(String paramTwo) {
            sample.paramTwo = paramTwo;
            return this;
        }

        public Test build() {
            return sample;
        }

    }

    //调用
    public static void main(String[] args) {
        
        //使用形式1：
        Test test = new Test();
        Test hello = test.builder()
                .withParamOne("Hello")
                .withParamTwo("world!")
                .build();
        System.out.println(hello.toString());

        //使用形式2：
        Test test1 = new Test()
                .builder()
                .withParamOne("Hello")
                .withParamTwo("world!")
                .build();
        System.out.println(test1.toString());

        //使用形式3：
        Test test2 = Test.builder()
                .withParamOne("Hello")
                .withParamTwo("world!")
                .build();
        System.out.println(test2.toString());
    }

}

代码分析：虽然调用时，中间 .withParamOne("Hello")、.withParamTwo("world!") 中的返回类型是 this（也就是SampleBuilder 对象）而不是 Test，但是不影响链的调用，因为这个 this 对象也可以调用这个方法啊。

所以相当于 中间隐藏了接收方法调用后的返回结果。

再给出一个例子：

@Bean
public Docket getDocket() {
    //创建Docket对象
    Docket docket = new Docket(DocumentationType.SWAGGER_2);
    Docket docket1 = docket.apiInfo(null); //设置Swagger接口文档的首页信息
    ApiSelectorBuilder select = docket1.select(); //初始化并返回一个API选择构造器
    ApiSelectorBuilder apis = select.apis(RequestHandlerSelectors.any()); //为任何接口生成API文档
    ApiSelectorBuilder paths = apis.paths(PathSelectors.any()); //可以根据url路径设置哪些请求加入文档，忽略哪些请求
    Docket build = paths.build();//创建API文档
    return build;
}

//改写成链式编程为：
@Bean
public Docket getDocket() {
    Docket docket = new Docket(DocumentationType.SWAGGER_2)
        .apiInfo(null)   
        .select() 
        .apis(RequestHandlerSelectors.any())   
        .paths(PathSelectors.any())
        .build();
    return docket;
}

三、实现链式编程的注意事项

1. 方法链的可读性：链式编程可以提高代码的可读性，但过长的链式调用可能会导致代码难以维护。确保链式调用是合理的，避免过度使用。
2. 线程安全：如果你的类在多线程环境下使用，确保链式调用不会导致线程安全问题。例如，可以使用不可变对象来避免这种问题。
3. 设计合理：链式编程需要合理的设计 API，确保每个方法的调用都是有意义的，避免无意义的操作链。