什么情况下使用 lombok Builder构建器?

╰+攻爆jí腚メ 2022-03-02 03:42 228阅读 1赞

# Lombok Builder构建器做了哪些事情? #

大学时，我在《effective java》上看过Builder构建器相关的内容，但实际开发中不经常用。后来，在项目中使用了lombok,发现它有一个注解 `@Builder`，就是为java bean生成一个构建器。于是，回头重新复习了下相关知识，整理如下。

## 1. 为什么使用构建器模式? ##

若一个类具有大量的成员变量，我们就需要提供一个全参的构造器或大量的set方法。这让实例的创建和赋值，变得很麻烦，且不直观。我们通过构建器，可以让变量的赋值变成链式调用，而且调用的方法名对应着成员变量的名称。让对象的创建和赋值都变得很简洁、直观。

## 2. lombok Builder使用样例 ##

首先,创建一个名为 User的java bean,非常简单,只有两个属性, sex,和 name.

其中 `@Builder`可以自动为 User 对象生成一个构建器,`@ToString` 可以自动为 User 对象生成 `toStrng()` 方法.

import lombok.Builder;
    import lombok.NonNull;
    import lombok.ToString;
    
    @Builder
    @ToString
    public class User { 
    
        private Integer sex;
        private String name;
    
    }

现来测试一下Lombok为我们自动提供的构建器功能:

@Test
        public void builderTest() { 
    
            User user = User.builder()
                    .name("杏仁")
                    .sex(1)
                    .build();
    
            System.out.println(user.toString());
        }

会看到控制台打印:

User(sex=1, name=杏仁)

可以看到,打印结果就是我们想要的样子,但是Lombok 为我们做了什么事情呢?

**使用 Lombok 需要注意理解 Lombok 的注解做了什么，否则很容易出错。**

## 3. 反编译lombok生成的User.class ##

*注意：下面请区分两组名词:"builder方法"和“build方法”，“构造器”和“构建器”。*

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.xingren.lomboklearn.pojo;
    
    public class User { 
        private Integer sex;
        private String name;
    
        User(final Integer sex, final String name) { 
            this.sex = sex;
            this.name = name;
        }
    
        public static User.UserBuilder builder() { 
            return new User.UserBuilder();
        }
    
        public String toString() { 
            return "User(sex=" + this.sex + ", name=" + this.name + ")";
        }
    
        public static class UserBuilder { 
            private Integer sex;
            private String name;
    
            UserBuilder() { 
            }
    
            public User.UserBuilder sex(final Integer sex) { 
                this.sex = sex;
                return this;
            }
    
            public User.UserBuilder name(final String name) { 
                this.name = name;
                return this;
            }
    
            public User build() { 
                return new User(this.sex, this.name);
            }
    
            public String toString() { 
                return "User.UserBuilder(sex=" + this.sex + ", name=" + this.name + ")";
            }
        }
    }

我们通过反编译User.class，获得上方的源码(最好用idea自带的反编译器，jd-gui反编译的源码不全)。

我们发现源码中有一个 `UserBuilder` 的静态内部类，我们在调用builder方法时，实际返回了这个静态内部类的实例。

public static User.UserBuilder builder() { 
            return new User.UserBuilder();
        }

这个`UserBuilder`类，具有和User相同的成员变量，且拥有名为sex,name的方法。这些以User的成员变量命名的方法，都是给`UserBuilder`的成员变量赋值，并返回this。

public User.UserBuilder sex(final Integer sex) { 
                this.sex = sex;
                return this;
            }
    
            public User.UserBuilder name(final String name) { 
                this.name = name;
                return this;
            }

这些方法返回this，其实就是返回调用这些方法的`UserBuilder`对象，也可称为“返回对象本身”。通过返回对象本身，形成了方法的链式调用。

再看build方法，它是`UserBuilder`类的方法。它创建了一个新的User对象，并将自身的成员变量值，传给了User的成员变量。

public User build() { 
                return new User(this.sex, this.name);
            }

所以为什么这种模式叫“构建器”，因为要创建User类的实例,首先要创建内部类`UserBuilder`。而这个UserBuilder也就是构建器，是创建User对象的一个过渡者。**所以利用这种模式，会有中间实例的创建，会加大虚拟机内存的消耗。**

## 4.链式方法赋值，一定要用构建器模式吗？ ##

不一定要用到构建器模式，通过上面分析 Lombok 的构建器原理可知,Lombok的`@Builder`更适合final修饰的成员变量.

因为final修饰的成员变量，需要在实例创建时就把值确定下来。 (常见的如: web 开发中的 Query/Form 等查询入参, 变量通常会设置为 final的) 在类具有大量成员变量的时候，我们是不希望用户直接调用全参构造器的。

那如果有大量属性，但不需要它是成员变量不可变的对象，我们还需要构建器模式吗？个人认为，不需要，我们可以参考构建器，把代码赋值改成链式的即可：

public class User { 
    
        private Integer sex;
    
        private String name;
    
        public static User build() { 
            return new User();
        }
        private User() { 
        }
    
        public User sex(Integer sex) { 
            this.sex = sex;
            return this;
        }
    
        public User name(String name){ 
            this.name = name;
            return this;
        }
    
    
    }

我们要做的很简单: **私有化构造函数,在 `build()`方法中实例化 User 对象.**

## 5. 使用@Builder注解需要注意的 属性默认值问题 ##

我们先来改造一下User 类:

@Builder
    @ToString
    public class User { 
    
        @NonNull
        private Integer sex = 1;
    
        private String name;
    
    }

添加一个 `@NoNull` 注解,此注解会要求sex属相不能为空.而我们又为sex属性设置了默认值 1 ,看起来应该没什么问题,我们再来测试一下:

@Test
        public void builderTest() { 
    
            User user = User.builder()
                    .name("杏仁")
                    .build();
    
            System.out.println(user.toString());
        }

我们去掉了sex属性的设置,因为它已经设置了默认值,但是运行就会发现报如下错误:

java.lang.NullPointerException: sex is marked @NonNull but is null

这就很奇怪了,我们明明给 sex 属性设置了默认值啊,怎么还会是null呢?

为了一探究竟,我们还是反编译User.class文件看下Lombok 到底做了什么?

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.xingren.lomboklearn.pojo;
    
    import lombok.NonNull;
    
    public class User { 
        @NonNull
        private Integer sex = 1;
        private String name;
    
        User(@NonNull final Integer sex, final String name) { 
            if (sex == null) { 
                throw new NullPointerException("sex is marked @NonNull but is null");
            } else { 
                this.sex = sex;
                this.name = name;
            }
        }
    
        public static User.UserBuilder builder() { 
            return new User.UserBuilder();
        }
    
        public String toString() { 
            return "User(sex=" + this.sex + ", name=" + this.name + ")";
        }
    
        public static class UserBuilder { 
            private Integer sex;
            private String name;
    
            UserBuilder() { 
            }
    
            public User.UserBuilder sex(@NonNull final Integer sex) { 
                if (sex == null) { 
                    throw new NullPointerException("sex is marked @NonNull but is null");
                } else { 
                    this.sex = sex;
                    return this;
                }
            }
    
            public User.UserBuilder name(final String name) { 
                this.name = name;
                return this;
            }
    
            public User build() { 
                return new User(this.sex, this.name);
            }
    
            public String toString() { 
                return "User.UserBuilder(sex=" + this.sex + ", name=" + this.name + ")";
            }
        }
    }

通过反编译后的代码可以看到, User 的 sex 属性已经有了默认值为 1. 但是 内部类 UserBuilder 却没有默认值, 我们再调用 User.builder() 方法是, 实例化的是 UserBuilder 内部类

public static User.UserBuilder builder() { 
            return new User.UserBuilder();
        }

最后调用 UserBuilder.build() 方法时, 是把 UserBuilder 类的属性传给了User类,导致 User 类的默认值被 UserBuilder 类覆盖

public User build() { 
                return new User(this.sex, this.name);
            }

而在User的全参构造方法中

User(@NonNull final Integer sex, final String name) { 
            if (sex == null) { 
                throw new NullPointerException("sex is marked @NonNull but is null");
            } else { 
                this.sex = sex;
                this.name = name;
            }
        }

则会判断sex是否null,是的话就会抛出

则会判断sex是否null,是的话就会抛出 `NullPointerException("sex is marked @NonNull but is null")` 异常.

**如何解决呢?**

解决起来也很简单,不止一种方法,其中一种是 我们可以在需要默认值的属性上使用 `@Builder.Default`注解

@Builder
    @ToString
    public class User { 
    
        @NonNull
        @Builder.Default
        private Integer sex = 1;
    
        private String name;
    
    }

再次测试就会发现,输出结果如我们期望那样

User(sex=1, name=杏仁)

那这个 `@Builder.Default`注解到底做了什么事情呢? 老规矩,还是反编译下 User.class,查看下源代码:

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.xingren.lomboklearn.pojo;
    
    import lombok.NonNull;
    
    public class User { 
        @NonNull
        private Integer sex;
        private String name;
    
        private static Integer $default$sex() { 
            return 1;
        }
    
        User(@NonNull final Integer sex, final String name) { 
            if (sex == null) { 
                throw new NullPointerException("sex is marked @NonNull but is null");
            } else { 
                this.sex = sex;
                this.name = name;
            }
        }
    
        public static User.UserBuilder builder() { 
            return new User.UserBuilder();
        }
    
        public String toString() { 
            return "User(sex=" + this.sex + ", name=" + this.name + ")";
        }
    
        public static class UserBuilder { 
            private boolean sex$set;
            private Integer sex;
            private String name;
    
            UserBuilder() { 
            }
    
            public User.UserBuilder sex(@NonNull final Integer sex) { 
                if (sex == null) { 
                    throw new NullPointerException("sex is marked @NonNull but is null");
                } else { 
                    this.sex = sex;
                    this.sex$set = true;
                    return this;
                }
            }
    
            public User.UserBuilder name(final String name) { 
                this.name = name;
                return this;
            }
    
            public User build() { 
                Integer sex = this.sex;
                if (!this.sex$set) { 
                    sex = User.$default$sex();
                }
    
                return new User(sex, this.name);
            }
    
            public String toString() { 
                return "User.UserBuilder(sex=" + this.sex + ", name=" + this.name + ")";
            }
        }
    }

首先我们发现, User类多了一个静态方法:

private static Integer $default$sex() { 
            return 1;
        }

此方法返回了sex的默认值

接下来看内部类 UserBuilder多了一个boolean类型的变量

private boolean sex$set;

现在还不知道这个变量的含义,我们需要结合 sex() 方法来推断:

public User.UserBuilder sex(@NonNull final Integer sex) { 
                if (sex == null) { 
                    throw new NullPointerException("sex is marked @NonNull but is null");
                } else { 
                    this.sex = sex;
                    this.sex$set = true;
                    return this;
                }
            }

可知,在调用构建器设置 sex属性时,会先判断是否为空(因为有`@NoNull`注解),并且如果不为空,会设置内部类 UserBuilder 的sex属性值,并且把 `sex$set` 置为 true.由此我们可知, `sex$set`变量就是来表示 sex是否是默认值的.

\*\*最后,\*\*在 UserBuilder.build()方法里面

public User build() { 
                Integer sex = this.sex;
                if (!this.sex$set) { 
                    sex = User.$default$sex();
                }
    
                return new User(sex, this.name);
            }

不再是单纯的调用User的全参构造器实例化User对象,**而是先判断sex是否有无默认值**.

这就是 Lombok 为我们所做的事情。

## 6. 总结 ##

所以，我觉得使用lombok的`@Builder`注解的时候，还是要思考一下。当你不需要成员变量不可变的时候，你完全没必要使用构建器模式，因为这会消耗java虚拟机的内存。还有使用 Lombok 的 `@Builder`注解时,属性默认值失效问题。