Java链式编程与Builder(建造者)设计模式

约定不等于承诺〃 2023-10-13 11:54 1阅读 0赞

## 一、链式编程 ##

### 1.1.释义 ###

链式编程，也叫级联式编程，调用对象的函数时返回一个this对象指向对象本身，达到链式效果，可以级联调用。

### 1.2.特点 ###

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

### 1.2.原理 ###

链式编程的原理是返回一个**this对象**，也就是返回对象本身，从而达到链式效果。

### 1.3.优点 ###

编程性强、代码简洁 、可读性强。

### 1.4.使用条件 ###

方法返回当前对象，即返回this；或方法支持链式调用，即返回调用该方法的对象。

#### 1.4.1.使用示例 ####

import lombok.Data;
    
    /**
     * 要实现链式编程，我们需要让setParam1()和setParam2()都返回this。
     * 当手写set方法时，无需 @Data注解
     * 在此仅为了使用 @Data的toString()
     */
    @Data
    public class Sample {
    
        private String param1;
        private String param2;
        private String param3;
    
        public Sample setParam1(String param1) {
            this.param1 = param1;
            return this;
        }
        public Sample setParam2(String param2) {
            this.param2 = param2;
            return this;
        }
        public Sample setParam3(String param3) {
            this.param3 = param3;
            return this;
        }
    }

#### 1.4.2.示例输出 ####

![a997f5ac6b804ca7a6cad665098135a7.png][]

## 二、String链式示例 ##

### 2.1.源码 ###

![937c8496c5444577b1507a3f36c2ea7a.png][]

![f45db91c056f453c8944580d0cceda6e.png][]

例如**可以将某对象toString()转化为String后，或将String对象valueOf()赋值后，进行concat()拼接、replace()替换、substring()截取**。符合的方法很多，大多数都能组装起来，使之符合链式编程。

## 三、StringBuffer和StringBuilder链式示例 ##

### 3.1.源码 ###

![cbe30588c7a24cc094b497568dd86286.png][]

### 3.2.使用示例 ###

![a299edb7d18847cfa236636520dfcf74.png][]

同时，Collection接口下的List的stream流，也是使用的链式编程，这里不做介绍。

## 四、@Accessors注解开启链式编程 ##

### 4.1.源码 ###

@Target({ElementType.TYPE, ElementType.FIELD})
 @Retention(RetentionPolicy.SOURCE)
 public @interface Accessors {
 	/**
 	 * If true, accessors will be named after the field and not include a {@code get} or {@code set}
 	 * prefix. If true and {@code chain} is omitted, {@code chain} defaults to {@code true}.
 	 * default: false
 	 * 
 	 * @return Whether or not to make fluent methods (named {@code fieldName()}, not for example {@code setFieldName}).
 	 */
 	boolean fluent() default false;
 	
 	/**
 	 * If true, setters return {@code this} instead of {@code void}.
 * 如果是true,setters方法返回{this} 而不是{void}
 * 
 	 * default: false, unless {@code fluent=true}, then default: true
 	 * 
 	 * @return Whether or not setters should return themselves (chaining) or {@code void} (no chaining).
 	 */
 	boolean chain() default false;
 	
 	/**
 	 * If present, only fields with any of the stated prefixes are given the getter/setter treatment.
 	 * Note that a prefix only counts if the next character is NOT a lowercase character or the last
 	 * letter of the prefix is not a letter (for instance an underscore). If multiple fields
 	 * all turn into the same name when the prefix is stripped, an error will be generated.
 	 * 
 	 * @return If you are in the habit of prefixing your fields (for example, you name them {@code fFieldName}, specify such prefixes here).
 	 */
 	String[] prefix() default {};
 }

### 4.2.注解使用 ###

@Data
    @Accessors(chain = true)
    public class Sample {
    
        private String param1;
        private String param2;
        private String param3;
    
    }

上述代码是对1.4.1中的示例代码进行的简化，可以看出，当使用注解时，不用自己再设计具体的链式实现，注解会开启链式操作。这个注解常用在Spring中的实体类上。

同时，使用@Accessors(fluent = true)时，省略给对象赋值和取值时候得set、get前缀，可以直接用对象点出来元素，不用set。

### 4.3.测试 ###

![a4799c3a160440959b0e73372e934a3a.png][]

## 五、使用Builder模式实现Java链式编程 ##

Builder模式是一种对象创建模式，允许我们创建一个对象，并设置其属性值。示例的Builder模式实现如下所示：

public class Sample {
    
        private String name;
        private String gender;
        private String age;
    
        private Sample(){}
        public static SampleBuilder builder() {
            return new SampleBuilder();
        }
    
        public static class SampleBuilder {
    
            private Sample sample = new Sample();
    
            public SampleBuilder setName(String name) {
                sample.name = name;
                return this;
            }
    
            public SampleBuilder setGender(String gender) {
                sample.gender = gender;
                return this;
            }
            public SampleBuilder setAge(String age) {
                sample.age = age;
                return this;
            }
    
            public Sample build() {
                return sample;
            }
        }
    }

在上面的代码示例中，我们首先创建了一个Sample类。为了实现Builder模式，我们还创建了一个SampleBuilder类。SampleBuilder类中有两个with方法，分别用于设置name属性、gender属性和age属性。它们都返回SampleBuilder对象，这样就可以实现链式调用。在参数设置完成后，我们通过build方法创建Sample对象。使用Builder模式进行链式编程的示例如下：

![03337f9bc0514619b950a277158b02bf.png][]

在上面的示例中，我们通过Sample.builder()创建了SampleBuilder对象，并使用其中的set方法设置参数。在设置完成后，我们通过build方法创建了Sample对象。

上面这就是一个最简单的builder链式编程，简单在于，能成链能赋值，仅此而已。但如果需要取值，需要对参数校验，这个类就不够用了，需要补充更多的规定，这就抛砖引玉的引出了Java重要设计模式之一的建造者模式。

## 六、Builder(建造者)设计模式 ##

### 6.1.实用范围 ###

当创建[复杂对象][Link 1]的算法应该独立于该对象的[组成][Link 2]部分以及它们的[装配][Link 3]方式时。

当构造过程必须允许被构造的对象有不同表示时。

### 6.2.角色 ###

在这样的[设计模式][Link 4]中，有以下几个角色：

1 builder：为创建一个产品对象的各个部件指定抽象接口。

2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

3 Director：构造一个使用Builder接口的对象。

4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成[最终产品][Link 5]的接口。

### 6.3.Builder 模式创建步骤 ###

1）在类中，创建一个静态内部类，包含外部类的全部属性；

2）在内部类中，为每一个属性进行赋值；

3）内部类中创建 **build** 方法，返回外部类对象

4）在外部类中创建静态 **builder**方法，返回内部类对象

### 6.4.残次品示例 ###

public class Sample {
 
 //Sample 类的属性都是不可变的。所有的属性都添加了final修饰符，在构造方法中设置了值。
 private final String name;
 private final String gender;
 private final Double age;
 //对外只提供getters方法。
 public String getName() {
 return name;
 }
 public String getGender() {
 return gender;
 }
 public Double getAge() {
 return age;
 }
 //Sample 类的构造方法是私有的。也就是说调用者不能直接创建User对象。
 private Sample(SampleBuilder builder){
 this.name = builder.name;
 this.gender = builder.gender;
 this.age = builder.age;
 }
 public static class SampleBuilder {
 private String name;
 private String gender;
 private Double age;
 public SampleBuilder SampleBuilder(){
 return new SampleBuilder();
 }
 
 public SampleBuilder setName(String name) {
 this.name = name;
 return this;
 }
 
 public SampleBuilder setGender(String gender) {
 this.gender = gender;
 return this;
 }
 public SampleBuilder setAge(Double age) {
 this.age = age;
 return this;
 }
 
 public Sample build() {
 //添加参数校验
 Sample sample = new Sample(this);
 if (sample.getAge() < 0 || sample.getAge() > 125){
 throw new IllegalStateException("Age out of range:" + sample.getAge());
 }
 if (!("男".equals(sample.getGender()) || "女".equals(sample.getGender()))){
 throw new IllegalStateException("Error Gender Input:" + sample.getGender());
 }
 return sample;
 }
 }
 }

![f54ee7ec1a7d429fabdd90f738c7f225.png][]

可以看到，基本链式编程形成，同时参数也会进行校验，符合要求。但之所以叫残次品，是因为这只是build链式开发，但说**设计模式**，明显“德不配位”。

### 6.5.简单示例 ###

#### 6.5.1.示例目录 ####

![70fc8c43530e41d9aed202169543b0b8.png][]

#### 6.5.2.各层代码 ####

> 建造者模式核心作用也就是优点，就是对复杂对象（**特指某几个对象组合而成的对象**）的创建，抽出来单独实现，对于用户使用这类复杂对象是提供了方便，同时，这也在复杂对象的部分创建与整体组装之间搭了一座桥，实现了部分和整体组装的解耦。
> 
> 建造者模式主要是用在复杂对象上的，对于简单对象，就毫无用武之地。但在此还是需要一些简单的对象，来帮助了解建造者模式。

Animal： 设置抽象属性

package com.test5;
    
    public class Animal {
        //名字
        private String name;
        //时速
        private Long speed;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Long getSpeed() {
            return speed;
        }
    
        public void setSpeed(Long speed) {
            this.speed = speed;
        }
    }

AnimalBuilder ：

package com.test5;
    
    public interface AnimalBuilder {
        void buildName();
        void buildSpeed();
    
        Animal builderAnimal();
    }

AnimalDirector ：

package com.test5;
    
    public class AnimalDirector {
        public Animal constructAnimal(AnimalBuilder pb) {
            pb.buildName();
            pb.buildSpeed();
            return pb.builderAnimal();
        }
    }

Eagle ：创建角色1

package com.test5;
    
    public class Eagle extends Animal{
    }

EagleBuilder ：建造角色1

package com.test5;
    
    public class EagleBuilder implements AnimalBuilder{
    
        Animal animal;
    
        public EagleBuilder(){
            animal = new Animal();
        }
    
       public void buildName(){
            animal.setName("雄鹰");
       }
    
       public void buildSpeed(){
            animal.setSpeed(80L);
       }
    
        public Animal builderAnimal(){
            return animal;
       }
    }

Rabbit ：创建角色2

package com.test5;
    
    public class Rabbit extends Animal{
    }

RabbitBuilder ：建造角色2

package com.test5;
    
    public class RabbitBuilder implements AnimalBuilder{
    
        Animal animal;
    
        public RabbitBuilder(){
            animal = new Animal();
        }
    
       public void buildName(){
            animal.setName("兔子");
       }
    
       public void buildSpeed(){
            animal.setSpeed(70L);
       }
    
        public Animal builderAnimal(){
            return animal;
       }
    }

每次添加新角色时，只需要新添加一个角色，然后为它添加一个建造，这样后面就可以使用了。

测试：

package com.test5;
    
    public class test {
    
        public static void main(String[] args) {
    
            AnimalDirector director = new AnimalDirector();
    
            Animal eagle = director.constructAnimal(new EagleBuilder());
            System.out.println(eagle.getName()+"的时速为："+eagle.getSpeed());
    
            Animal rabbit = director.constructAnimal(new RabbitBuilder());
            System.out.println(rabbit.getName()+"的时速为："+rabbit.getSpeed());
    
        }
    }

结果示例：

雄鹰的时速为：80
    兔子的时速为：70

[a997f5ac6b804ca7a6cad665098135a7.png]: https://img-blog.csdnimg.cn/a997f5ac6b804ca7a6cad665098135a7.png
[937c8496c5444577b1507a3f36c2ea7a.png]: https://img-blog.csdnimg.cn/937c8496c5444577b1507a3f36c2ea7a.png
[f45db91c056f453c8944580d0cceda6e.png]: https://img-blog.csdnimg.cn/f45db91c056f453c8944580d0cceda6e.png
[cbe30588c7a24cc094b497568dd86286.png]: https://img-blog.csdnimg.cn/cbe30588c7a24cc094b497568dd86286.png
[a299edb7d18847cfa236636520dfcf74.png]: https://img-blog.csdnimg.cn/a299edb7d18847cfa236636520dfcf74.png
[a4799c3a160440959b0e73372e934a3a.png]: https://img-blog.csdnimg.cn/a4799c3a160440959b0e73372e934a3a.png
[03337f9bc0514619b950a277158b02bf.png]: https://img-blog.csdnimg.cn/03337f9bc0514619b950a277158b02bf.png
[Link 1]: https://baike.baidu.com/item/%E5%A4%8D%E6%9D%82%E5%AF%B9%E8%B1%A1/53551848?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E7%BB%84%E6%88%90/10881662?fromModule=lemma_inlink
[Link 3]: https://baike.baidu.com/item/%E8%A3%85%E9%85%8D/7145348?fromModule=lemma_inlink
[Link 4]: https://baike.baidu.com/item/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/1212549?fromModule=lemma_inlink
[Link 5]: https://baike.baidu.com/item/%E6%9C%80%E7%BB%88%E4%BA%A7%E5%93%81/885278?fromModule=lemma_inlink
[f54ee7ec1a7d429fabdd90f738c7f225.png]: https://img-blog.csdnimg.cn/f54ee7ec1a7d429fabdd90f738c7f225.png
[70fc8c43530e41d9aed202169543b0b8.png]: https://img-blog.csdnimg.cn/70fc8c43530e41d9aed202169543b0b8.png