Java开发神器Lombok的使用与原理

Dear 丶 2023-06-30 06:47 75阅读 0赞

在面向对象编程中必不可少需要在代码中定义对象模型，而在基于Java的业务平台开发实践中尤其如此。相信大家在平时开发中也深有感触，本来是没有多少代码开发量的，但是因为定义的业务模型对象比较多，而需要重复写Getter/Setter、构造器方法、字符串输出的ToString方法和Equals/HashCode方法等。那么是否一款插件或工具能够替大家完成这些繁琐的操作呢？本文将向大家介绍一款在Eclipse/Intellij IDEA主流的开发环境中都可以使用的Java开发神器，同时简要地介绍下其背后自定义注解的原理。

Lombok的简介

Lombok是一款Java开发插件，使得Java开发者可以通过其定义的一些注解来消除业务工程中冗长和繁琐的代码，尤其对于简单的Java模型对象（POJO）。在开发环境中使用Lombok插件后，Java开发人员可以节省出重复构建，诸如hashCode和equals这样的方法以及各种业务对象模型的accessor和ToString等方法的大量时间。对于这些方法，它能够在编译源代码期间自动帮我们生成这些方法，并没有如反射那样降低程序的性能。

在Intellij中安装Lombok的插件

想要体验一把Lombok的话，得先在自己的开发环境中安装上对应的插件。下面先为大家展示下如何在Intellij中安装上Lombok插件。

通过IntelliJ的插件中心寻找Lombok并安装

file

file

另外需要注意的是，在使用lombok注解的时候记得要导入lombok.jar包到工程，如果使用的是Maven的工程项目的话，要在其pom.xml中添加依赖如下：

  1. <dependency>
  2.     <groupId>org.projectlombok</groupId>
  3.     <artifactId>lombok</artifactId>
  4.     <version>1.16.8</version>
  5. </dependency>

好了，就这么几步后就可以在Java工程中开始用Lombok这款开发神器了。下文将会给大家介绍Lombok中一些注解的使用方法，让大家对如何用这些注解有一个大致的了解。

Lombok注解使用方法

Lombok常用注解介绍

下面先来看下Lombok中主要几个常用注解介绍：

  1. Val 可以将变量申明是final类型
  2. @NonNull 能够为方法或构造函数的参数提供非空检查
  3. @Cleanup 能够自动释放资源
  4. @Getter/@Setter 可以针对类的属性字段自动生成Get/Set方法
  5. @ToString 使用该注解的类生成一个toString方法
  6. @EqualsAndHashCode 使用该注解的类自动生成equals和hashCode方法
  7. @NoArgsConstructor, @RequiredArgsConstructor, @AllArgsConstructor,这几个注解分别为类自动生成了无参构造器、指定参数的构造器和包含所有参数的构造器。
  8. @Data注解作用比较全，其包含注解的集合@ToString，@EqualsAndHashCode，所有字段的@Getter和所有非final字段的@Setter, @RequiredArgsConstructor等
  9. @Builder注解提供了一种比较推崇的构建值对象的方式
  10. @Synchronized注解类似Java中的Synchronized 关键字，但是可以隐藏同步锁

Lombok的基本使用示例

（1）val 可以将变量申明是final类型。

  1. public   static void main(String[] args) {
  3.     val setVar = new HashSet<String>();
  4.     val listsVar = new   ArrayList<String>();
  5.     val mapVar = new HashMap<String,   String>();
  7.     //=>上面代码相当于如下：
  8.     final Set<String> setVar2 = new   HashSet<>();
  9.     final List<String> listsVar2 = new   ArrayList<>();
  10.     final Map<String, String> maps2 =   new HashMap<>();
  12. }

（2）@NonNull注解能够为方法或构造函数的参数提供非空检查。

  1. public void notNullExample(@NonNull String string) {
  2.     //方法内的代码
  3. }
  5. //=>上面代码相当于如下：
  7. public void notNullExample(String string) {
  8.     if (string != null) {
  9.         //方法内的代码相当于如下：
  10.     } else {
  11.         throw new NullPointerException("null");
  12.     }
  13. }

（3）@Cleanup注解能够自动释放资源。

  1. public   void jedisExample(String[] args) {
  2.     try {
  3.         @Cleanup Jedis jedis =   redisService.getJedis();
  4.     } catch (Exception ex) {
  5.         logger.error(“Jedis异常:”,ex)
  6.     }
  8.     //=>上面代码相当于如下：
  9.     Jedis jedis= null;
  10.     try {
  11.         jedis = redisService.getJedis();
  12.     } catch (Exception e) {
  13.         logger.error(“Jedis异常:”,ex)
  14.     } finally {
  15.         if (jedis != null) {
  16.             try {
  17.                 jedis.close();
  18.             } catch (Exception e) {
  19.                 e.printStackTrace();
  20.             }
  21.         }
  22.     }
  23. }

（4）@Getter/@Setter注解可以针对类的属性字段自动生成Get/Set方法。

  1. public class OrderCreateDemoReq{
  3.     @Getter
  4.     @Setter
  5.     private String customerId;
  7.     @Setter
  8.     @Getter
  9.     private String poolId;
  11.     //其他代码……
  12. }
  14. //上面请求Req类的代码相当于如下：
  16. public class OrderCreateDemoReq{
  17.     private String customerId;    
  18.     private String poolId;
  20.     public String getCustomerId(){
  21.          return customerId;
  22.     }
  24.     public String getPoolId(){
  25.          return poolId;
  26.     }
  28.     public void setCustomerId(String customerId){
  29.          this.customerId = customerId;
  30.     }
  32.     public void setPoolId(String poolId){
  33.          this.pool = pool;
  34.     }
  36. }

（5）@ToString注解，为使用该注解的类生成一个toString方法，默认的toString格式为：ClassName(fieldName= fieleValue ,fieldName1=fieleValue)。

  1. @ToString(callSuper=true,exclude="someExcludedField")
  2. public   class Demo extends Bar {
  4.     private boolean someBoolean = true;
  5.     private String someStringField;
  6.     private float someExcludedField;
  8. }
  10. //上面代码相当于如下：
  12. public   class Demo extends Bar {
  14.     private boolean someBoolean = true;
  15.     private String someStringField;
  16.     private float someExcludedField;
  18.     @ Override
  19.     public String toString() {
  20.         return "Foo(super=" +   super.toString() +
  21.             ", someBoolean=" +   someBoolean +
  22.             ", someStringField=" +   someStringField + ")";
  23.     }
  24. }

（6）@EqualsAndHashCode注解，为使用该注解的类自动生成equals和hashCode方法。

  1. @EqualsAndHashCode(exclude = {"id"}, callSuper =true)
  2. public class LombokDemo extends Demo{
  3.     private int id;
  4.     private String name;
  5.     private String gender;
  6. }
  8. //上面代码相当于如下：
  10. public class LombokDemo extends Demo{
  12.     private int id;
  13.     private String name;
  14.     private String gender;
  16.     @Override
  17.     public boolean equals(final Object o) {
  18.         if (o == this) return true;
  19.         if (o == null) return false;
  20.         if (o.getClass() != this.getClass()) return false;
  21.         if (!super.equals(o)) return false;
  22.         final LombokDemo other = (LombokDemo)o;
  23.         if (this.name == null ? other.name != null : !this.name.equals(other.name)) return false;
  24.         if (this.gender == null ? other.gender != null : !this.gender.equals(other.gender)) return false;
  25.         return true;
  26.     }
  28.     @Override
  29.     public int hashCode() {
  30.         final int PRIME = 31;
  31.         int result = 1;
  32.         result = result * PRIME + super.hashCode();
  33.         result = result * PRIME + (this.name == null ? 0 : this.name.hashCode());
  34.         result = result * PRIME + (this.gender == null ? 0 : this.gender.hashCode());
  35.         return result;
  36.     }
  38. }

(7) @NoArgsConstructor, @RequiredArgsConstructor, @AllArgsConstructor,这几个注解分别为类自动生成了无参构造器、指定参数的构造器和包含所有参数的构造器。

  1. @RequiredArgsConstructor(staticName = "of")
  2. @AllArgsConstructor(access = AccessLevel.PROTECTED)
  3. public class ConstructorExample<T> {
  5.   private int x, y;
  6.   @NonNull private T description;
  8.   @NoArgsConstructor
  9.   public static class NoArgsExample {
  10.     @NonNull private String field;
  11.   }
  13. }
  15. //上面代码相当于如下：
  16. @RequiredArgsConstructor(staticName = "of")
  17. @AllArgsConstructor(access = AccessLevel.PROTECTED)
  18. public class ConstructorExample<T> {
  20.   private int x, y;
  21.   @NonNull private T description;
  23.   @NoArgsConstructor
  24.   public static class NoArgsExample {
  25.     @NonNull private String field;
  26.   }
  28. }
  30. public class ConstructorExample<T> {
  31.   private int x, y;
  32.   @NonNull private T description;
  34.   private ConstructorExample(T description) {
  35.     if (description == null) throw new NullPointerException("description");
  36.     this.description = description;
  37.   }
  39.   public static <T> ConstructorExample<T> of(T description) {
  40.     return new ConstructorExample<T>(description);
  41.   }
  43.   @java.beans.ConstructorProperties({"x", "y", "description"})
  44.   protected ConstructorExample(int x, int y, T description) {
  45.     if (description == null) throw new NullPointerException("description");
  46.     this.x = x;
  47.     this.y = y;
  48.     this.description = description;
  49.   }
  51.   public static class NoArgsExample {
  52.     @NonNull private String field;
  54.     public NoArgsExample() {
  55.     }
  56.   }
  57. }

（8）@Data注解作用比较全，其包含注解的集合@ToString，@EqualsAndHashCode，所有字段的@Getter和所有非final字段的@Setter, @RequiredArgsConstructor。其示例代码可以参考上面几个注解的组合。

（9）@Builder注解提供了一种比较推崇的构建值对象的方式。

  1. @Builder 
  2. public class BuilderExample { 
  4.   private String name; 
  5.   private int age; 
  7.   @Singular private Set<String> occupations; 
  9. }
  11. //上面代码相当于如下：
  13. public class BuilderExample { 
  15.   private String name; 
  16.   private int age; 
  17.   private Set<String> occupations; 
  19.   BuilderExample(String name, int age, Set<String> occupations) { 
  20.     this.name = name; 
  21.     this.age = age; 
  22.     this.occupations = occupations; 
  23.   } 
  25.   public static BuilderExampleBuilder builder() { 
  26.     return new BuilderExampleBuilder(); 
  27.   } 
  29.   public static class BuilderExampleBuilder { 
  31.     private String name; 
  32.     private int age; 
  33.     private java.util.ArrayList<String> occupations;    
  35.     BuilderExampleBuilder() { 
  36.     } 
  38.     public BuilderExampleBuilder name(String name) { 
  39.       this.name = name; 
  40.       return this; 
  41.     } 
  43.     public BuilderExampleBuilder age(int age) { 
  44.       this.age = age; 
  45.       return this; 
  46.     } 
  48.     public BuilderExampleBuilder occupation(String occupation) { 
  49.       if (this.occupations == null) { 
  50.         this.occupations = new java.util.ArrayList<String>(); 
  51.       } 
  52.       this.occupations.add(occupation); 
  53.       return this; 
  54.     } 
  56.     public BuilderExampleBuilder occupations(Collection<? extends String> occupations) { 
  57.       if (this.occupations == null) { 
  58.         this.occupations = new java.util.ArrayList<String>(); 
  59.       } 
  60.       this.occupations.addAll(occupations); 
  61.       return this; 
  62.     } 
  64.     public BuilderExampleBuilder clearOccupations() { 
  65.       if (this.occupations != null) { 
  66.         this.occupations.clear(); 
  67.       }
  68.       return this; 
  69.     } 
  71.     public BuilderExample build() {  
  72.       Set<String> occupations = new HashSet<>(); 
  73.       return new BuilderExample(name, age, occupations); 
  74.     } 
  76.     @verride 
  77.     public String toString() { 
  78.       return "BuilderExample.BuilderExampleBuilder(name = " + this.name + ", age = " + this.age + ", occupations = " + this.occupations + ")"; 
  79.     } 
  80.   } 
  81. }

（10）@Synchronized注解类似Java中的Synchronized 关键字，但是可以隐藏同步锁。

  1. public class SynchronizedExample { 
  3.  private final Object readLock = new   Object(); 
  5.  @Synchronized 
  6.  public static void hello() { 
  7.      System.out.println("world");   
  8.  } 
  10.  @Synchronized("readLock") 
  11.  public void foo() { 
  12.    System.out.println("bar"); 
  13.  } 
  15. //上面代码相当于如下：
  17.  public class SynchronizedExample { 
  19.   private static final Object $LOCK = new   Object[0]; 
  20.   private final Object readLock = new   Object(); 
  22.   public static void hello() { 
  23.     synchronized($LOCK) { 
  24.       System.out.println("world"); 
  25.     } 
  26.   }   
  28.   public void foo() { 
  29.     synchronized(readLock) { 
  30.         System.out.println("bar");   
  31.     } 
  32.   } 
  34. }

Lombok背后的自定义注解原理

本文在前三章节主要介绍了Lombok这款Java开发利器中各种定义注解的使用方法，但作为一个Java开发者来说光了解插件或者技术框架的用法只是做到了“知其然而不知其所以然”，如果真正掌握其背后的技术原理，看明白源码设计理念才能真正做到“知其然知其所以然”。好了，话不多说下面进入本章节的正题，看下Lombok背后注解的深入原理。

可能熟悉Java自定义注解的同学已经猜到，Lombok这款插件正是依靠可插件化的Java自定义注解处理API（JSR 269: Pluggable Annotation Processing API）来实现在Javac编译阶段利用“Annotation Processor”对自定义的注解进行预处理后生成真正在JVM上面执行的“Class文件”。有兴趣的同学反编译带有Lombok注解的类文件也就一目了然了。其大致执行原理图如下：

file

file

从上面的这个原理图上可以看出Annotation Processing是编译器在解析Java源代码和生成Class文件之间的一个步骤。其中Lombok插件具体的执行流程如下：

file

file

从上面的Lombok执行的流程图中可以看出，在Javac 解析成AST抽象语法树之后, Lombok 根据自己编写的注解处理器，动态地修改 AST，增加新的节点（即Lombok自定义注解所需要生成的代码），最终通过分析生成JVM可执行的字节码Class文件。使用Annotation Processing自定义注解是在编译阶段进行修改，而JDK的反射技术是在运行时动态修改，两者相比，反射虽然更加灵活一些但是带来的性能损耗更加大。

需要更加深入理解Lombok插件的细节，自己查阅其源代码是必比可少的。对开源框架代码比较有执着追求的童鞋可以将Lombok的源代码工程从github上download到本地进行阅读和自己调试。下图为Lombok工程源代码的截图：

file

file

从熟悉JSR 269: Pluggable Annotation Processing API的同学可以从工程类结构图中发现AnnotationProcessor这个类是Lombok自定义注解处理的入口。该类有两个比较重要的方法一个是init方法，另外一个是process方法。在init方法中，先用来做参数的初始化，将AnnotationProcessor类中定义的内部类（JavacDescriptor、EcjDescriptor）先注册到ProcessorDescriptor类型定义的列表中。其中，内部静态类—JavacDescriptor在其加载的时候就将lombok.javac.apt.LombokProcessor这个类进行对象实例化并注册。

在LombokProcessor处理器中，其中的process方法会根据优先级来分别运行相应的handler处理类。Lombok中的多个自定义注解都分别有对应的handler处理类，如下图所示：

file

file

可以看出，在Lombok中对于其自定义注解进行实际的替换、修改和处理的正是这些handler类。对于其实现的细节可以具体参考其中的代码。

本文先从Lombok使用角度出发，先介绍了如何在当前主流的Java开发环境—Intellij中安装这块Java插件，随后分别介绍了Lombok中几种主要的常用注解（比如，@Data、@CleanUp、@ToString和@Getter/Setter等），最后将Lombok背后Java自定义注解的原理与源代码结合起来，介绍了Lombok插件背后具体的执行处理流程。限于篇幅，未能对“自定义Java注解处理器”的具体实践和原理进行阐述，后面将另起专题篇幅进行介绍。限于笔者的才疏学浅，对本文内容可能还有理解不到位的地方，如有阐述不合理之处还望留言一起探讨。

发表评论

表情：
评论列表 （有 0 条评论，75人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java开发神器Lombok的使用与原理

    在面向对象编程中必不可少需要在代码中定义对象模型，而在基于Java的业务平台开发实践中尤其如此。相信大家在平时开发中也深有感触，本来是没有多少代码开发量的，但是因为定义的业务模

    Dear 丶Dear 丶/ 0 赞/ 76 阅读

    相关 Lombok神器带你飞（简化POJO）

    前言 遇到残暴的大佬，心里不由得为代码暗暗揪了心，不过撸码残暴起来，也是感觉到了一丝丝的爽~ 今天为大家介绍一个神器：Lombok。 希望各种各样的神器带来便捷的同时也为

    小咪咪小咪咪/ 0 赞/ 381 阅读