2021Lombok开发小册——是可达鸭

最新推荐文章于 2023-06-08 17:42:47 发布

永寂如孤星

最新推荐文章于 2023-06-08 17:42:47 发布

阅读量392

点赞数 2

文章标签： lombok java

本文链接：https://blog.csdn.net/yjrguxing/article/details/116746157

版权

常用注解

常用注解中会讲解我们实际开发中经常会用到的注解

@Getter

@Getter注解会自动生成类中变量的Get方法，不包括被staticl修饰的变量，具体解析以及lombok实际生成的代码如下

import lombok.AccessLevel;

//默认访问级别为public
@lombok.Getter
public class Getter {
    private Integer lombokTestInt;

    //@Getter(AccessLevel.NONE) 访问级别 无 不允许访问 不会生成相应Get方法
    //@Getter(AccessLevel.MODULE) 访问级别 默认 =不写访问修饰符
    //@Getter(AccessLevel.PRIVATE) 访问级别 私有 =private
    //@Getter(AccessLevel.PUBLIC) 访问级别 公开 =public
    //@Getter(AccessLevel.PACKAGE) 访问级别 包 同包下可访问
    //@Getter(AccessLevel.PROTECTED) 访问级别 受保护的 =protected
    @lombok.Getter(AccessLevel.PROTECTED)
    private char lombokTestchar;
    //静态变量不受Getter影响 不会生成Getter方法
    private static String lombokTestString;
    //常量受Getter影响 
    private final boolean flag = false;
    //lombok实际生成的代码
//    public Integer getLombokTestInt(){
//        return lombokTestInt;
//    }
//    protected char getLombokTestchar(){
//        return lombokTestchar;
//    }
}

Structure中也可以看出生成了哪些方法
在这里插入图片描述

boolean问题

使用@Getter注解时，你会遇到boolean问题，如下
在这里插入图片描述
相比于其他类型的变量，boolean显得有些独树一帜，他的get方法并不是get变量名()，而是会被替换成is变量名()，不过他的包装类Boolean并不会出现此问题。

@Setter

@Setter和@Getter的用法基本一致，只不过生成的是set方法，具体生成代码如下

import lombok.AccessLevel;

//默认访问级别为public
@lombok.Setter
public class Setter {
    private Integer lombokTestInt;

    //@Setter(AccessLevel.NONE) 访问级别 无 不允许访问 不会生成相应Get方法
    //@Setter(AccessLevel.MODULE) 访问级别 默认 =不写访问修饰符
    //@Setter(AccessLevel.PRIVATE) 访问级别 私有 =private
    //@Setter(AccessLevel.PUBLIC) 访问级别 公开 =public
    //@Setter(AccessLevel.PACKAGE) 访问级别 包 同包下可访问
    //@Setter(AccessLevel.PROTECTED) 访问级别 受保护的 =protected
    @lombok.Setter(AccessLevel.PROTECTED)
    private char lombokTestchar;
    //静态变量不受Setter影响 不会生成Setter方法
    private static String lombokTestString;
    //常量不受Setter影响 不会生成Setter方法
    private final boolean flag = false;
    private boolean isFlag = true;
    //lombok实际生成的代码
//    public Integer setLombokTestInt(){
//        return lombokTestInt;
//    }
//    protected char setLombokTestchar(){
//        return lombokTestchar;
//    }
}

Structure中也可以看出生成了哪些方法，相比@Getter，@Setter并不对常量起作用
在这里插入图片描述

boolean问题

相对于@Getter，@Setter的boolean问题在于，当你的boolean变量名符合驼峰命名同时小写前缀为is时，会被省略掉，如上图，同样的，Boolean包装类不受影响。

@ToString

我们先来看一下默认从Object处继承来的ToString（）

public class ToString {

    private Integer lombokTestInt;

    private char lombokTestchar;
    private static String lombokTestString;
    private final boolean flag = false;
    private boolean isFlag = true;

    public static void main(String[] args) {
        System.out.println(new ToString().toString());
        //ToString@4554617c
        //4554617c为类的物理地址经过hashcode压缩后
        //再用toHexString转为16进制无符号位的数字String所得
    }
}

这显然不是我们实际开发所需要的输出，我们再来看一下ToString注解所形成的的输出

@lombok.ToString
public class ToString {

    private Integer lombokTestInt;

    private char lombokTestchar;
    private static String lombokTestString;
    private final boolean flag = false;
    private boolean isFlag = true;

    public static void main(String[] args) {
        System.out.println(new ToString().toString());
        //ToString(lombokTestInt = null, lombokTestchar =, flag = false, isFlag = true)
    }
}

很显然，这类数据是符合我们的需求的，那么再补充几个细节，如下

/**
 * 需要注意的是,ToString注解只能作用于类上,不能作用于变量和方法上
 * 1.可以通过设置includeFieldNames=false使输出不再带有key值 默认为true
 * 例：@ToString(includeFieldNames = false)
 * 2.可以通过设置exclude使部分变量不会输出
 * 例：@ToString(exclude = {"lombokTestInt","lombokTestchar"})
 * 3.可以通过设置of使ToString只输出选中变量
 * 例：@ToString(of = {"lombokTestInt","lombokTestchar"})
 * 4.可以通过设置callSuper为true来调用父类的ToString
 * 例：@ToString(callSuper = true)
 */
@lombok.ToString(callSuper = true)
public class ToString {

    private Integer lombokTestInt;

    private char lombokTestchar;
    private static String lombokTestString;
    private final boolean flag = false;
    private boolean isFlag = true;

    public static void main(String[] args) {
        System.out.println(new ToString().toString());
        //ToString(super=ToString@4554617c, lombokTestInt=null, lombokTestchar= , flag=false, isFlag=true)
    }
    //实际生成的代码
//    @Override
//    public String toString() {
//        return "ToString{" + super.toString() +
//                "lombokTestInt=" + lombokTestInt +
//                ", lombokTestchar=" + lombokTestchar +
//                ", flag=" + flag +
//                ", isFlag=" + isFlag +
//                '}';
//    }
}
class A{
    private int a;
    private boolean b;
}

@EqualsAndHashCode

@EqualsAndHashCode用于生成equals方法和hasecode方法，具体如下

/**
 * 需要注意的是,EqualsAndHashCode注解只能作用于类上,不能作用于变量和方法上
 * 1.生成的equals和hashcode方法不会考虑静态变量和瞬态变量
 * 2.可以通过设置exclude使部分变量不被使用
 * 例：@EqualsAndHashCode(exclude = {"lombokTestInt","lombokTestchar"})
 * 3.可以通过设置of使ToString只使用选中变量
 * 例：@EqualsAndHashCode(of = {"lombokTestInt","lombokTestchar"})
 * 4.可以通过设置callSuper为true来调用父类的equals及hashcode来验证相等性
 * 例：@EqualsAndHashCode(callSuper = true)
 * 需要注意，如果父类没有重写equals/hashcode方法，而使用Object的,则会出现相等性问题,lombok会进行报错
 */
@lombok.EqualsAndHashCode
public class EqualsAndHashCode {
    private Integer lombokTestInt;

    private char lombokTestchar;
    private static String lombokTestString;
    private final boolean flag = false;
    private boolean isFlag = true;
    //实际lombok生成的代码
//    public boolean equals(Object o) {
//        if (o == this) {
//            return true;
//        } else if (!(o instanceof EqualsAndHashCode)) {
//            return false;
//        } else {
//            EqualsAndHashCode other = (EqualsAndHashCode) o;
//            if (!other.canEqual(this)) {
//                return false;
//            } else {
//                label35:
//                {
//                    Object this$lombokTestInt = this.lombokTestInt;
//                    Object other$lombokTestInt = other.lombokTestInt;
//                    if (this$lombokTestInt == null) {
//                        if (other$lombokTestInt == null) {
//                            break label35;
//                        }
//                    } else if (this$lombokTestInt.equals(other$lombokTestInt)) {
//                        break label35;
//                    }
//
//                    return false;
//                }
//
//                if (this.lombokTestchar != other.lombokTestchar) {
//                    return false;
//                } else {
//                    this.getClass();
//                    other.getClass();
//                    if (false) {
//                        return false;
//                    } else {
//                        return this.isFlag == other.isFlag;
//                    }
//                }
//            }
//        }
//    }
//
//    protected boolean canEqual(Object other) {
//        return other instanceof EqualsAndHashCode;
//    }
//
//    public int hashCode() {
//        int PRIME = true;
//        int result = 1;
//        Object $lombokTestInt = this.lombokTestInt;
//        int result = result * 59 + ($lombokTestInt == null ? 43 : $lombokTestInt.hashCode());
//        result = result * 59 + this.lombokTestchar;
//        int var10000 = result * 59;
//        this.getClass();
//        result = var10000 + 97;
//        result = result * 59 + (this.isFlag ? 79 : 97);
//        return result;
//    }
}

为什么equals和hashcode要一起重写？

在Object类中hashcode这一方法的注释上，对hashcode及equals提出了3个常规协定。
1.同一个对象多次调用hashcode所得到的的值应该是相同的
2.如果2个对象使用.equals得到true时，则他们的hashcodd值应该相等
3.如果2个对象使用.equals得到false时，则他们的hashcode值应该不相等

同时hashcode的作用为判断两个对象是否相等，具体做法也在注释中写明：将对象的地址通过一种方式转换为整数，由此可以看出hashcode比较的是对象地址。

了解了上面的情况，我们再回头看这个问题，为什么equals和hashcode要一起重写？
我们重写equals方法的本意是为了让equals方法可以比较对象的值，在此情况下就会出现一种情况
当equals相等时，hashcode可能不相等，这就违反了hashcode方法的第二个常规协定
为了避免这一情况的发生，所以一般equals和hashcode一起重写

@NonNull

@NonNull注解用于对变量进行空值检查，具体如下

import lombok.Data;
import lombok.Getter;
import lombok.Setter;

/**
 * NonNull注解用于对变量进行空值检查
 *可以直接放在变量上,也可以放在自己写的get/set方法上
 *这里只讨论直接放在变量上的情况，因为已通过@Getter、@Setter注解生成get/set方法
 * 注解@Data的功效之一是,为本类创建一个公共构造方法,参数包括了所有final变量和被@NonNull所修饰的变量
 * 请注意，这会影响无参构造的自动构建，如果此类没有final变量和被@NonNull所修饰的变量
 * 那么@Data会自动生成一个无参构造
 * 对于@Data的其他效果将在后面做统一介绍
 *
 * NonNull的空值检查会作用于 创建包含此变量的对象时、调用此变量的Get/Set方法时
 * 1.NonNull注解对于引用数据类型的get/set有效
 * 2.NonNull注解对于基本数据类型的get/set有效
 * 3.NonNull注解对于被Static修饰变量的get/set无效
 * 4.NonNull注解对于被final修饰变量的get有效
 * 5.NonNull注解对于未赋值的引用数据类型、基本数据类型、final类型
 * 在由Data生成的构造函数中会包含这些参数并且进行空值检查
 *
 * 对于所有未经过空值检查的数据,即数据为Null,则Lombok会产生一个NullPointException
 *
 * 如果变量同时使用了notnull注解,则NonNull注解不会生效
 */
@Setter
@Getter
@Data//后面会讲别着急
public class NonNull {
    @lombok.NonNull
    private Integer lombokTestInt;
    @lombok.NonNull
    private Integer lombokTestIntB = 2;

    @lombok.NonNull
    private char lombokTestchar;
    @lombok.NonNull
    private char lombokTestcharB = 'A';
    @lombok.NonNull
    private static String lombokTestString;
    @lombok.NonNull
    private static String lombokTestStringB = "A";

    @lombok.NonNull
    private final boolean flag;
    @lombok.NonNull
    private final boolean flagB = true;

    public static void main(String[] args) {
        NonNull nonNull = new NonNull(1, 'B', true);
    }

    //lombok实际生成的与NonNull相关的代码
    //public void setLombokTestInt(@lombok.NonNull Integer lombokTestInt) {
    //        if (lombokTestInt == null) {
    //            throw new NullPointerException("lombokTestInt is marked non-null but is null");
    //        } else {
    //            this.lombokTestInt = lombokTestInt;
    //        }
    //    }
    //
    //    public void setLombokTestIntB(@lombok.NonNull Integer lombokTestIntB) {
    //        if (lombokTestIntB == null) {
    //            throw new NullPointerException("lombokTestIntB is marked non-null but is null");
    //        } else {
    //            this.lombokTestIntB = lombokTestIntB;
    //        }
    //    }
    //
    //    public void setLombokTestchar(@lombok.NonNull char lombokTestchar) {
    //        this.lombokTestchar = lombokTestchar;
    //    }
    //
    //    public void setLombokTestcharB(@lombok.NonNull char lombokTestcharB) {
    //        this.lombokTestcharB = lombokTestcharB;
    //    }
    //
    //    @lombok.NonNull
    //    public Integer getLombokTestInt() {
    //        return this.lombokTestInt;
    //    }
    //
    //    @lombok.NonNull
    //    public Integer getLombokTestIntB() {
    //        return this.lombokTestIntB;
    //    }
    //
    //    @lombok.NonNull
    //    public char getLombokTestchar() {
    //        return this.lombokTestchar;
    //    }
    //
    //    @lombok.NonNull
    //    public char getLombokTestcharB() {
    //        return this.lombokTestcharB;
    //    }
    //
    //    @lombok.NonNull
    //    public boolean isFlag() {
    //        return this.flag;
    //    }
    //
    //    @lombok.NonNull
    //    public boolean isFlagB() {
    //        this.getClass();
    //        return true;
    //    }
    //
    //    public NonNull(@lombok.NonNull Integer lombokTestInt, @lombok.NonNull char lombokTestchar, @lombok.NonNull boolean flag) {
    //        if (lombokTestInt == null) {
    //            throw new NullPointerException("lombokTestInt is marked non-null but is null");
    //        } else {
    //            this.lombokTestInt = lombokTestInt;
    //            this.lombokTestchar = lombokTestchar;
    //            this.flag = flag;
    //        }
    //    }
}

@Date

@Date注解是Lombok中最常用的注解，他包含了@ToString, @EqualsAndHashCode, @Getter, 和 @Setter，具体如下

/**
 * 此注解结合了@ToString,@EqualsAndHashCode,@Getter和@Setter的功能
 * 它相当于在类上打上了@ToString,@EqualsAndHashCode这两个注解
 * 并在每一个变量上加上了@Getter和@Setter注解
 * 并且和NonNull注解会有联动，可自行查看上文中NonNull注解的解释
 *
 * 如果你需要一个静态工厂来作为final变量的set方法，可以通过设置staticConstructor
 * 参数名来创建一个以此为名字的公开静态工厂
 * 例@lombok.Data(staticConstructor = "of")
 *
 * 大部分情况下 对一个pojo(普通java对象)打上此注解可以提供所需的一切
 */
@lombok.Data(staticConstructor = "of")
public class Data {
    public int a;
    private  boolean flag;
    public final int  ab;
    private final double abc;
    //lombok生成的代码
    // private Data(int ab, double abc) {
    //        this.ab = ab;
    //        this.abc = abc;
    //    }
    //
    //    public static Data of(int ab, double abc) {
    //        return new Data(ab, abc);
    //    }
    //
    //    public int getA() {
    //        return this.a;
    //    }
    //
    //    public boolean isFlag() {
    //        return this.flag;
    //    }
    //
    //    public int getAb() {
    //        return this.ab;
    //    }
    //
    //    public double getAbc() {
    //        return this.abc;
    //    }
    //
    //    public void setA(int a) {
    //        this.a = a;
    //    }
    //
    //    public void setFlag(boolean flag) {
    //        this.flag = flag;
    //    }
    //
    //    public boolean equals(Object o) {
    //        if (o == this) {
    //            return true;
    //        } else if (!(o instanceof Data)) {
    //            return false;
    //        } else {
    //            Data other = (Data)o;
    //            if (!other.canEqual(this)) {
    //                return false;
    //            } else if (this.getA() != other.getA()) {
    //                return false;
    //            } else if (this.isFlag() != other.isFlag()) {
    //                return false;
    //            } else if (this.getAb() != other.getAb()) {
    //                return false;
    //            } else {
    //                return Double.compare(this.getAbc(), other.getAbc()) == 0;
    //            }
    //        }
    //    }
    //
    //    protected boolean canEqual(Object other) {
    //        return other instanceof Data;
    //    }
    //
    //    public int hashCode() {
    //        int PRIME = true;
    //        int result = 1;
    //        int result = result * 59 + this.getA();
    //        result = result * 59 + (this.isFlag() ? 79 : 97);
    //        result = result * 59 + this.getAb();
    //        long $abc = Double.doubleToLongBits(this.getAbc());
    //        result = result * 59 + (int)($abc >>> 32 ^ $abc);
    //        return result;
    //    }
    //
    //    public String toString() {
    //        return "Data(a=" + this.getA() + ", flag=" + this.isFlag() + ", ab=" + this.getAb() + ", abc=" + this.getAbc() + ")";
    //    }
}

@cleanup

此注解已被JDK1.7新特性自动资源管理所替代，所以不过多赘述，有兴趣的可以自己了解

最后更新于2021年5月20日本篇文章未完一周内续
原创不易，如果该文章对你有所帮助，望左上角点击关注~如有任何技术相关问题，可通过评论联系我讨论,我会在力所能及之内进行相应回复以及开单章解决该问题.

该文章如有任何错误请在评论中指出，感激不尽，转载请附出处！
*个人博客首页：https://blog.csdn.net/yjrguxing ——您的每个关注和评论都对我意义重大

永寂如孤星

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
3
评论
2021Lombok开发小册——是可达鸭

@Getterimport lombok.AccessLevel;import lombok.Getter;//默认访问级别为public@Getterpublic class LomBokTest { private Integer lombokTestInt; //@Getter(AccessLevel.NONE) 访问级别无不允许访问不会生成相应Get方法 //@Getter(AccessLevel.MODULE) 访问级别默认 =不写访问修饰符
复制链接

扫一扫