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