lombok的简单介绍

##lombok的使用

一直在使用lombok的set和get，对其他的功能用的比较少，蓦然发现这个库好用的功能不要太多啊

有必要深入理解一番。

###lombok安装

1 需要IDE支持，不然开发的时候都会报错

2 需要加载依赖的安装包

###lombok提供的注解功能说明

```
@Data
@Setter
@Getter
@Log4j
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@NonNull
@Cleanup
@ToString
@RequiredArgsConstructor
@Value
@SneakyThrows
@Synchronized

```

@Setter和@Getter

注解在 类 上；提供属性的get和set

@Data

注解在 类 上；提供类所有属性的 get 和 set 方法，此外还提供了equals、canEqual、hashCode、toString 方法。

@Log4j @Slf4j

注解在 类 上；为类提供一个 属性名为 log 的 log4j 日志对象，提供默认构造方法。
@Slf4j 使用slf4j提供日志服务，这个稍后会讲到

@AllArgsConstructor

注解在 类 上；为类提供一个全参的构造方法，加了这个注解后，类中不提供默认构造方法了。

@NoArgsConstructor

注解在 类 上；为类提供一个无参的构造方法。

@EqualsAndHashCode

可以生成 equals、canEqual、hashCode 方法。

@NonNull

注解在 属性 上，会自动产生一个关于此参数的非空检查，
如果参数为空，则抛出一个空指针异常，也会有一个默认的无参构造方法。

@Cleanup

这个注解用在 变量 前面，可以保证此变量代表的资源会被自动关闭，
默认是调用资源的 close() 方法，
如果该资源有其它关闭方法，可使用 @Cleanup(“methodName”) 来指定要调用的方法，
也会生成默认的构造方法

@RequiredArgsConstructor

这个注解用在 类 上，使用类中所有带有 @NonNull
注解的或者带有 final 修饰的成员变量生成对应的构造方法。

@Value

这个注解用在 类 上，会生成含所有参数的构造方法，get 方法，
此外还提供了equals、hashCode、toString 方法。

@SneakyThrows

这个注解用在 方法 上，可以将方法中的代码用 try-catch 语句包裹起来，
捕获异常并在 catch 中用 Lombok.sneakyThrow(e) 把异常抛出，
可以使用 @SneakyThrows(Exception.class) 的形式指定抛出哪种异常，也会生成默认的构造方法。

@SneakyThrows

这个注解用在 方法 上，可以将方法中的代码用 try-catch 语句包裹起来，
捕获异常并在 catch 中用 Lombok.sneakyThrow(e) 把异常抛出，
可以使用 @SneakyThrows(Exception.class) 的形式指定抛出哪种异常，也会生成默认的构造方法。

@Synchronized

这个注解用在类方法或者实例方法上，效果和 synchronized 关键字相同，
区别在于锁对象不同，对于类方法和实例方法，
synchronized 关键字的锁对象分别是类的 class 对象和 this 对象，
而 @Synchronized 的锁对象分别是
私有静态 final对象,
私有final对象，
当然，也可以自己指定锁对象，此外也提供默认的构造方法。

本节参考：

https://zhuanlan.zhihu.com/p/32779910

###lombok的原理

插入式注解处理API

自从Java 6起，javac就支持“JSR 269 Pluggable Annotation Processing API”规范，
只要程序实现了该API，就能在javac运行的时候得到调用。

JSR 的例子,暂时没有，等我写java虚拟机的时候一并补上。胡乱立flag会不会有完成不了的风险=。=

相关的代码

 package test.lombok;

 public class LombokTest {

     public static void main(String[] args){
         tData();
         testLog();
         testClean();
         testException();
         tesSync();
     }

     //修改lomok data注解
     public static void tData(){

         LomokData lomokData = new LomokData();
         lomokData.setName("abc");
         System.out.println(lomokData.getName());

         //equal
         LomokData lomokData2 = new LomokData();
         lomokData2.setName("abc");
         System.out.println(lomokData.equals(lomokData2));

         //canEqual
         System.out.println(lomokData.canEqual(lomokData2));

         //tostring
         System.out.println(lomokData.toString());

         //hashCode
         System.out.println(lomokData.hashCode());

         //@Slf4j
         //LomokData.testLog();

         //toString

         System.out.println(lomokData);
     }

     //@AllArgsConstructor
     //@NoArgsConstructor
     public static void testArgs(){
         LommokLog lommokLog1 = new LommokLog();
         lommokLog1.setCountry(null);
     }

     public static void testLog(){
         LommokLog.testLog();
     }

     //@Cleanup
     public static void testClean(){
         try{
             TestCleanUp.fileCopy();
         }catch (Exception e){
             e.printStackTrace();
         }
     }

     public static void testException(){
         TestThrow.openIo();
     }

     //测试锁
     public static void tesSync(){
         TestSync testSync = new TestSync();
         int number = 10;
         SyncIt syncItArr[] = new SyncIt[number];

         for (int i =0; i < number;i++){
             syncItArr[i] = new SyncIt(testSync);
             new Thread(syncItArr[i],"thread-"+i).start();
         }
         TestSync.sleepIt(60);
     }
 }

 class SyncIt implements Runnable{
     private TestSync testSync;
     public SyncIt(TestSync testSync){
         this.testSync = testSync;
     }

     @Override
     public void run() {
         testSync.h3();
     }
 }

 package test.lombok;

 import lombok.Synchronized;

 import java.util.concurrent.TimeUnit;

 public class TestSync {

     private final Object readLock = new Object();

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

     @Synchronized
     public int h2(){
         sleepIt(3);
         return 12;
     }
     @Synchronized
     public void h3(){
         System.out.println("!!");
         sleepIt(3);
     }

     @Synchronized("readLock")
     public void foo(){
         System.out.println("foo");
     }

     public static void sleepIt(int n){
         try{
             TimeUnit.SECONDS.sleep(n);
         }catch (Exception e){
             e.printStackTrace();
         }
     }
 }
 package test.lombok;

 import lombok.Cleanup;
 import lombok.SneakyThrows;

 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;

 public class TestThrow {

     @SneakyThrows(IOException.class)
     public static void openIo(){

         @Cleanup InputStream inputStream = new FileInputStream("/data1/applogs/flogger/2019-01-31/info.log.copy");

     }
 }
 package test.lombok;

 import lombok.*;
 import lombok.extern.log4j.Log4j;

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;

 @Log4j
 @AllArgsConstructor
 @NoArgsConstructor
 @Setter
 @Getter
 @EqualsAndHashCode
 @ToString
 //@RequiredArgsConstructor
 public class LommokLog {

     @NonNull
     private int id;

     private String name;

     private String country;

     public static void testLog(){
         log.info("test123");
     }

 }

 class TestCleanUp{

     public static void fileCopy() throws Exception{
         String filename = "/data1/applogs/flogger/2019-01-31/info.log";
         String filenameCopy = "/data1/applogs/flogger/2019-01-31/info.log.copy";

         @Cleanup InputStream in = new FileInputStream(filename);
         @Cleanup OutputStream out = new FileOutputStream(filenameCopy);
         byte[] b = new byte[10000];
         while (true) {
             int r = in.read(b);
             if (r == -1) break;
             out.write(b, 0, r);
         }

     }

 }

本节参考:

https://github.com/coderzhw/blog/issues/6
https://blog.csdn.net/zhuhai__yizhi/article/details/49999151