【学习笔记】快速学习链式编程和建造模式 ，附代码

Posted on by hackdl

文章目录

    • 一、链式编程
      • 1.1 什么情况下使用链式编程?
      • 1.2 举个例子
        • 1.2.1 链式的POJO写法
      • 1.3 使用Lombok生成链式编程
        • 1.3.1 使用注解 @Accessors(chain = true)
      • 1.4 小结
    • 二、建造者模式
      • 2.1 什么时候使用建造者模式？
      • 2.2 举个例子
        • 2.2.1 （可选）使用lombok注解@Builder
        • 2.2.2 建造者模式代码
        • 2.2.3 使用建造者模式构建POJO
      • 2.3 如何手写建造者模式？
        • 2.3.1 思路整理

一、链式编程

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

1.1 什么情况下使用链式编程?

只要方法返回的是对象本身，那么就可以使用链式编程

1.2 举个例子

已一个普通的POJO类（学生类为例）

一般的学生类写法如下

public class Student {

    private String name;

    private Integer age;

   服务器托管网 public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
1.2.1 链式的POJO写法
public class StudentC {

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }


    public Integer getAge() {
        return age;
    }

    public StudentC setName(String name) {
        this.name = name;
        return this;
    }

    public StudentC setAge(Integer age) {
        this.age = age;
        return this;
    }
}

两个不同的写法的POJO用法也是不同的：

public static void main(String[] args) {
    Student student = new Student();
    student.setName("jack");
    student.setAge(15);
    System.out.println(JSON.toJSONString(student));

    StudentC studentC = new StudentC().setAge(18).setName("jane");
    System.out.println(JSON.toJSONString(studentC));
}

// 打印结果
{"age":15,"name":"jack"}
{"age":18,"name":"jane"}
  • 效果是一样的，但是写法会更加直观
  • 现在市面上很多成熟的组件都提供了链式编程

1.3 使用Lombok生成链式编程

引入lombok依赖

dependency>
    groupId>org.projectlombokgroupId>
    artifactId>lombokartifactId>
    optional>trueoptional>
dependency>
1.3.1 使用注解 @Accessors(chain = true)

代码

@Data
@Accessors(chain = true)
public class Student {

    private String name;

    private Integer age;
}

生成的源代码

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

    public String getName() {
        return this.name;
    }

    public Integer getAge() {
        return this.age;
    }

    public Student setName(final String name) {
        this.name = name;
        return this;
    }

    public Student setAge(final Integer age) {
        this.age = age;
        return this;
    }

    ///.........

使用该注解后，所有属性的set方法在编译后都会自动生成为链式编程的格式

1.4 小结

链式编程是一个很实用的小技巧，对于很多赋值用的set方法都可以使用链式编程，并且不会对原来的写法有影响。

属于是锦上添花的写法，值得推荐。

二、建造者模式

建造者模式是一步一步建造一个复杂对象，它允许用户只通过指定复杂对象的类型和内容就可以建造他们，用户不需要指定内部的具体构建细节。

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。

它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

2.1 什么时候使用建造者模式？

当一个对象非常复杂，比如包含了很多简单的对象，就可以使用建造者模式引导用户一步一步创建简单对象，最后再来建造复杂对象。

（举个例子，比如要组装一个电脑，就需要一步一步的装各种配件…

2.2 举个例子

结合Lombok自动生成来学习建造者模式

2.2.1 （可选）使用lombok注解@Builder

举个例子

@Data
@Builder
public class StudentB implements Serializable {

    private String name;

    private Integer age;
}
2.2.2 建造者模式代码
import java.io.Serializable;

public class StudentB implements Serializable {
    private String name;
    private Integer age;

    StudentB(final String name, final Integer age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return this.name;
    }

    public Integer getAge() {
        return this.age;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public void setAge(final Integer age) {
        this.age = age;
    }

    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof StudentB)) {
            return false;
        } else {
            StudentB other = (StudentB)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$age = this.getAge();
                Object other$age = other.getAge();
                if (this$age == null) {
                    if (other$age != null) {
                        return false;
                    }
                } else if (!this$age.equals(other$age)) {
                    return false;
                }

                Object this$name = this.getName();
                Object other$name = other.getName();
                if (this$name == null) {
                    if (other$name != null) {
                        return false;
                    }
                } else if (!this$name.equals(other$name)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof StudentB;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $age = this.getAge();
        result = result * 59 + ($age == null ? 43 : $age.hashCode());
        Object $name = this.getName();
        result = result * 59 + ($name == null ? 43 : $name.hashCode());
        return result;
    }

    public String toString() {
        return "StudentB(name=" + this.getName() + ", age=" + this.getAge() + ")";
    }

    public static class StudentBBuilder {
        private String name;
        private Integer age;

        StudentBBuilder() {
        }

        public StudentBBuilder name(final String name) {
            this.name = name;
            return this;
        }

        public StudentBBuilder age(final Integer age) {
            this.age = age;
            return this;
        }

        public StudentB build() {
            return new StudentB(this.name, this.age);
        }

        public String toString() {
            return "StudentB.StudentBBuilder(name=" + this.name + ", age=" + this.age + ")";
        }
    }
}
2.2.3 使用建造者模式构建POJO
public static void main(String[] args) {
    StudentB jojo = StudentB.builder().name("jojo").age(20).build();
    System.out.println(JSON.toJSONString(jojo));
}
// 打印结果
{"age":20,"name":"jojo"}

2.3 如何手写建造者模式？

可以看到，lombok帮我们创建了一个建造者的内部类。我们可以学习一下lombok做了什么。

2.3.1 思路整理

  1. 在POJO类的内部写一个静态内部类 ： 建造者类，命名为XX-Builder

  2. 建造者类使用链式编程，并且有一个关键方法：build()

    public static class StudentBBuilder {
    private String name;
    private Integer age;

    StudentBBuilder() {
    }

    public StudentBBuilder name(final String name) {
        this.name = name;
        return this;
    }

    public StudentBBuilder age(final Integer age) {
        this.age = age;
        return this;
    }
}

  3. build()方法则会直接返回一个完整的POJO对象

    public StudentB build() {
    return new StudentB(this.name, this.age);
}

  4. 而**只需服务器托管网要使用POJO的静态方法 builder()**就可以获得这个构建者类。

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

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: