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

扫描二维码关注公众号，回复： 5142684 查看本文章

@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

@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会不会有完成不了的风险=。=

相关的代码

  1 package test.lombok;
  2 
  3 
  4 public class LombokTest {
  5 
  6     public static void main(String[] args){
  7         tData();
  8         testLog();
  9         testClean();
 10         testException();
 11         tesSync();
 12     }
 13 
 14     //修改lomok data注解
 15     public static void tData(){
 16 
 17         LomokData lomokData = new LomokData();
 18         lomokData.setName("abc");
 19         System.out.println(lomokData.getName());
 20 
 21         //equal
 22         LomokData lomokData2 = new LomokData();
 23         lomokData2.setName("abc");
 24         System.out.println(lomokData.equals(lomokData2));
 25 
 26         //canEqual
 27         System.out.println(lomokData.canEqual(lomokData2));
 28 
 29         //tostring
 30         System.out.println(lomokData.toString());
 31 
 32         //hashCode
 33         System.out.println(lomokData.hashCode());
 34 
 35         //@Slf4j
 36         //LomokData.testLog();
 37 
 38         //toString
 39 
 40         System.out.println(lomokData);
 41     }
 42 
 43     //@AllArgsConstructor
 44     //@NoArgsConstructor
 45     public static void testArgs(){
 46         LommokLog lommokLog1 = new LommokLog();
 47         lommokLog1.setCountry(null);
 48     }
 49 
 50     public static void testLog(){
 51         LommokLog.testLog();
 52     }
 53 
 54     //@Cleanup
 55     public static void testClean(){
 56         try{
 57             TestCleanUp.fileCopy();
 58         }catch (Exception e){
 59             e.printStackTrace();
 60         }
 61     }
 62 
 63 
 64     public static void testException(){
 65         TestThrow.openIo();
 66     }
 67 
 68     //测试锁
 69     public static void tesSync(){
 70         TestSync testSync = new TestSync();
 71         int number = 10;
 72         SyncIt syncItArr[] = new SyncIt[number];
 73 
 74         for (int i =0; i < number;i++){
 75             syncItArr[i] = new SyncIt(testSync);
 76             new Thread(syncItArr[i],"thread-"+i).start();
 77         }
 78         TestSync.sleepIt(60);
 79     }
 80 }
 81 
 82 class SyncIt implements Runnable{
 83     private TestSync testSync;
 84     public SyncIt(TestSync testSync){
 85         this.testSync = testSync;
 86     }
 87 
 88     @Override
 89     public void run() {
 90         testSync.h3();
 91     }
 92 }
 93 
 94 package test.lombok;
 95 
 96 import lombok.Synchronized;
 97 
 98 import java.util.concurrent.TimeUnit;
 99 
100 public class TestSync {
101 
102     private final Object readLock = new Object();
103 
104     @Synchronized
105     public static void h1(){
106         System.out.println("h1");
107     }
108 
109 
110     @Synchronized
111     public int h2(){
112         sleepIt(3);
113         return 12;
114     }
115     @Synchronized
116     public void h3(){
117         System.out.println("!!");
118         sleepIt(3);
119     }
120 
121     @Synchronized("readLock")
122     public void foo(){
123         System.out.println("foo");
124     }
125 
126     public static void sleepIt(int n){
127         try{
128             TimeUnit.SECONDS.sleep(n);
129         }catch (Exception e){
130             e.printStackTrace();
131         }
132     }
133 }
134 package test.lombok;
135 
136 import lombok.Cleanup;
137 import lombok.SneakyThrows;
138 
139 import java.io.FileInputStream;
140 import java.io.IOException;
141 import java.io.InputStream;
142 
143 public class TestThrow {
144 
145     @SneakyThrows(IOException.class)
146     public static void openIo(){
147 
148         @Cleanup InputStream inputStream = new FileInputStream("/data1/applogs/flogger/2019-01-31/info.log.copy");
149 
150     }
151 }
152 package test.lombok;
153 
154 import lombok.*;
155 import lombok.extern.log4j.Log4j;
156 
157 import java.io.FileInputStream;
158 import java.io.FileOutputStream;
159 import java.io.InputStream;
160 import java.io.OutputStream;
161 
162 
163 @Log4j
164 @AllArgsConstructor
165 @NoArgsConstructor
166 @Setter
167 @Getter
168 @EqualsAndHashCode
169 @ToString
170 //@RequiredArgsConstructor
171 public class LommokLog {
172 
173     @NonNull
174     private int id;
175 
176     private String name;
177 
178     private String country;
179 
180 
181     public static void testLog(){
182         log.info("test123");
183     }
184 
185 }
186 
187 class TestCleanUp{
188 
189     public static void fileCopy() throws Exception{
190         String filename = "/data1/applogs/flogger/2019-01-31/info.log";
191         String filenameCopy = "/data1/applogs/flogger/2019-01-31/info.log.copy";
192 
193         @Cleanup InputStream in = new FileInputStream(filename);
194         @Cleanup OutputStream out = new FileOutputStream(filenameCopy);
195         byte[] b = new byte[10000];
196         while (true) {
197             int r = in.read(b);
198             if (r == -1) break;
199             out.write(b, 0, r);
200         }
201 
202     }
203 
204 }

本节参考:

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

猜你喜欢