Lombok-高级篇

男娘i 2023-01-12 04:12 184阅读 0赞

Lombok入门知识，请戳《[Lombok-入门篇][Lombok-]》

--------------------

*  **@Getter**

@Target({ElementType.FIELD, ElementType.TYPE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface Getter {
    
       lombok.AccessLevel value() default lombok.AccessLevel.PUBLIC;
       
       AnyAnnotation[] onMethod() default {};
       
       boolean lazy() default false;
       
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
    }

该注解可以标注在字段或类上。标注在字段上，将会给该字段构建标准的getter方法，比如字段为name，则方法名为getName，方法返回值与字段的类型对应。标注在类上，将会对类中的所有非静态字段构建getter方法。

**属性解释：**

（1）**value**

设置生成的getter方法的访问修饰符，默认为public。AccessLevel的可选值有**PUBLIC, MODULE, PROTECTED, PACKAGE, PRIVATE,NONE**分别对应访问权限为**public、module(java9)、protected、default、private**。NONE表示不生成getter方法，即停用注解功能。

比如，将getter方法设置成private：

// getter方法访问修饰符为private
    @Getter(AccessLevel.PRIVATE)
    public class User {
    
        private String name;
    
    }

编译后：

public class User {
        private String name;
    
        public User() {
        }
        // 方法是private
        private String getName() {
            return this.name;
        }
    }

（2）**lazy**

默认为false，当配置lazy=true时，@Getter注解只能标注在字段上，且该字段必须是private和final修饰的，也就是无法修改了。lazy的含义是只有调用get方法的时候，才会对属性赋值。

源码：

public class User {
    
        @Getter(value = AccessLevel.PUBLIC, lazy = true)
        private final String name = "hello";
    
    }

编译后：

import java.util.concurrent.atomic.AtomicReference;
    
    public class User {
        private final AtomicReference<Object> name = new AtomicReference();
    
        public User() {
        }
    
        public String getName() {
            Object value = this.name.get();
            if (value == null) {
                synchronized(this.name) {
                    value = this.name.get();
                    if (value == null) {
                        String actualValue = "hello";
                        value = "hello" == null ? this.name : "hello";
                        this.name.set(value);
                    }
                }
            }
    
            return (String)((String)(value == this.name ? null : value));
        }
    }

（3）**onMethod**

构建在方法上添加注解，是一个还处于实验中的功能，暂不讨论。

**使用规则：**

（1）标注在字段上

源码：

public class User {
    
        @Getter
        private String name;
    
        @Getter
        private static int age;
        
    }

编译后：

public class User {
        private String name;
        private static int age;
    
        public User() {
        }
    
        public String getName() {
            return this.name;
        }
    
        public static int getAge() {
            return age;
        }
    }

当在字段上使用时，是不区分静态和非静态字段的，均可以构建getter方法。

（2）标注在类上

源码：

@Getter
    public class User {
    
        private String name;
    
        private static int age;
    
    }

编译后：

public class User {
        private String name;
        private static int age;
    
        public User() {
        }
    
        public String getName() {
            return this.name;
        }
    }

当在类上使用时，不会对静态字段构建getter方法。

（3）已经自定义实现了getXx方法，是否会覆盖：

源码：

@Getter
    public class User {
    
        private String name;
    
        public int getName() {
            return name.hashCode();
        }
        
    }

编译后：

public class User {
        private String name;
    
        public User() {
        }
    
        public int getName() {
            return this.name.hashCode();
        }
    }

Lombok不会覆盖已经显示定义的同名方法，虽然自定义的getName方法不是标准的getter方法，返回值不是name的String类型。此条规则也适应于其他注解。

*  **@Setter**

@Target({ElementType.FIELD, ElementType.TYPE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface Setter {
     
       lombok.AccessLevel value() default lombok.AccessLevel.PUBLIC;
       
       AnyAnnotation[] onMethod() default {};
       
       AnyAnnotation[] onParam() default {};
    
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
    }

该注解可以标注在字段与类上。标注在字段上，将会给该字段构建标准的setter方法，比如字段为name，则方法名为setName或isName，方法返回值与字段的类型对应。标注在类上，将会对类中的所有**非静态字段、非final字段**构建setter方法。

**属性解释：**

（1）**value**与**onMethod**作用与**@Getter**相同。

（2）**onParam**

对setter方法的参数添加注解，也是一个处于实验中的功能。

**使用规则：**

（1）与@Getter的区别是，@Setter注解不会对final修饰的属性构建方法，而@Getter可以。

源码：

@Setter
    @Getter
    public class User {
    
        private final String name = "hello";
    
    }

编译后：

public class User {
        private final String name = "hello";
    
        public User() {
        }
    
        public String getName() {
            this.getClass();
            return "hello";
        }
    }

*  **@ToString**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface ToString {
    
       boolean includeFieldNames() default true;
       
       String[] exclude() default {};
       
       String[] of() default {};
       
       boolean callSuper() default false;
       
       boolean doNotUseGetters() default false;
       
       boolean onlyExplicitlyIncluded() default false;
       
       @Target(ElementType.FIELD)
       @Retention(RetentionPolicy.SOURCE)
       public @interface Exclude {}
       
       @Target({ElementType.FIELD, ElementType.METHOD})
       @Retention(RetentionPolicy.SOURCE)
       public @interface Include {
           
          int rank() default 0;
          
          String name() default "";
       }
    }

标注在类上，默认根据类的所有非静态字段重写toString方法。

源码：

@ToString
    public class User {
    
        private final String name = "hello";
    
        private int age;
    
        private static String address;
    
    }

编译后：

public class User {
        private final String name = "hello";
        private int age;
        private static String address;
    
        public User() {
        }
        // 不包含静态字段address
        public String toString() {
            StringBuilder var10000 = (new StringBuilder()).append("User(name=");
            this.getClass();
            return var10000.append("hello").append(", age=").append(this.age).append(")").toString();
        }
    }

如果没有定义final字段，生成的toString是：

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

**属性解释：**

（1）**includeFieldNames**

设置toString方法中是否包含字段名，默认为true。设置为false，将只会包含字段的值。

默认为true构建的方法：

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

设置为false后：

public String toString() {
        return "User(" + this.name + ", " + this.age + ")";
    }

（2）**exclude**

填写字段名，用来移除字段，此属性会在未来版本废弃。可指定多个值，toString方法将不会包含该字段。比如，移除age：

源码：

@ToString(exclude = {"age"})
    public class User {
    
        private String name = "hello";
    
        private int age;
    
    }

编译后toString方法：

public String toString() {
        return "User(name=" + this.name + ")";
    }

（3）**of**

与exclude相反，of用来指定包含在toString中的字段，此属性会在未来版本废弃。默认of为空数组，为所有非静态字段。比如，包含age：

源码：

@ToString(of = {"age"})
    public class User {
    
        private String name = "hello";
    
        private int age;
    
    }

编译后toString方法：

public String toString() {
        return "User(age=" + this.age + ")";
    }

（4）**callSuper**

设置是否调用父类的toString方法。默认为false。

定义SonUser继承自User：

@ToString
    public class SonUser extends User{
    
        private boolean vip;
    
    }

默认为false时，toString方法：

public String toString() {
        return "SonUser(vip=" + this.vip + ")";
    }

设置为true后，toString方法：

public String toString() {
        return "SonUser(super=" + super.toString() + ", vip=" + this.vip + ")";
    }

（5）**doNotUseGetters**

前提是当字段存在对应的getter方法时，设置获取属性值的时候是否使用getter方法获取值，默认为false，表示可以使用getter方法。

源码：

@ToString
    public class User {
    
        private String name = "hello";
    
        private int age;
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    }

默认为false，toString方法：

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

设置为true，toString方法：

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

（6）**@ToString.Include、onlyExplicitlyIncluded**

两者结合使用，是属性of的替换方法，用于设置包含在方法中的字段。onlyExplicitlyIncluded设置为true，@ToString.Include标记在需要包含的属性或方法上。@ToString.Include只能标注与字段和方法。

源码：

@ToString(onlyExplicitlyIncluded = true)
    public class User {
    
        @ToString.Include
        private String name = "hello";
    
        private int age;
    
    }

编译后toString方法：

public String toString() {
        return "User(name=" + this.name + ")";
    }

（7）**@ToString.Exclude**

属性exclude的替代注解，标记在字段上。

*  **@EqualsAndHashCode**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface EqualsAndHashCode {
    
       String[] exclude() default {};
       
       String[] of() default {};
       
       boolean callSuper() default false;
       
       boolean doNotUseGetters() default false;
       
       CacheStrategy cacheStrategy() default CacheStrategy.NEVER;
       
       AnyAnnotation[] onParam() default {};
       
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
       
       boolean onlyExplicitlyIncluded() default false;
       
       @Target(ElementType.FIELD)
       @Retention(RetentionPolicy.SOURCE)
       public @interface Exclude {}
       
       @Target({ElementType.FIELD, ElementType.METHOD})
       @Retention(RetentionPolicy.SOURCE)
       public @interface Include {
    
          String replaces() default "";
    
          int rank() default 0;
       }
    
       public enum CacheStrategy {
    
          NEVER,
    
          LAZY
       }
    }

重写equals与hashcode方法，标记在类上。

**属性解释：**

（1）像exclude、of等等与前面注解中的作用相同。

（2）**cacheStrategy**

是否缓存hashcode，默认为不缓存。设置为LAZY时，第一次调用hashcode方法会对hashcode值进行缓存，下次再调用，返回缓存的hashcode，无需重新计算。

设置成LAZY，编译后的hashcode方法为：

private transient int $hashCodeCache;
    
    public int hashCode() {
        if (this.$hashCodeCache != 0) {
            return this.$hashCodeCache;
        } else {
            int PRIME = true;
            int result = 1;
            int result = result * 59 + this.age;
            Object $name = this.name;
            result = result * 59 + ($name == null ? 43 : $name.hashCode());
            if (result == 0) {
                result = -2147483648;
            }
    
            this.$hashCodeCache = result;
            return result;
        }
    }

*  **@AllArgsConstructor**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface AllArgsConstructor {
    
       String staticName() default "";
       
       AnyAnnotation[] onConstructor() default {};
       
       AccessLevel access() default lombok.AccessLevel.PUBLIC;
       
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
    }

构建全参构造器（不包含静态属性），标记在类上。

**属性解释：**

（1）**staticName**

当设置了此属性，构建的全参构造器将是private访问权限，并提供一个静态方法，方法名是配置的值，返回类的对象。

源码：

@AllArgsConstructor(staticName = "hello")
    public class User {
    
        private String name = "hello";
    
        private int age;
    
        private static String address;
    
    }

编译后：

public class User {
        private String name = "hello";
        private int age;
        private static String address;
        // 私有的构造器
        private User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public static User hello(String name, int age) {
            return new User(name, age);
        }
    }

（2）**onConstructor**

在生成的全参构造器添加注解。

（3）**access**

设置全参构造器的访问权限，默认为public。

*  **@NoArgsConstructor**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface NoArgsConstructor {
      
       String staticName() default "";
       
       AnyAnnotation[] onConstructor() default {};
       
       AccessLevel access() default lombok.AccessLevel.PUBLIC;
       
       boolean force() default false;
    
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
    }

**属性解释：**

（1）staticName、onConstructor、access同@AllArgsConstructor

（2）**force**

对于final属性，是否强制初始化，默认为否。为否时，若没有显示对final属性初始化，则会提示错误。

比如，默认情况下，没有对final修饰的属性age初始化：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

设置force为true，源码：

@NoArgsConstructor(force = true)
    public class User {
    
        private final String name;
    
        private final int age;
    
        private final boolean vip;
    
    }

编译后：

public class User {
        private final String name = null;
        private final int age = 0;
        private final boolean vip = false;
    
        public User() {
        }
    }

*  **@Builder**

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
    @Retention(RetentionPolicy.SOURCE)
    public @interface Builder {
        String builderMethodName() default "builder";
    
        String buildMethodName() default "build";
    
        String builderClassName() default "";
    
        boolean toBuilder() default false;
    
        AccessLevel access() default AccessLevel.PUBLIC;
    
        String setterPrefix() default "";
    
        @Target({ElementType.FIELD})
        @Retention(RetentionPolicy.SOURCE)
        public @interface Default {
        }
    
        @Target({ElementType.FIELD, ElementType.PARAMETER})
        @Retention(RetentionPolicy.SOURCE)
        public @interface ObtainVia {
            String field() default "";
    
            String method() default "";
    
            boolean isStatic() default false;
        }
    }

使用Builder构建者模式构造类。

**属性解释：**

（1）**builderMethodName**

设置创建builder的方法名，默认为builder。

（2）**buildMethodName**

设置builder中创建对象的build方法，默认为build。

（3）**builderClassName**

设置builder的类名。

（4）**toBuilder**

是否生成toBuilder方法，默认为否，设置为true，将会添加如下方法：

public User.UserBuilder toBuilder() {
        return (new User.UserBuilder()).name(this.name).age(this.age);
    }

（5）**setterPrefix**

设置给属性赋值的方法名前缀，不设置，生成的方法名和字段相同。

*  **@Cleanup**

@Target(ElementType.LOCAL_VARIABLE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Cleanup {
       String value() default "close";
    }

关闭资源使用，标记于局部变量。

**属性解释：**

（1）**value**

设置调用的方法，方法不能含有参数，默认为**close()**方法。

*  **@NonNull**

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE, ElementType.TYPE_USE})
    @Retention(RetentionPolicy.CLASS)
    @Documented
    public @interface NonNull {
    }

使用此注解标记的方法参数或字段，当通过方法修改字段或传入参数使，会进行非空判断，也就是会加入if(xxx=null)的判断。

**使用规则：**

（1）标注的参数或字段必须是引用类型的，对int这样的原生类型无效。

（2）标注在字段上、方法参数上。

源码：

public class User {
    
        @NonNull
        private String name;
    
        private Integer age;
    
        private Boolean vip;
    
        public void changeAge(@NonNull Integer age) {
            this.age = age;
        }
    
    }

编译后：

public class User {
        @NonNull
        private String name;
        private Integer age;
        private Boolean vip;
    
        public User() {
        }
    
        public void changeAge(@NonNull Integer age) {
            if (age == null) {
                throw new NullPointerException("age is marked non-null but is null");
            } else {
                this.age = age;
            }
        }
    }

（3）@NonNull结合@Setter，或@AllArgsConstructor使用

源码：

@Setter
    @AllArgsConstructor
    public class User {
    
        @NonNull
        private String name;
    
        private Integer age;
    
        @NonNull
        private Boolean vip;
        
    }

编译后：

import lombok.NonNull;
    
    public class User {
        @NonNull
        private String name;
        private Integer age;
        @NonNull
        private Boolean vip;
    
        public void setName(@NonNull String name) {
            if (name == null) {
                throw new NullPointerException("name is marked non-null but is null");
            } else {
                this.name = name;
            }
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public void setVip(@NonNull Boolean vip) {
            if (vip == null) {
                throw new NullPointerException("vip is marked non-null but is null");
            } else {
                this.vip = vip;
            }
        }
    
        public User(@NonNull String name, Integer age, @NonNull Boolean vip) {
            if (name == null) {
                throw new NullPointerException("name is marked non-null but is null");
            } else if (vip == null) {
                throw new NullPointerException("vip is marked non-null but is null");
            } else {
                this.name = name;
                this.age = age;
                this.vip = vip;
            }
        }
    }

*  **@RequiredArgsConstructor**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface RequiredArgsConstructor {
    
       String staticName() default "";
       
       AnyAnnotation[] onConstructor() default {};
    
       AccessLevel access() default lombok.AccessLevel.PUBLIC;
       
       @Deprecated
       @Retention(RetentionPolicy.SOURCE)
       @Target({})
       @interface AnyAnnotation {}
    }

对final字段或标记 @NonNull的字段生成参数构造器。

源码：

@RequiredArgsConstructor
    public class User {
    
        @NonNull
        private String name;
    
        private Integer age;
    
        private final Boolean vip;
    
    }

编译后：

import lombok.NonNull;
    
    public class User {
        @NonNull
        private String name;
        private Integer age;
        private final Boolean vip;
    
        public User(@NonNull String name, Boolean vip) {
            if (name == null) {
                throw new NullPointerException("name is marked non-null but is null");
            } else {
                this.name = name;
                this.vip = vip;
            }
        }
    }

*  **@Data**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Data {
       String staticConstructor() default "";
    }

作用是以下几个注解的集合：**@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode**

**属性解释：**

（1）**staticConstructor**

当设置了此属性，构造器将会是private，并且生成一个静态方法，方法名是配置的值，返回值是当前类的对象。

源码：

@Data(staticConstructor="hello")
    public class User {
    
        private String name;
    
        private Integer age;
    
        private final Boolean vip;
    
    }

将staticConstructor配置为"hello"，编译后：

... 省略部分代码
    private User(Boolean vip) {
        this.vip = vip;
    }
    
    public static User hello(Boolean vip) {
        return new User(vip);
    }
    ...省略部分代码

*  **@SneakyThrows**

@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
    @Retention(RetentionPolicy.SOURCE)
    public @interface SneakyThrows {
       Class<? extends Throwable>[] value() default java.lang.Throwable.class;
    }

标注在方法或构造器上。会对方法体使用try...catch。

源码：

@SneakyThrows(NullPointerException.class)
    public void say() {
        System.out.println("hello world");
    }

编译后：

public void say() {
        try {
            System.out.println("hello world");
        } catch (NullPointerException var2) {
            throw var2;
        }
    }

**属性解释：**

（1）**value**

设置catch捕获的异常类型，比如上面例子中捕获空指针异常。

*  **@Synchronized**

@Synchronized
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Synchronized {
    
       String value() default "";
    }

标注在方法上，对方法体进行同步操作。

源码：

@Synchronized
    public void say() {
        System.out.println("hello world");
    }

编译后：

private final Object $lock = new Object[0];
    public void say() {
        synchronized(this.$lock) {
            System.out.println("hello world");
        }
    }

**属性解释：**

（1）**value**

指定synchronized锁住的对象是哪个属性，当指定的字段不存在时，编译会报错。

源码：

private Object hello = new Object();
    
    @Synchronized("hello")
    public void say() {
        System.out.println("hello world");
    }

编译后：

private Object hello = new Object();
    public void say() {
        synchronized(this.hello) {
            System.out.println("hello world");
        }
    }

*  **@Value**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Value {
       String staticConstructor() default "";
    }

标记在类上，将类设置成final类，将非静态字段设置成final字段。作用是以下注解的集合：**@Getter @FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE) @AllArgsConstructor @ToString @EqualsAndHashCode。**

*  **@CommonsLog、@Flogger、@JBossLog、@Log、@Log4j、@Log4j2、@Slf4j、@XSlf4j**

标注在类上，生成日志字段。需要结合响应的日志依赖使用。

**引入依赖：**

**@CommonsLog：**

<dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>xxx</version>
    </dependency>

**@Flogger：**

<dependency>
        <groupId>com.google.flogger</groupId>
        <artifactId>flogger</artifactId>
        <version>xxx</version>
    </dependency>

**@JBossLog：**

<dependency>
        <groupId>org.jboss.logging</groupId>
        <artifactId>jboss-logging</artifactId>
        <version>xxx</version>
    </dependency>

**@Log：**

无需引入依赖，使用JDK自带的java.util.logging.Logger。

**@Log4j：**

**@Log4j2：**

<dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>xxx</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>xxx</version>
    </dependency>

**@Slf4j：**

**@XSlf4j：**

以@CommonsLog为例：

@Retention(RetentionPolicy.SOURCE)
    @Target(ElementType.TYPE)
    public @interface CommonsLog {
       String topic() default "";
    }

属性解释：

（1）**topic**

设置日志的名称，默认为注解标注的类class.getName()。

默认：private static final Log log = LogFactory.getLog(User.class);

topic设置成hello：private static final Log log = LogFactory.getLog("hello");

[Lombok-]: https://blog.csdn.net/weixin_50518271/article/details/113094153?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: /images/20221119/974b850a89cb498eaeb9d677432c4db5.png