1. 程式人生 > >lombok註解介紹

lombok註解介紹

lombok註解介紹

lombok註解文件
lombok官網下載

lombok是一個可以幫助我們簡化java程式碼編寫的工具類,尤其是簡化javabean的編寫,即通過採用註解的方式,消除程式碼中的構造方法,getter/setter等程式碼,使我們寫的類更加簡潔,當然,這帶來的副作用就是不易閱讀…不過,還是能看得懂吧,廢話不多說,先看一下lombok支援的一些常見的註解。

  1. @NonNull
  2. @Cleanup
  3. @Getter/@Setter
  4. @ToString
  5. @EqualsAndHashCode
  6. @NoArgsConstructor/@RequiredArgsConstructor /@AllArgsConstructor
  7. @Data
  8. @Value
  9. @SneakyThrows
  10. @Synchronized
  11. @Log

@NonNull

這個註解可以用在成員方法或者構造方法的引數前面,會自動產生一個關於此引數的非空檢查,如果引數為空,則丟擲一個空指標異常,舉個例子來看看:

//成員方法引數加上@NonNull註解
public String getName(@NonNull Person p){
    return p.getName();
}
  • 1
  • 2
  • 3
  • 4

實際效果相當於:

public String getName(@NonNull Person p){
    if(p==null){
        throw new NullPointerException("person");
    }
    return p.getName();
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

用在構造方法的引數上效果類似,就不再舉例子了。

@Cleanup

這個註解用在變數前面,可以保證此變數代表的資源會被自動關閉,預設是呼叫資源的close()方法,如果該資源有其它關閉方法,可使用@Cleanup(“methodName”)來指定要呼叫的方法,就用輸入輸出流來舉個例子吧:

public static void main(String[] args) throws IOException {
     @Cleanup InputStream in = new FileInputStream(args[0]);
     @Cleanup OutputStream out = new FileOutputStream(args[1]);
     byte[] b = new byte[1024];
     while (true) {
       int r = in.read(b);
       if (r == -1) break;
       out.write(b, 0, r);
     }
 }
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

實際效果相當於:

public static void main(String[] args) throws IOException {
     InputStream in = new FileInputStream(args[0]);
     try {
       OutputStream out = new FileOutputStream(args[1]);
       try {
         byte[] b = new byte[10000];
         while (true) {
           int r = in.read(b);
           if (r == -1) break;
           out.write(b, 0, r);
         }
       } finally {
         if (out != null) {
           out.close();
         }
       }
     } finally {
       if (in != null) {
         in.close();
       }
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

是不是簡化了很多。

@Getter/@Setter

這一對註解從名字上就很好理解,用在成員變數前面,相當於為成員變數生成對應的get和set方法,同時還可以為生成的方法指定訪問修飾符,當然,預設為public,直接來看下面的簡單的例子:

public class Programmer{
    @Getter
    @Setter
    private String name;

    @Setter(AccessLevel.PROTECTED)
    private int age;

    @Getter(AccessLevel.PUBLIC)
    private String language;
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

實際效果相當於:

public class Programmer{
    private String name;
    private int age;
    private String language;

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

    public String getName(){
        return name;
    }

    protected void setAge(int age){
        this.age = age;
    }

    public String getLanguage(){
        return language;
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

這兩個註解還可以直接用在類上,可以為此類裡的所有非靜態成員變數生成對應的get和set方法。

@ToString/@EqualsAndHashCode

這兩個註解也比較好理解,就是生成toString,equals和hashcode方法,同時後者還會生成一個canEqual方法,用於判斷某個物件是否是當前類的例項,生成方法時只會使用類中的非靜態非transient成員變數,這些都比較好理解,就不舉例子了。
當然,這兩個註解也可以新增限制條件,例如用@ToString(exclude={“param1”,“param2”})來排除param1和param2兩個成員變數,或者用@ToString(of={“param1”,“param2”})來指定使用param1和param2兩個成員變數,@EqualsAndHashCode註解也有同樣的用法。

@NoArgsConstructor/@RequiredArgsConstructor /@AllArgsConstructor

這三個註解都是用在類上的,第一個和第三個都很好理解,就是為該類產生無參的構造方法和包含所有引數的構造方法,第二個註解則使用類中所有帶有@NonNull註解的或者帶有final修飾的成員變數生成對應的構造方法,當然,和前面幾個註解一樣,成員變數都是非靜態的,另外,如果類中含有final修飾的成員變數,是無法使用@NoArgsConstructor註解的。
三個註解都可以指定生成的構造方法的訪問許可權,同時,第二個註解還可以用@RequiredArgsConstructor(staticName=”methodName”)的形式生成一個指定名稱的靜態方法,返回一個呼叫相應的構造方法產生的物件,下面來看一個生動鮮活的例子:

@RequiredArgsConstructor(staticName = "sunsfan")
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@NoArgsConstructor
public class Shape {
    private int x;
    @NonNull
    private double y;
    @NonNull
    private String name;
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

實際效果相當於:

public class Shape {
    private int x;
    private double y;
    private String name;

    public Shape(){
    }

    protected Shape(int x,double y,String name){
        this.x = x;
        this.y = y;
        this.name = name;
    }

    public Shape(double y,String name){
        this.y = y;
        this.name = name;
    }

    public static Shape sunsfan(double y,String name){
        return new Shape(y,name);
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

@Data/@Value

呃!!
@Data註解綜合了3,4,5和6裡面的@RequiredArgsConstructor註解,其中@RequiredArgsConstructor使用了類中的帶有@NonNull註解的或者final修飾的成員變數,它可以使用@Data(staticConstructor=”methodName”)來生成一個靜態方法,返回一個呼叫相應的構造方法產生的物件。這個例子就也省略了吧…
@Value註解和@Data類似,區別在於它會把所有成員變數預設定義為private final修飾,並且不會生成set方法。

@SneakyThrows

這個註解用在方法上,可以將方法中的程式碼用try-catch語句包裹起來,捕獲異常並在catch中用Lombok.sneakyThrow(e)把異常丟擲,可以使用@SneakyThrows(Exception.class)的形式指定丟擲哪種異常,很簡單的註解,直接看個例子:

public class SneakyThrows implements Runnable {
    @SneakyThrows(UnsupportedEncodingException.class)
    public String utf8ToString(byte[] bytes) {
        return new String(bytes, "UTF-8");
    }

    @SneakyThrows
    public void run() {
        throw new Throwable();
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

實際效果相當於:

public class SneakyThrows implements Runnable {
    @SneakyThrows(UnsupportedEncodingException.class)
    public String utf8ToString(byte[] bytes) {
        try{
            return new String(bytes, "UTF-8");
        }catch(UnsupportedEncodingException uee){
            throw Lombok.sneakyThrow(uee);
        }
    }

    @SneakyThrows
    public void run() {
        try{
            throw new Throwable();
        }catch(Throwable t){
            throw Lombok.sneakyThrow(t);
        }
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

@Synchronized

這個註解用在類方法或者例項方法上,效果和synchronized關鍵字相同,區別在於鎖物件不同,對於類方法和例項方法,synchronized關鍵字的鎖物件分別是類的class物件和this物件,而@Synchronized得鎖物件分別是私有靜態final物件LOCKfinalLOCK和私有final物件lock,當然,也可以自己指定鎖物件,例子也很簡單,往下看:

public class Synchronized {
    private final Object readLock = new Object();

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

    @Synchronized
    public int answerToLife() {
        return 42;
    }

    @Synchronized("readLock")
    public void foo() {
        System.out.println("bar");
    }
}
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

實際效果相當於:

public class Synchronized {
   private static final Object $LOCK = new Object[0];
   private final Object $lock = new Object[0];
   private final Object readLock = new Object();

   public static void hello() {
     synchronized($LOCK) {
       System.out.println("world");
     }
   }

   public int answerToLife() {
     synchronized($lock) {
       return 42;
     }
   }

   public void foo() {
     synchronized(readLock) {
       System.out.println("bar");
     }
   }
 }
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

@Log

這個註解用在類上,可以省去從日誌工廠生成日誌物件這一步,直接進行日誌記錄,具體註解根據日誌工具的不同而不同,同時,可以在註解中使用topic來指定生成log物件時的類名。不同的日誌註解總結如下(上面是註解,下面是實際作用):

@CommonsLog
private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LogExample.class);
@JBossLog
private static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LogExample.class);
@Log
private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());
@Log4j
private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LogExample.class);
@Log4j2
private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class);
@Slf4j
private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
@XSlf4j
private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LogExample.class);
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

關於lombok的註解先寫到這裡,當然,還有其他一些註解需要大家自己去摸索,同時lombok一直在擴充套件,將來肯定會加入更多的註解元素,拭目以待了。

lombok註解介紹