Lombok 是一种 Java Archive (JAR) 文件，可用来消除 Java 代码的冗长。
我们看这样一个例子，一个标准的 Java bean。一个典型的 Java bean 一般具有几个属性。每个属性具有一个 accessor 和 mutator（getter 和 setter）。通常还会有一个 toString() 方法、一个 equals() 方法和一个 hashCode() 方法。
初看上去，其中可预见的冗余就已经非常多了。如果每个属性都具有一个 getter 和 setter，并且通常如此，那么又何必详细说明呢？
让我们来看看 Lombok。为了消除代码行，Lombok 使用注释来标识类和 Java 代码块。在前述的那个 Java bean 示例中，所有的 getter、setter 以及其他三个方法都是在编译时被暗示并包括进来的。
而且更好的是如果您使用的是 Eclipse 或 IBM® WebSphere® Studio Application Developer（如果还没用的话，建议最好使用），您就可以将 Lombok 集成到 Java 项目并即刻获得开发时结果。换言之，Eclipse 编译器可以立即识别所暗指的 getters/setters，而其他 Java 代码则可引用这些方法。
最直接的好处当然是代码行的减少，这真的很棒。并且，如果有一个特定的 getter 或 setter 需要特别的注意，那么您就不必为了找到这个特定的 getter 或 setter 而遍历数十行代码。代码也会更为简洁并且冗余也少了。
Lombok 还让您得以简化代码的其他部分 — 不仅仅是 Java bean。比如，还可以减少 try/catch/finally 块内以及同步方法内的冗余代码。
现在，我们来看看在您自己的开发环境中如何能实现上述目的。
要进行安装，本文假设您使用的是 Eclipse 或 WebSphere Studio Application Developer。如果不是，您仍可使用 Lombok；但是不能享用开发时的种种益处。不过，您仍然可以享用编译时的益处。
首先，打开您的浏览器并将 URL 指向 http://projectlombok.org/。
在撰写本文之时，用这个 URL 打开的页面的右上角会出现一个很大的单词。这个单词是 “Download”。单击该单词并开始下载 lombok.jar。此文件无需解压缩，而从其他站点下载的文件中，99% 都需要解压缩。
下载此文件后，需要执行这个 JAR 文件。在您的操作系统中打开一个提示符，进入到安装了 lombok.jar 的那个目录，并键入 java -jar lombok.jar。
以上假设在您的路径内已经有 Java Runtime Environment (JRE)。如果没有，需要添加它。如果要了解如何添加，可以参考针对您的具体操作系统的相关文档。
如果您使用的是 Microsoft® Windows®，那么还可以双击这个 lombok.jar 图标。同样地，您必须能够从您的图形用户界面（GUI）执行 JAR。
不管采取何种方式，应该最终都能看到一个 Lombok 安装屏幕。该屏幕会提问 Eclipse 或 WebSphere Studio Application Developer 可执行文件位于何处。它的默认位置有可能是正确的。但有时可能需要更改这个默认位置。
单击 Install/Update，Lombok 会被迅速并入 Eclipse 开发环境。如果已经运行了 Eclipse，那么就需要关闭它并重启。
现在，就可以在 Eclipse 或 WebSphere Studio Application Developer 内开始使用 Lombok 了。请参考清单 1 内的代码。
清单 1. Java bean 的一个良好开端
public class Lure {
private String name;
private int size;
private String color;
private String style;
}
|
以上是一个简单的 Java bean 的典型开始。从这里，可以为每个属性添加 getters 和 setters。然后再添加一个 equals() 方法、一个 toString() 方法和一个 hashCode() 方法。
有了 Lombok，您无需自己完成上述操作。相反，您只需添加一个注释：@Data。
没错，就这么简单。清单 2 中包括了 @Data。
清单 2. Java bean 的一个更好的开端
import lombok.Data
public @Data class Lure {
private String name;
private int size;
private String color;
private String style;
}
|
不过请记住，只有当 lombok.jar 位于您的构建路径且 lombok.Data 被导入到这个 Java 类时，上述代码才会奏效。
如果在 Eclipse 或 WebSphere Studio Application Developer 内查看这个类的概要（通常位于屏幕上这个类的右侧），就能看到这些方法会被自动添加到这个 Lure 类。
若不能立即看到这个概要，可以单击 Eclipse 内的 Window 菜单，然后选择 Show View。 从所出现的弹出菜单中，选择 Outline，它应该出现在屏幕的右侧。强制显示类的概要的热键组合是 Alt+Shift+Q， 然后是 O。
如果您编写了另一个类来实例化 Lure，您将能立刻拥有对 Lure 所暗指的方法（比如 getName() 或setSize()）的访问。您还能拥有对 equals()、hashCode() 和 toString() 的访问。很棒，对吧？
如果您使用的不是 Eclipse 或 WebSphere Studio Application Developer，那么所暗指的这些方法添加只有在实际编译这些代码时才能被认可。所以虽然在没有 Eclipse 或 WebSphere Studio Application Developer 时仍可以使用 Lombok，但 Lombok 最初的设计目的就是与 Eclipse 或 WebSphere Studio Application Developer 相集成。
在生成 getter/setter 方法时，Lombok 遵从传统的标准。所有这些方法名都以 get 或 set 开头并且属性名都是大写的。当然，如果属性是一个 Boolean，情况例外。在这种情况下，getter 以 is 开始，而非 get。这是 Java bean 的一种标准实践。
现在，假设有一个 Java bean 对您的一个 getter 具有特殊要求。在清单 2 的例子中，getStyle() 可能返回颜色和大小的组合。在这种情况下，可以按自己的意愿编写 getStyle() 方法的代码。Lombok 检查您的代码并且不会基于这个属性创建其自己的 getStyle 版本。
又假设，您有一个 getter 方法不想公开。为此，Lombok 让您可以输入一个附加参数。清单 3 给出了一个定制的修饰符（modifier）。
清单 3. 一个定制的修饰符
private String name; @Getter(AccessLevel.PROTECTED) private int size; private String color; private String style; |
在本例中，getSize() 方法将不会被公开。它具有一个受保护的修饰符，所以它只对派生子类可用并且在 Lure类本身的内部。
您可能并不总是想接受 Lombok 为您提供的其他默认值。比如，toString() 方法会列出类名以及所有的属性名和值，中间以逗号分割。这个列表出现在类名的旁边。
比如，假设在记录这个 Lure 类时，您并不关心颜色。为了更改 toString() 的默认设置，需要使用 ToString注释。
清单 4. 修改 toString()
@ToString(exclude="color")
public @Data class Lure {
private String name;
private int size;
private String color;
private String style;
}
|
若输出一个实例化了的 Lure 类，它应该看上去类似于：
Lure(name=Wishy-Washy, size=1, style=trolling) |
注意到颜色没有被包括？这是因为您之前用注释告诉过 Lombok 不包括颜色。
您还可以修改 equals() 和 hashCode() 方法该如何被处理。清单 5 很直白，不需要过多解释。
清单 5. 修改 hashCode()
@EqualsAndHashCode(exclude="style")
public @Data class Lure {
private String name;
private int size;
private String color;
private String style;
}
|
在本例中，当 equals() 和 hashCode() 方法生成时，style 属性并没有被包括。
您是不是也一直非常痛恨编写 try/catch/finally 块呢？我是这样的。幸运的是，有了 Lombok，您无需这么做了。这也是 Lombok 消除 Java 冗余的另一种方式。为了消除 try/catch/finally 块的冗余，只需使用 @Cleanup 注释。参见清单 6。
清单 6. 使用 @Cleanup 注释
public static void main(String[] args) throws IOException {
@Cleanup InputStream in = new FileInputStream(args[0]);
@Cleanup OutputStream out = new FileOutputStream(args[1]);
//write file code goes here
}
|
上述代码较我们通常在标准 Java 代码内看到的整洁了很多。请注意您还是需要抛出由被调用代码捕获的异常（在本例中，为 IOException）。
清单 6 中的这个代码块不仅消除了 try/catch/finally 块，而且还关闭了开放流。如果您处理的对象使用一个方法而不是 close() 来释放资源，那么就需要用一个带附加说明的注释调用该方法。比如，@Cleanup("relinquish")。
Lombok 还可以减少同步方法所需的代码的冗余。很自然，这是用 @Synchronized 方法实现的。
清单 7. 使用 @Synchronized 注释
@Synchronized
private int foo() {
//some magic done here
return 1;
}
|
在本例中，Lombok 会自动创建一个名为 $lock 的实例对象，并会针对该对象同步方法 foo()。
如果用 @Synchronized 注释的这个方法是静态的，那么 Lombok 就会创建一个名为 $LOCK 的类对象，并会针对该对象同步这个方法。
您还可以指定一个对象用以通过一个附加参数进行显式的锁定。比如，@Synchronized("myObject") 会针对对象 myObject 同步这个方法。在这种情况下，必须显式地定义它。
使用 Lombok，可以实现所有应用程序开发人员都竭尽全力实现的一个目标：消除冗余。
您还可以让您的代码可读性更好。在 Java bean 内寻找 “特殊”（即不遵循典型的标准）的具有大量属性的 getter 和 setter 方法将更为简便。这是因为只有这些特殊的 getter/setter 方法是需要被实际编码的。
Lombok 有助于代码的整洁、效率的提高以及冗余的减少。为何不在您自己的环境内尝试一下呢？
前言：
逛开源社区的时候无意发现的，用了一段时间，觉得还可以，特此推荐一下。
lombok 提供了简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 java 代码。特别是相对于 POJO，光说不做不是我的风格，先来看看吧。
lombok 的官方网址：http://projectlombok.org/
lombok 其实到这里我就介绍完了，开个玩笑，其实官网上有 lombok 三分四十九秒的视频讲解，里面讲的也很清楚了，而且还有文档可以参考。
在这里我就不扯太多，先来看一下 lombok 的安装，其实这个官网视频上也有讲到啦
lombok 安装
使用 lombok 是需要安装的，如果不安装，IDE 则无法解析 lombok 注解。先在官网下载最新版本的 JAR 包，现在是 0.11.2 版本，我用的是 0.11.0
第一次使用的时候我下载的是最新版本的，也就是我现在用的 0.11.0，到现在已经更新了两个版本，更新的好快啊 ... ...
1. 双击下载下来的 JAR 包安装 lombok
我选择这种方式安装的时候提示没有发现任何 IDE，所以我没安装成功，我是手动安装的。如果你想以这种方式安装，请参考官网的视频。
2.eclipse / myeclipse 手动安装 lombok
1. 将 lombok.jar 复制到 myeclipse.ini / eclipse.ini 所在的文件夹目录下
2. 打开 eclipse.ini / myeclipse.ini，在最后面插入以下两行并保存：
-Xbootclasspath/a:lombok.jar
-javaagent:lombok.jar
3.重启 eclipse / myeclipse
lombok 注解：
lombok 提供的注解不多，可以参考官方视频的讲解和官方文档。
Lombok 注解在线帮助文档：http://projectlombok.org/features/index.
下面介绍几个我常用的 lombok 注解：
@Data ：注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
@Setter：注解在属性上；为属性提供 setting 方法
@Getter：注解在属性上；为属性提供 getting 方法
@Log4j ：注解在类上；为类提供一个 属性名为log 的 log4j 日志对象
@NoArgsConstructor：注解在类上；为类提供一个无参的构造方法
@AllArgsConstructor：注解在类上；为类提供一个全参的构造方法
下面是简单示例
1.不使用 lombok 的方案
2
public class Person
{3
4
private String id;5
private String name;6
private String identity;7
private Logger log = Logger.getLogger(Person.class);8
9
public Person() {10
11
}12
13
public Person(String id, String name, String identity) {14
this.id = id;15
this.name = name;16
this.identity = identity;17
}18
19
public String getId() {20
return id;21
}22
23
public String getName() {24
return name;25
}26
27
public String getIdentity() {28
return identity;29
}30
31
public void setId(String id) {32
this.id = id;33
}34
35
public void setName(String name) {36
this.name = name;37
}38
39
public void setIdentity(String identity) {40
this.identity = identity;41
}42
}43
2.使用 lombok 的方案
2
@Data
3
@Log4j
4
@NoArgsConstructor
5
@AllArgsConstructor
6
public class Person
{7
8
private String id;9
private String name;10
private String identity;11
12
}13
上面的两个 java 类，从作用上来看，它们的效果是一样的，相比较之下，很明显，使用 lombok 要简洁许多，特别是在类的属性较多的情况下，
同时也避免了修改字段名字时候忘记修改方法名所犯的低级错误。最后需要注意的是，在使用 lombok 注解的时候记得要导入 lombok.jar 包到工程
lombok是一款可以精减java代码、提升开发人员生产效率的辅助工具，利用注解在编译期自动生成setter/getter/toString()/constructor之类的代码。代码越少，意味着出bug的可能性越低。
官网地址：https://projectlombok.org/ 首页有一段几分钟的演示视频，看完就明白是怎么回事了。
先来二段对比代码：
这是用lombok后的java代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
import
lombok.*;
import
lombok.extern.slf4j.Slf4j;
import
java.io.ByteArrayInputStream;
import
java.io.*;
import
java.util.ArrayList;
@Data
@Slf4j
@AllArgsConstructor
public
class
Something {
private
String name;
private
final
String country;
private
final
Object lockObj =
new
Object();
public
void
sayHello(
@NonNull
String target) {
String content = String.format(
"hello,%s"
, target);
System.out.println(content);
log.info(content);
}
public
void
addBalabala() {
val list =
new
ArrayList
list.add(
"haha"
);
System.out.println(list.size());
}
@SneakyThrows
(IOException.
class
)
public
void
closeBalabala() {
@Cleanup
InputStream is =
new
ByteArrayInputStream(
"hello world"
.getBytes());
System.out.println(is.available());
}
@Synchronized
(
"lockObj"
)
public
void
lockMethod() {
System.out.println(
"test lock method"
);
}
}
|
等效于下面这段java代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
import
java.beans.ConstructorProperties;
import
java.io.ByteArrayInputStream;
import
java.io.IOException;
import
java.util.ArrayList;
import
java.util.Collections;
import
lombok.NonNull;
import
org.slf4j.Logger;
import
org.slf4j.LoggerFactory;
public
class
Something {
private
static
final
Logger log = LoggerFactory.getLogger(Something.
class
);
private
String name;
private
final
String country;
private
final
Object lockObj =
new
Object();
public
void
sayHello(
@NonNull
String target) {
if
(target ==
null
) {
throw
new
NullPointerException(
"target"
);
}
else
{
String content = String.format(
"hello,%s"
,
new
Object[]{target});
System.out.println(content);
log.info(content);
}
}
public
void
addBalabala() {
ArrayList list =
new
ArrayList();
list.add(
"haha"
);
System.out.println(list.size());
}
public
void
closeBalabala() {
try
{
ByteArrayInputStream $ex =
new
ByteArrayInputStream(
"hello world"
.getBytes());
try
{
System.out.println($ex.available());
}
finally
{
if
(Collections.singletonList($ex).get(
0
) !=
null
) {
$ex.close();
}
}
}
catch
(IOException var6) {
throw
var6;
}
}
public
void
lockMethod() {
Object var1 =
this
.lockObj;
synchronized
(
this
.lockObj) {
System.out.println(
"test lock method"
);
}
}
public
String getName() {
return
this
.name;
}
public
String getCountry() {
return
this
.country;
}
public
Object getLockObj() {
return
this
.lockObj;
}
public
void
setName(String name) {
this
.name = name;
}
public
boolean
equals(Object o) {
if
(o ==
this
) {
return
true
;
}
else
if
(!(o
instanceof
Something)) {
return
false
;
}
else
{
Something other = (Something)o;
if
(!other.canEqual(
this
)) {
return
false
;
}
else
{
label47: {
String
this
$name =
this
.getName();
String other$name = other.getName();
if
(
this
$name ==
null
) {
if
(other$name ==
null
) {
break
label47;
}
}
else
if
(
this
$name.equals(other$name)) {
break
label47;
}
return
false
;
}
String
this
$country =
this
.getCountry();
String other$country = other.getCountry();
if
(
this
$country ==
null
) {
if
(other$country !=
null
) {
return
false
;
}
}
else
if
(!
this
$country.equals(other$country)) {
return
false
;
}
Object
this
$lockObj =
this
.getLockObj();
Object other$lockObj = other.getLockObj();
if
(
this
$lockObj ==
null
) {
if
(other$lockObj !=
null
) {
return
false
;
}
}
else
if
(!
this
$lockObj.equals(other$lockObj)) {
return
false
;
}
return
true
;
}
}
}
protected
boolean
canEqual(Object other) {
return
other
instanceof
Something;
}
public
int
hashCode() {
boolean
PRIME =
true
;
byte
result =
1
;
String $name =
this
.getName();
int
result1 = result *
59
+ ($name ==
null
?
0
:$name.hashCode());
String $country =
this
.getCountry();
result1 = result1 *
59
+ ($country ==
null
?
0
:$country.hashCode());
Object $lockObj =
this
.getLockObj();
result1 = result1 *
59
+ ($lockObj ==
null
?
0
:$lockObj.hashCode());
return
result1;
}
public
String toString() {
return
"Something(name="
+
this
.getName() +
", country="
+
this
.getCountry() +
", lockObj="
+
this
.getLockObj() +
")"
;
}
@ConstructorProperties
({
"name"
,
"country"
})
public
Something(String name, String country) {
this
.name = name;
this
.country = country;
}
}
|
大概减少了2/3的代码，各种注解的详细用法，请参考：https://projectlombok.org/features/index.html
IDEA下使用时，可以通过插件的形式安装，插件下载地址：https://github.com/mplushnikov/lombok-intellij-plugin/releases
然后
Plugins -> Install plugin from disk... 选择下载的zip包安装，重启idea即可。
另外，还有一个关键设置：
为了让设置生效，建议再重启一次idea，然后就可以开心的编码了，可以ide里可以直接看到生成的方法：（下图中打红圈的都是自动生成的）
一、项目背景
在写Java程序的时候经常会遇到如下情形：
新建了一个Class类，然后在其中设置了几个字段，最后还需要花费很多时间来建立getter和setter方法
lombok项目的产生就是为了省去我们手动创建getter和setter方法的麻烦，它能够在我们编译源码的时候自动帮我们生成getter和setter方法。即它最终能够达到的效果是：在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法
比如源码文件：
import java.io.Serializable;
import lombok.Data;
@Data
public class BasicClusterInfo implements Serializable { private static final long serialVersionUID = 3478135817352393604L; private String hbaseKey; private int receiverCount; }以下是编译上述源码文件得到的字节码文件，对其反编译得到的结果
public class BasicClusterInfo extends java.lang.Object implements java.io.Serializable{ public BasicClusterInfo(); public java.lang.String getHbaseKey(); public int getReceiverCount(); public void setHbaseKey(java.lang.String); public void setReceiverCount(int); public boolean equals(java.lang.Object); public boolean canEqual(java.lang.Object); public int hashCode(); public java.lang.String toString(); }
二、使用方法
lombok网址：https://projectlombok.org/download.html
Eclipse支持需要点击运行下载的jar包
Maven依赖：
<dependency> <groupId>org.projectlombokgroupId> <artifactId>lombokartifactId> <version>1.16.6version> <scope>providedscope> dependency>使用lombok项目的方法很简单，分为四个步骤：
1)在需要自动生成getter和setter方法的类上，加上@Data注解
2)在编译类路径中加入lombok.jar包
3)使用支持lombok的编译工具编译源代码（关于支持lombok的编译工具，见“四、支持lombok的编译工具”）
4)编译得到的字节码文件中自动生成了getter和setter方法
三、原理分析
接下来进行lombok能够工作的原理分析，以Oracle的javac编译工具为例。
自从Java 6起，javac就支持“JSR 269 Pluggable Annotation Processing API”规范，只要程序实现了该API，就能在javac运行的时候得到调用。
举例来说，现在有一个实现了"JSR 269 API"的程序A,那么使用javac编译源码的时候具体流程如下：
1)javac对源代码进行分析，生成一棵抽象语法树(AST)
2)运行过程中调用实现了"JSR 269 API"的A程序
3)此时A程序就可以完成它自己的逻辑，包括修改第一步骤得到的抽象语法树(AST)
4)javac使用修改后的抽象语法树(AST)生成字节码文件
详细的流程图如下： 
lombok本质上就是这样的一个实现了"JSR 269 API"的程序。在使用javac的过程中，它产生作用的具体流程如下：
1)javac对源代码进行分析，生成一棵抽象语法树(AST)
2)运行过程中调用实现了"JSR 269 API"的lombok程序
3)此时lombok就对第一步骤得到的AST进行处理，找到@Data注解所在类对应的语法树(AST)，然后修改该语法树(AST)，增加getter和setter方法定义的相应树节点
4)javac使用修改后的抽象语法树(AST)生成字节码文件
四、支持lombok的编译工具
1)由“三、原理分析”可知，Oracle javac直接支持lombok
2)常用的项目管理工具Maven所使用的java编译工具来源于配置的第三方工具，如果我们配置这个第三方工具为Oracle javac的话，那么Maven也就直接支持lombok了
3)Intellij Idea配置的编译工具为Oracle javac的话，也就直接支持lombok了。
4)Eclipse中使用的不是Oracle javac这个编译工具，而是自己实现的Eclipse Compiler for Java (ECJ).要想使ECJ支持lombok，得进行设置，具体是在Eclipse程序目录中的eclipse.ini文件中添加如下两行设置：
-javaagent:[lombok.jar所在路径]
-Xbootclasspath/a:[lombok.jar所在路径]
五、其他问题
现在使用Intellij Idea作为Java项目的IDE，配置Oracle javac作为编译工具。
现在有一个A类，其中有一些字段，没有创建它们的setter和getter方法，使用了lombok的@Data注解，另外有一个B类，它调用了A类实例的相应字段的setter和getter方法
编译A类和B类所在的项目，并不会报错，因为最终生成的A类字节码文件中存在相应字段的setter和getter方法
但是，IDE发现B类源代码中所使用的A类实例的setter和getter方法在A类源代码中找不到定义，IDE会认为这是错误
要解决以上这个不是真正错误的错误，可以下载安装Intellij Idea中的"Lombok plugin"。
六、lombok的罪恶
使用lombok虽然能够省去手动创建setter和getter方法的麻烦，但是却大大降低了源代码文件的可读性和完整性，降低了阅读源代码的舒适度。
参考文献
[1]http://stackoverflow.com/questions/6107197/how-does-lombok-work
[2]https://projectlombok.org/download.html
[3]http://stackoverflow.com/questions/3061654/what-is-the-difference-between-javac-and-the-eclipse-compiler
[4]http://www.ibm.com/developerworks/library/j-lombok/
[5]http://notatube.blogspot.com/2010/12/project-lombok-creating-custom.html