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();
}

實際效果相當於：

public String getName(@NonNull Person p){
    if(p==null){
        throw new NullPointerException("person");
    }
    return p.getName();
}

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

@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);
     }
 }

實際效果相當於：

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();
       }
    }
}

是不是簡化了很多。

@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;
}

實際效果相當於：

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;
    }
}

這兩個註解還可以直接用在類上，可以為此類裡的所有非靜態成員變數生成對應的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;
}

實際效果相當於：

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);
    }
}

@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();
    }
}

實際效果相當於：

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);
        }
    }
}

@Synchronized

這個註解用在類方法或者例項方法上，效果和synchronized關鍵字相同，區別在於鎖物件不同，對於類方法和例項方法，synchronized關鍵字的鎖物件分別是類的class物件和this物件，而@Synchronized得鎖物件分別是私有靜態final物件LOCK和私有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");
    }
}

實際效果相當於：

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");
     }
   }
 }

@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);

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