lombok_lombok 介绍 - CSDN
lombok 订阅
Lombok项目是一个Java库,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。 展开全文
Lombok项目是一个Java库,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。
信息
外文名
Lombok
中文名
龙目
linux简介
“Boilerplate”是一个术语,用于描述在应用程序的许多部分中很少改动就重复的代码。对Java语言最常见的批评就是在大多数项目中都可以找到这种类型的代码,由于语言本身的局限性而更加严重。龙目岛计划(Project Lombok)旨在通过用简单的注释集代替众多的代码。Lombok也存在一定风险,在一些开发工具商店中没有Project Lombok支持选择。 IDE和JDK升级存在破裂的风险,并且围绕项目的目标和实施存在争议。常用注解:@Setter :注解在类或字段,注解在类时为所有字段生成setter方法,注解在字段上时只为该字段生成setter方法。@Getter :使用方法同上,区别在于生成的是getter方法。@ToString :注解在类,添加toString方法。@EqualsAndHashCode: 注解在类,生成hashCode和equals方法。@NoArgsConstructor: 注解在类,生成无参的构造方法。@RequiredArgsConstructor: 注解在类,为类中需要特殊处理的字段生成构造方法,比如final和被@NonNull注解的字段。@AllArgsConstructor: 注解在类,生成包含类中所有字段的构造方法。@Data: 注解在类,生成setter/getter、equals、canEqual、hashCode、toString方法,如为final属性,则不会为该属性生成setter方法。@Slf4j: 注解在类,生成log变量,严格意义来说是常量。
收起全文
精华内容
参与话题
  • Intellij IDEA 安装lombok及使用详解

    万次阅读 多人点赞 2017-08-11 11:54:22
    项目中经常使用bean,entity等类,绝大部分数据类类中都需要get、set、toString、equals和hashCode...而使用了lombok则不一样,使用了lombok的注解(@Setter,@Getter,@ToString,@@RequiredArgsConstructor,@EqualsAndHas

           项目中经常使用bean,entity等类,绝大部分数据类类中都需要get、set、toString、equals和hashCode方法,虽然eclipse和idea开发环境下都有自动生成的快捷方式,但自动生成这些代码后,如果bean中的属性一旦有修改、删除或增加时,需要重新生成或删除get/set等方法,给代码维护增加负担。而使用了lombok则不一样,使用了lombok的注解(@Setter,@Getter,@ToString,@@RequiredArgsConstructor,@EqualsAndHashCode或@Data)之后,就不需要编写或生成get/set等方法,很大程度上减少了代码量,而且减少了代码维护的负担。故强烈建议项目中使用lombok,去掉bean中get、set、toString、equals和hashCode等方法的代码。

     一、实战

       1.安装lombok插件:

          具体流程如图:

          1.1

                                             

           1.2

             

           1.3

              

        2.添加lombok的maven的pom.xml依赖:         

      <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.10</version>
      </dependency>

        3. 示例代码Student.java

    package com.lombok.demo;
    
    
    import lombok.EqualsAndHashCode;
    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    /**
     * Created by zhangzh on 2017/2/8.
     */
    @Setter
    @Getter
    @ToString
    @EqualsAndHashCode
    public class Student {
    
        private String name;
        private int age;
        private String male;
        private String studentNo;
    }
    

         4. 测试类LombokTest.java

    package com.lombok.demo;
    
    import lombok.extern.java.Log;
    
    /**
     * Created by zhangzh on 2017/2/8.
     */
    @Log
    public class LombokTest {
    
        public static void main(String[] args) {
    
            Student student = new Student();
            student.setAge(27);
            student.setMale("man");
            student.setName("lance");
            student.setStudentNo("2017");
    
            System.out.println(student.toString());
    
            Student student2 = new Student();
            student2.setAge(27);
            student2.setMale("man");
            student2.setName("lance");
            student2.setStudentNo("2017");
    
            System.out.println(student.equals(student2));
    
            student2.setStudentNo("2018");
    
            System.out.println(student.equals(student2));
    
            log.info("lombok test");
    
        }
    }
    

        5. 输出结果:   

    Student(name=lance, age=27, male=man, studentNo=2017)
    true
    false
    lombok test


    结果分析,如果没有添加@Setter注解,则LombokTest中的student示例无法使用setAge()等方法。使用lombok之后,省去了许多没必要的get,set,toString,equals,hashCode代码,简化了代码编写,减少了代码量。
          另外@Data注解的作用相当于 @Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode的合集。
          另外@Log 省去了在LombokTest中添加 getLogger的如下代码: 


    private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());

    看,简单吧!
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • Lombok使用示例详情

    万次阅读 2019-07-30 18:06:48
    Lombok是一个可以通过注解来帮助我们简化消除一些必须有但显得很臃肿的Java代码的一种工具,通过使用对应的注解,可以在编译源码的时候动态添加源码。 例如在实体中经常见到一堆Getter和Setter方法,这些方法是...
    分享一个朋友的人工智能教程。比较通俗易懂,风趣幽默,感兴趣的朋友可以去看看。

    简介

    Lombok是一个可以通过注解来帮助我们简化消除一些必须有但显得很臃肿的Java代码的一种工具,通过使用对应的注解,可以在编译源码的时候动态添加源码。

    例如在实体中经常见到一堆Getter和Setter方法,这些方法是必要的不可缺少的,但是这些代码感觉却像是“垃圾”,看起来重复而臃肿,看起来也不美观,也不简洁清爽,可以使用lombok,在类上直接使用@Getter @Setter 这两个注解,那么代码在编译的时候会自动帮你生成这个类下的所有字段对应的Getter和Setter方法,实体中只有一些属性,看起来实体类变得简洁很多,虽然IDE可以很快的生成出来,但是生成之后的实体还是那么的臃肿,而且如果修改了字段的名称或者字段的类型还要重新生成,比较麻烦,使用Lombok就是消除一些含金量不高却必须要有的代码,使程序员看起来代码更加简洁、清爽。

    Automatic Resource Management, automatic generation of getters, setters, equals, hashCode and toString, and more!

    lombok的官方地址:https://projectlombok.org/
    lombok的Github地址:https://github.com/rzwitserloot/lombok

    Lombok plugin 插件

    Intellij idea 使用Lombok需要安装插件:Lombok plugin: Preferences —> Plugins —> 搜索 Lombok plugin — > Install
    同时设置 Preferences -> Compiler -> Annotation Processors -> Enable annotation processing勾选。
    这里写图片描述

    使用示例

    首先引入lombok依赖

    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
        <scope>provided</scope>
    </dependency>
    

    1. @Getter/@Setter

    为字段生成Getter和Setter方法,可以注解到字段或者类上(注解在类上会为类中的所有字段生成Getter和Setter方法),默认是public类型的,如果需要的话可以修改方法的访问级别。

    public class User {
        @Getter @Setter
        private Long id;
    
        @Getter(AccessLevel.PROTECTED)
        private String phone;
    
        private String password;
    }
    

    编译后的代码:

    public class User {
        private Long id;
        private String phone;
        private String password;
    
        public User() {
        }
    
        public Long getId() {
            return this.id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        protected String getPhone() {
            return this.phone;
        }
    }
    

    结果解释:

    id字段生成了Getter&Setter,访问修饰符是public
    phone只生成了Getter方法,因为只使用了@Getter而没有使用@Setter, 并且访问修饰符是protected
    password 上并没有注解,所以什么都不生成
    注意:Lombok中的注解一般都会包含一个无参构造函数注解@NoArgsConstructor(用于生成无参构造函数的) ,所以还会额外生成一个无参构造函数

    @Getter @Setter 注解在类上,表示为类中的所有字段生成Getter&Setter方法。

    @Getter @Setter
    public class User {
        private Long id;
        private String phone;
        private String password;
    }
    
    public class User {
        private Long id;
        private String phone;
        private String password;
    
        public User() {
        }
    
        public Long getId() {
            return this.id;
        }
    
        public String getPhone() {
            return this.phone;
        }
    
        public String getPassword() {
            return this.password;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }
    

    2. @NonNull

    为字段赋值时(即调用字段的setter方法时),如果传的参数为null,则会抛出空异常NullPointerException,生成setter方法时会对参数是否为空检查

    @Getter
    @Setter
    public class User {
        private Long id;
    
        @NonNull
        private String phone;
    }
    
    public class User {
        private Long id;
        @NonNull
        private String phone;
    
        public User() {
        }
    
        public Long getId() {
            return this.id;
        }
    	public void setId(Long id) {
            this.id = id;
        }
        @NonNull
        public String getPhone() {
            return this.phone;
        }
    
        public void setPhone(@NonNull String phone) {
            if(phone == null) {
                throw new NullPointerException("phone");
            } else {
                this.phone = phone;
            }
        }
    }
    

    3. @NoArgsConstructor

    生成一个无参构造方法。当类中有final字段没有被初始化时,编译器会报错,此时可用@NoArgsConstructor(force = true),然后就会为没有初始化的final字段设置默认值 0 / false / null, 这样编译器就不会报错。对于具有约束的字段(例如@NonNull字段),不会生成检查或分配,因此请注意,正确初始化这些字段之前,这些约束无效。

    @NoArgsConstructor(force = true)
    public class User {
        private Long id;
    
        @NonNull
        private String phone;
    
        private final Integer age;
    }
    
    public class User {
        private Long id;
        @NonNull
        private String phone;
        private final Integer age = null;
    
        public User() {
        }
    }
    

    4. @RequiredArgsConstructor

    生成构造方法(可能带参数也可能不带参数),如果带参数,这参数只能是以final修饰的未经初始化的字段,或者是以@NonNull注解的未经初始化的字段。

    @RequiredArgsConstructor(staticName = “of”)会生成一个of()的静态方法,并把构造方法设置为私有的

    @RequiredArgsConstructor
    public class User {
        private Long id;
    
        @NonNull
        private String phone;
    
        @NotNull
        private Integer status = 0;
    
        private final Integer age;
        private final String country = "china";
    }
    
    public class User {
        private Long id;
        @NonNull
        private String phone;
        @NotNull
        private Integer status = Integer.valueOf(0);
        private final Integer age;
        private final String country = "china";
    
        public User(@NonNull String phone, Integer age) {
            if(phone == null) {
                throw new NullPointerException("phone");
            } else {
                this.phone = phone;
                this.age = age;
            }
        }
    }
    

    必要的构造函数只会生成final修饰的未经初始化的字段或者是以@NonNull注解的未经初始化的字段, 所以生成了public User(@NonNull String phone, Integer age)构造函数

    @RequiredArgsConstructor(staticName = "of")
    public class User {
        private Long id;
    
        @NonNull
        private String phone;
    
        @NotNull
        private Integer status = 0;
    
        private final Integer age;
        private final String country = "china";
    }
    
    
    public class User {
        private Long id;
        @NonNull
        private String phone;
        @NotNull
        private Integer status = Integer.valueOf(0);
        private final Integer age;
        private final String country = "china";
    
        private User(@NonNull String phone, Integer age) {
            if(phone == null) {
                throw new NullPointerException("phone");
            } else {
                this.phone = phone;
                this.age = age;
            }
        }
    
        public static User of(@NonNull String phone, Integer age) {
            return new User(phone, age);
        }
    }
    

    5. @AllArgsConstructor

    生成一个全参数的构造方法

    @AllArgsConstructor
    public class User {
        private Long id;
    
        @NonNull
        private String phone;
    
        @NotNull
        private Integer status = 0;
    
        private final Integer age;
        private final String country = "china";
    }
    
    
    public class User {
        private Long id;
        @NonNull
        private String phone;
        @NotNull
        private Integer status = Integer.valueOf(0);
        private final Integer age;
        private final String country = "china";
    
        public User(Long id, @NonNull String phone, Integer status, Integer age) {
            if(phone == null) {
                throw new NullPointerException("phone");
            } else {
                this.id = id;
                this.phone = phone;
                this.status = status;
                this.age = age;
            }
        }
    }
    

    6. @ToString

    生成toString()方法,默认情况下它会按顺序(以逗号分隔)打印你的类名称以及每个字段。可以这样设置不包含哪些字段,可以指定一个也可以指定多个@ToString(exclude = “id”) / @ToString(exclude = {“id”,“name”})
    如果继承的有父类的话,可以设置callSuper 让其调用父类的toString()方法,例如:@ToString(callSuper = true)

    @ToString(exclude = {"password", "salt"})
    public class User {
    
        private Long id;
    
        private String phone;
    
        private String password;
    
        private String salt;
    }
    
    
    public class User {
        private Long id;
        private String phone;
        private String password;
        private String salt;
    
        public User() {
        }
    
        public String toString() {
            return "User(id=" + this.id + ", phone=" + this.phone + ")";
        }
    }
    
    @ToString(exclude = {"password", "salt"}, callSuper = true)
    public class User {
    
        private Long id;
    
        private String phone;
    
        private String password;
    
        private String salt;
    }
    
    
    public class User {
        private Long id;
        private String phone;
        private String password;
        private String salt;
    
        public User() {
        }
    
        public String toString() {
            return "User(super=" + super.toString() + ", id=" + this.id + ", phone=" + this.phone + ")";
        }
    }
    

    7. @EqualsAndHashCode

    生成hashCode()和equals()方法,默认情况下,它将使用所有非静态,非transient字段。但可以通过在可选的exclude参数中来排除更多字段。或者,通过在of参数中命名它们来准确指定希望使用哪些字段。

    // exclude 排除字段
    @EqualsAndHashCode(exclude = {“password”, “salt”})

    // of 指定要包含的字段
    @EqualsAndHashCode(of = {“id”, “phone”, “password”})

    @EqualsAndHashCode
    public class User implements Serializable{
    
        private static final long serialVersionUID = 6569081236403751407L;
    
        private Long id;
    
        private String phone;
    
        private transient int status;
    }
    
    
    
    public class User implements Serializable {
        private static final long serialVersionUID = 6569081236403751407L;
        private Long id;
        private String phone;
        private transient int status;
    
        public User() {
        }
    
        public boolean equals(Object o) {
            if(o == this) {
                return true;
            } else if(!(o instanceof User)) {
                return false;
            } else {
                User other = (User)o;
                if(!other.canEqual(this)) {
                    return false;
                } else {
                    Long this$id = this.id;
                    Long other$id = other.id;
                    if(this$id == null) {
                        if(other$id != null) {
                            return false;
                        }
                    } else if(!this$id.equals(other$id)) {
                        return false;
                    }
    
                    String this$phone = this.phone;
                    String other$phone = other.phone;
                    if(this$phone == null) {
                        if(other$phone != null) {
                            return false;
                        }
                    } else if(!this$phone.equals(other$phone)) {
                        return false;
                    }
    
                    return true;
                }
            }
        }
    
        protected boolean canEqual(Object other) {
            return other instanceof User;
        }
    
        public int hashCode() {
            boolean PRIME = true;
            byte result = 1;
            Long $id = this.id;
            int result1 = result * 59 + ($id == null?43:$id.hashCode());
            String $phone = this.phone;
            result1 = result1 * 59 + ($phone == null?43:$phone.hashCode());
            return result1;
        }
    }
    

    生成了 equals 、hashCode 和 canEqual 无参构造函数 四个方法

    8. @Data

    @Data 包含了 @ToString、@EqualsAndHashCode、@Getter / @Setter和@RequiredArgsConstructor的功能

    @Data
    public class User {
        private Long id;
        private String phone;
        private Integer status;
    }
    
    
    public class User {
        private Long id;
        private String phone;
        private Integer status;
    
        public User() {
        }
    
        public Long getId() {
            return this.id;
        }
    
        public String getPhone() {
            return this.phone;
        }
    
        public Integer getStatus() {
            return this.status;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public void setStatus(Integer status) {
            this.status = status;
        }
    
        public boolean equals(Object o) {
            if(o == this) {
                return true;
            } else if(!(o instanceof User)) {
                return false;
            } else {
                User other = (User)o;
                if(!other.canEqual(this)) {
                    return false;
                } else {
                    label47: {
                        Long this$id = this.getId();
                        Long other$id = other.getId();
                        if(this$id == null) {
                            if(other$id == null) {
                                break label47;
                            }
                        } else if(this$id.equals(other$id)) {
                            break label47;
                        }
    
                        return false;
                    }
    
                    String this$phone = this.getPhone();
                    String other$phone = other.getPhone();
                    if(this$phone == null) {
                        if(other$phone != null) {
                            return false;
                        }
                    } else if(!this$phone.equals(other$phone)) {
                        return false;
                    }
    
                    Integer this$status = this.getStatus();
                    Integer other$status = other.getStatus();
                    if(this$status == null) {
                        if(other$status != null) {
                            return false;
                        }
                    } else if(!this$status.equals(other$status)) {
                        return false;
                    }
    
                    return true;
                }
            }
        }
    
        protected boolean canEqual(Object other) {
            return other instanceof User;
        }
    
        public int hashCode() {
            boolean PRIME = true;
            byte result = 1;
            Long $id = this.getId();
            int result1 = result * 59 + ($id == null?43:$id.hashCode());
            String $phone = this.getPhone();
            result1 = result1 * 59 + ($phone == null?43:$phone.hashCode());
            Integer $status = this.getStatus();
            result1 = result1 * 59 + ($status == null?43:$status.hashCode());
            return result1;
        }
    
        public String toString() {
            return "User(id=" + this.getId() + ", phone=" + this.getPhone() + ", status=" + this.getStatus() + ")";
        }
    }
    

    9. @Value

    @Value 将字段都变成不可变类型:使用final修饰, 同时还包含@ToString、@EqualsAndHashCode、@AllArgsConstructor 、@Getter(注意只有Getter没有Setter)

    @Value
    public class User {
        private Long id;
        private String username;
    }
    
    
    public final class User {
        private final Long id;
        private final String username;
    
        public User(Long id, String username) {
            this.id = id;
            this.username = username;
        }
    
        public Long getId() {
            return this.id;
        }
    
        public String getUsername() {
            return this.username;
        }
    
        public boolean equals(Object o) {
            if(o == this) {
                return true;
            } else if(!(o instanceof User)) {
                return false;
            } else {
                User other = (User)o;
                Long this$id = this.getId();
                Long other$id = other.getId();
                if(this$id == null) {
                    if(other$id != null) {
                        return false;
                    }
                } else if(!this$id.equals(other$id)) {
                    return false;
                }
    
                String this$username = this.getUsername();
                String other$username = other.getUsername();
                if(this$username == null) {
                    if(other$username != null) {
                        return false;
                    }
                } else if(!this$username.equals(other$username)) {
                    return false;
                }
    
                return true;
            }
        }
    
        public int hashCode() {
            boolean PRIME = true;
            byte result = 1;
            Long $id = this.getId();
            int result1 = result * 59 + ($id == null?43:$id.hashCode());
            String $username = this.getUsername();
            result1 = result1 * 59 + ($username == null?43:$username.hashCode());
            return result1;
        }
    
        public String toString() {
            return "User(id=" + this.getId() + ", username=" + this.getUsername() + ")";
        }
    }
    
    

    10. @Log

    生成log对象,用于记录日志,可以通过topic属性来设置getLogger(String name)方法的参数 例如 @Log4j(topic = “com.xxx.entity.User”),默认是类的全限定名,即 类名.class,log支持以下几种:

    • @Log java.util.logging.Logger
    • @Log4j org.apache.log4j.Logger
    • @Log4j2 org.apache.logging.log4j.Logger
    • @Slf4j org.slf4j.Logger
    • @XSlf4j org.slf4j.ext.XLogger
    • @CommonsLog org.apache.commons.logging.Log
    • @JBossLog org.jboss.logging.Logger
    @Log
     	private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());
    @Log4j
    	private static final Logger log = org.apache.log4j.Logger.Logger.getLogger(UserService.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);
     @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
    public class UserService {
    
        public void addUser(){
            log.info("add user");
        }
    }
    
    
    import java.util.logging.Logger;
    
    public class UserService {
        private static final Logger log = Logger.getLogger(UserService.class.getName());
    
        public UserService() {
        }
    }
    

    11. @SneakyThrows

    使用try catch 来捕获异常, 默认捕获的是Throwable异常,也可以设置要捕获的异常

    public class User {
    
        @SneakyThrows
        public void sleep(){
            Thread.sleep(1000);
        }
    
        @SneakyThrows(InterruptedException.class)
        public void sleep2()  {
            Thread.sleep(1000);
        }
    }
    
    
    public class User {
        public User() {
        }
    
        public void sleep() {
            try {
                Thread.sleep(1000L);
            } catch (Throwable var2) {
                throw var2;
            }
        }
    
        public void sleep2() {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException var2) {
                throw var2;
            }
        }
    
        public static void main(String[] args) {
        }
    }
    

    12. @Synchronized

    给方法加上同步锁

    public class User {
        private final Object readLock = new Object();
    
        @Synchronized
        public static void foo(){
            System.out.println();
        }
    
        @Synchronized
        public void bar(){
            System.out.println();
        }
    
        @Synchronized("readLock")
        public void test() {
            System.out.println();
        }
    }
    
    
    public class User {
        private static final Object $LOCK = new Object[0];
        private final Object $lock = new Object[0];
        private final Object readLock = new Object();
    
        public User() {
        }
    
        public static void foo() {
            Object var0 = $LOCK;
            synchronized($LOCK) {
                System.out.println();
            }
        }
    
        public void bar() {
            Object var1 = this.$lock;
            synchronized(this.$lock) {
                System.out.println();
            }
        }
    
        public void test() {
            Object var1 = this.readLock;
            synchronized(this.readLock) {
                System.out.println();
            }
        }
    }
    

    13. @Cleanup

    主要用来修饰 IO 流相关类, 会在 finally 代码块中对该资源进行 close();

    public class CleanupExample {
      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[10000];
        while (true) {
          int r = in.read(b);
          if (r == -1) break;
          out.write(b, 0, r);
        }
      }
    }
    
    
    public class CleanupExample {
      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();
          }
        }
      }
    }
    

    14. @Getter(lazy = true)

    @Getter(lazy = true)
    标注字段为懒加载字段,懒加载字段在创建对象时不会进行初始化,而是在第一次访问的时候才会初始化,后面再次访问也不会重复初始化

    public class User {
    
        private final List<String> cityList = getCityFromCache();
    
        private List<String> getCityFromCache() {
            System.out.println("get city from cache ...");
            return new ArrayList<>();
        }
    }
    
    
    public static void main(String[] args) {
         User user = new User();  // 出事化对象时会会执行getCityFromCache()方法
    }
    
    public class User {
        @Getter(lazy = true)
        private final List<String> cityList = getCityFromCache();
    
        private List<String> getCityFromCache() {
            System.out.println("get city from cache ...");
            return new ArrayList<>();
        }
    }
    
    
    
    public class User {
        private final AtomicReference<Object> cityList = new AtomicReference();
    
        public User() {
        }
    
        private List<String> getCityFromCache() {
            System.out.println("get city from cache ...");
            return new ArrayList();
        }
    
        public List<String> getCityList() {
            Object value = this.cityList.get();
            if(value == null) {
                AtomicReference var2 = this.cityList;
                synchronized(this.cityList) {
                    value = this.cityList.get();
                    if(value == null) {
                        List actualValue = this.getCityFromCache();
                        value = actualValue == null?this.cityList:actualValue;
                        this.cityList.set(value);
                    }
                }
            }
    
            return (List)((List)(value == this.cityList?null:value));
        }
    }
    

    @Getter(lazy = true):为懒加载字段生成一个Getter方法

    public static void main(String[] args) {
        User user = new User();		// 创建对象时不会初始化懒加载的字段
        List<String> cityList = user.getCityList();  // 只有第一次访问属性时才会去初始化
    
        cityList = user.getCityList();	// 第二次就不会再次初始化了
    }
    

    15. @Wither

    提供了给final字段赋值的一种方法

    public class User {
        @Wither
        private final String country;
    
        public User(String country) {
            this.country = country;
        }
    }
    
    
    public class User {
        private final String country;
    
        public User(String country) {
            this.country = country;
        }
    
        public User withCountry(String country) {
            return this.country == country?this:new User(country);
        }
    }
    

    16. @Builder

    @Builder注释为你的类生成复杂的构建器API。

    @Builder
    public class User {
        private Long id;
        private String phone;
    
    }
    
    
    public class User {
        private Long id;
        private String phone;
    
        User(Long id, String phone) {
            this.id = id;
            this.phone = phone;
        }
    
        public static User.UserBuilder builder() {
            return new User.UserBuilder();
        }
    
        public static class UserBuilder {
            private Long id;
            private String phone;
    
            UserBuilder() {
            }
    
            public User.UserBuilder id(Long id) {
                this.id = id;
                return this;
            }
    
            public User.UserBuilder phone(String phone) {
                this.phone = phone;
                return this;
            }
    
            public User build() {
                return new User(this.id, this.phone);
            }
    
            public String toString() {
                return "User.UserBuilder(id=" + this.id + ", phone=" + this.phone + ")";
            }
        }
    }
    

    17. @Delegate

    为List类型的字段生成一大堆常用的方法,其实这些方法都是List中的方法
    注意:一个类中只能使用一个@Delegate注解,因为使用多个会生成多个size()方法,从而会编译报错。

    public class User {
        @Delegate
        private List<String> address;
    }
    
    
    
    public class User {
        private List<String> address;
    
        public User() {
        }
    
        public int size() {
            return this.address.size();
        }
    
        public boolean isEmpty() {
            return this.address.isEmpty();
        }
    
        public boolean contains(Object arg0) {
            return this.address.contains(arg0);
        }
    
        public Iterator<String> iterator() {
            return this.address.iterator();
        }
    
        public Object[] toArray() {
            return this.address.toArray();
        }
    
        public <T> T[] toArray(T[] arg0) {
            return this.address.toArray(arg0);
        }
    
        public boolean add(String arg0) {
            return this.address.add(arg0);
        }
    
        public boolean remove(Object arg0) {
            return this.address.remove(arg0);
        }
    
        public boolean containsAll(Collection<?> arg0) {
            return this.address.containsAll(arg0);
        }
    
        public boolean addAll(Collection<? extends String> arg0) {
            return this.address.addAll(arg0);
        }
    
        public boolean addAll(int arg0, Collection<? extends String> arg1) {
            return this.address.addAll(arg0, arg1);
        }
    
        public boolean removeAll(Collection<?> arg0) {
            return this.address.removeAll(arg0);
        }
    
        public boolean retainAll(Collection<?> arg0) {
            return this.address.retainAll(arg0);
        }
    
        public void replaceAll(UnaryOperator<String> arg0) {
            this.address.replaceAll(arg0);
        }
    
        public void sort(Comparator<? super String> arg0) {
            this.address.sort(arg0);
        }
    
        public void clear() {
            this.address.clear();
        }
    
        public String get(int arg0) {
            return (String)this.address.get(arg0);
        }
    
        public String set(int arg0, String arg1) {
            return (String)this.address.set(arg0, arg1);
        }
    
        public void add(int arg0, String arg1) {
            this.address.add(arg0, arg1);
        }
    
        public String remove(int arg0) {
            return (String)this.address.remove(arg0);
        }
    
        public int indexOf(Object arg0) {
            return this.address.indexOf(arg0);
        }
    
        public int lastIndexOf(Object arg0) {
            return this.address.lastIndexOf(arg0);
        }
    
        public ListIterator<String> listIterator() {
            return this.address.listIterator();
        }
    
        public ListIterator<String> listIterator(int arg0) {
            return this.address.listIterator(arg0);
        }
    
        public List<String> subList(int arg0, int arg1) {
            return this.address.subList(arg0, arg1);
        }
    
        public Spliterator<String> spliterator() {
            return this.address.spliterator();
        }
    }
    
    

    lombok.config

    lombok.config配置文件是通过一些设置来控制代码生成的规则或者称之为习惯,配置文件的位置应放在src/mian/java,不要放置在src/main/resources。

    注意配置文件和要使用注解的类要在同一套代码中,要么同时在src/main/java 要么同时在 src/test/java中

    lombok.config

    #lombok 默认对boolean类型字段生成的get方法使用is前缀, 通过此配置则使用get前缀,默认: false
    lombok.getter.noIsPrefix=true
    
    #默认的set方法返回void设置为true返回调用对象本身,这样方便使用链式来继续调用方法,默认: false
    lombok.accessors.chain=true
    
    #如果设置为true  get和set方法将不带get,set前缀, 直接以字段名为方法名, 默认: false
    lombok.accessors.fluent=true
    
    #设置log类注解返回的字段名称,默认: log
    lombok.log.fieldName=logger
    
    @Log4j
    @Getter @Setter
    public class User {
        private String username;
        private boolean vip;
        private boolean isOldUser;
    }
    
    public class User {
        private static final Logger logger = Logger.getLogger(User.class);
        private String username;
        private boolean vip;
        private boolean isOldUser;
    
        public User() {
        }
    
        public String username() {
            return this.username;
        }
    
        public boolean vip() {
            return this.vip;
        }
    
        public boolean isOldUser() {
            return this.isOldUser;
        }
    
        public User username(String username) {
            this.username = username;
            return this;
        }
    
        public User vip(boolean vip) {
            this.vip = vip;
            return this;
        }
    
        public User isOldUser(boolean isOldUser) {
            this.isOldUser = isOldUser;
            return this;
        }
    }
    
    
    分享一个朋友的人工智能教程。比较通俗易懂,风趣幽默,感兴趣的朋友可以去看看。
    展开全文
  • Lombok详解

    千次阅读 2019-02-24 15:18:01
    lombok介绍 lombok可以通过简单的注解的形式来帮助我们简化和消除一些必须有但显得很臃肿的Java代码,比如常见的Getter&amp;amp;Setter、toString()、构造函数等等。lombok不仅方便编写,同时也让我们的代码更...

    lombok介绍

    lombok可以通过简单的注解的形式来帮助我们简化和消除一些必须有但显得很臃肿的Java代码,比如常见的Getter&Setter、toString()、构造函数等等。lombok不仅方便编写,同时也让我们的代码更简洁。
    lombok提供了一个功能完整的jar包,可以很方便的与我们的项目进行集成。

    maven依赖

    以maven项目为例,pom文件中引入:

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
        <scope>provided</scope>
    </dependency>
    
    lombok插件安装

    下载lombok.jar,(https://projectlombok.org/download.html),建议下载与项目中依赖的lombok版本一致或者更高。
    将下载好的lombok.jar移至eclipse的根目录,和 eclipse.ini 文件平级的。
    在lombok.jar 的目录下,运行:
    这里写图片描述
    java -jar lombok.jar
    a. 运行后会弹框如下框,直接点确定
    这里写图片描述
    b. 点specify location 按钮,选择eclipse的安装目录,选择到eclipse层即可。
    按如下图步骤点击install即可
    这里写图片描述
    这里写图片描述
    c. 成功后如下图:
    这里写图片描述
    黑框框也多了很多log:
    这里写图片描述
    看看是否真的安装成功,可以在 eclipse.ini 中看看,我的环境是多了一行(-javaagent:D:\Program Files\eclipse\lombok.jar)
    这里写图片描述
    重启eclipse,再clean project。

    若是idea,则打开IDEA,选择 file -> settings -> plugins;
    在搜索框中输入Lombok plugin,点击install;重启IDEA,安装完成。

    ** @NonNull**
    给方法参数增加这个注解会自动在方法内对该参数进行是否为空的校验,如果为空,则抛出NPE(NullPointerException)。

    ** @Getter/@Setter**
    使用在成员变量或者类上,为特定成员变量/类中所有变量生成Getter/Setter方法。

    @ToString
    用在类上,可以自动覆写toString方法,当然还可以加其他参数,例如@ToString(exclude=”id”)排除id属性,或者@ToString(callSuper=true, includeFieldNames=true)调用父类的toString方法,包含所有属性。

    @EqualsAndHashCode
    自动生成hashCode() 和 equals()方法。

    @Data
    注解在类上,相当于同时使用了@ToString、@EqualsAndHashCode、@Getter、@Setter和@RequiredArgsConstrutor

    示例:
    使用@Data注释改造下DataDemo,效果如下。需要注意的是使用@RequiredArgsConstrutor生成静态方法需指定staticConstructor的值。

     @Data(staticConstructor = "lombok")
    public class DataDemo{
          private final String name;
          @Setter(value = AccessLevel.PACKAGE) private int age;
          private double score;
          private String[] tags;
    
          @ToString(includeFieldNames=true)
          @Data(staticConstructor="of")
          public static class Exercise<T> {
            private final String name;
            private final T value;
          }
    }
    

    @Value
    用在类上,是@Data的不可变形式,相当于为属性添加final声明,只提供getter方法,而不提供setter方法,具体示例可以参考@Data部分

    @Log
    lombok可以快速生成多种常用日志实例,包括Commonslog、log、log4j、slf4j等等,具体的使用可以依照需求灵活选择。

    ** @Cleanup**
    这个注解用在变量前面,可以保证此变量代表的资源会被自动关闭,默认是调用资源的close()方法,如果该资源有其它关闭方法,可使用@Cleanup(“methodName”)来指定要调用的方法.
    示例:
    @Cleanup不仅减少了代码编写,同时也避免了可能的泄露问题,CleanUpDemo的lombok改造效果如下。

    public class CleanUpDemo {
      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[10000];
        while (true) {
          int r = in.read(b);
          if (r == -1) break;
          out.write(b, 0, r);
        }
      }
    }
    
    展开全文
  • Lombok 看这篇就够了

    千次阅读 2019-07-10 10:36:09
    自从进公司实习后,项目代码中能用 Lombok 的都用了,毕竟这么好的轮子要充分利用好。也可以减少一些 get/set/toString 方法的编写,虽说 IDEA 的插件可以自动生成 get/set/toString 方法,但是使用 Lombok 可以让...

    [外链图片转存失败(img-1326kftV-1562726153337)(http://ohfk1r827.bkt.clouddn.com/blog/180107/7JfK07cCbh.png-1)]

    前提

    自从进公司实习后,项目代码中能用 Lombok 的都用了,毕竟这么好的轮子要充分利用好。也可以减少一些 get/set/toString 方法的编写,虽说 IDEA 的插件可以自动生成 get/set/toString 方法,但是使用 Lombok 可以让代码更简洁。

    下面看看如何在 IDEA 中如何安装 Lombok:

    安装

    打开 IDEA 的 Settings 面板,并选择 Plugins 选项,然后点击 “Browse repositories”

    在输入框输入”lombok”,得到搜索结果,点击安装,然后安装提示重启 IDEA,安装成功;

    [外链图片转存失败(img-JghzhtMs-1562726153341)(http://ohfk1r827.bkt.clouddn.com/blog/180106/C33FG37Gk4.png-1)]

    引入依赖

    在自己的项目里添加 lombok 的编译支持,在 pom 文件里面添加 dependency

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
        <scope>provided</scope>
    </dependency>
    
    

    怎么使用?

    在实体类上引入相关的注解就行:

    [外链图片转存失败(img-jlgrs0LA-1562726153347)(http://ohfk1r827.bkt.clouddn.com/blog/180106/aCEc8ileJg.png-1)]

    有哪些注解?

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

    注解详解

    @Data

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

    [外链图片转存失败(img-OaROYdQa-1562726153361)(http://ohfk1r827.bkt.clouddn.com/blog/180107/mHj1eak6fJ.png-1)]

    @Setter

    注解在 属性 上;为单个属性提供 set 方法; 注解在 上,为该类所有的属性提供 set 方法, 都提供默认构造方法。

    [外链图片转存失败(img-V6xcUMNd-1562726153363)(http://ohfk1r827.bkt.clouddn.com/blog/180107/lkkff2b6Dc.png-1)]

    [外链图片转存失败(img-mDJlx1cP-1562726153367)(http://ohfk1r827.bkt.clouddn.com/blog/180107/J9mC8FGfc0.png-1)]

    @Getter

    注解在 属性 上;为单个属性提供 get 方法; 注解在 上,为该类所有的属性提供 get 方法,都提供默认构造方法。

    [外链图片转存失败(img-xlN8sdwV-1562726153372)(http://ohfk1r827.bkt.clouddn.com/blog/180107/d0F5h97J5f.png-1)]

    [外链图片转存失败(img-zIstCksw-1562726153375)(http://ohfk1r827.bkt.clouddn.com/blog/180107/K0m81cFd6g.png-1)]

    @Log4j

    注解在 上;为类提供一个 属性名为 log 的 log4j 日志对象,提供默认构造方法。

    [外链图片转存失败(img-5aCWr7am-1562726153377)(http://ohfk1r827.bkt.clouddn.com/blog/180107/BChd89Cbh5.png-1)]

    @AllArgsConstructor

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

    [外链图片转存失败(img-1sf6JRw4-1562726153382)(http://ohfk1r827.bkt.clouddn.com/blog/180107/4iji9AJ0fE.png-1)]

    @NoArgsConstructor

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

    [外链图片转存失败(img-BuKDlDhX-1562726153385)(http://ohfk1r827.bkt.clouddn.com/blog/180107/JcdfmhDAaB.png-1)]

    @EqualsAndHashCode

    注解在 上, 可以生成 equals、canEqual、hashCode 方法。

    [外链图片转存失败(img-ZReunVxa-1562726153390)(http://ohfk1r827.bkt.clouddn.com/blog/180108/CKHe7EICGd.png-1)]

    @NonNull

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

    [外链图片转存失败(img-O2SON3wr-1562726153395)(http://ohfk1r827.bkt.clouddn.com/blog/180108/g6Lh1eh1jm.png-1)]

    @Cleanup

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

    [外链图片转存失败(img-5deEGPih-1562726153397)(http://ohfk1r827.bkt.clouddn.com/blog/180108/Ba1bDkKb9J.png-1)]

    @ToString

    这个注解用在 上,可以生成所有参数的 toString 方法,还会生成默认的构造方法。

    [外链图片转存失败(img-UkM3unJt-1562726153403)(http://ohfk1r827.bkt.clouddn.com/blog/180108/7LjglDeH8e.png-1)]

    @RequiredArgsConstructor

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

    [外链图片转存失败(img-hzAL0WON-1562726153407)(http://ohfk1r827.bkt.clouddn.com/blog/180108/CBgAF4ei8m.png-1)]

    @Value

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

    [外链图片转存失败(img-6kKjrlRm-1562726153409)(http://ohfk1r827.bkt.clouddn.com/blog/180108/b6KeAg0ABi.png-1)]

    @SneakyThrows

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

    [外链图片转存失败(img-TJDxRLkX-1562726153435)(http://ohfk1r827.bkt.clouddn.com/blog/180108/IfCKh1FGbh.png-1)]

    @Synchronized

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

    [外链图片转存失败(img-rx7xQB1p-1562726153436)(http://ohfk1r827.bkt.clouddn.com/blog/180108/L95jIc7eJi.png-1)]

    总结

    以上注解可根据需要一起搭配使用!

    虽说轮子好,但是我们不仅要知其然,也要知其所以然!

    关注我

    [外链图片转存失败(img-XBioJqHN-1562726153436)(http://ohfk1r827.bkt.clouddn.com/blog/180103/C6LG3mGa12.jpg)]

    最后

    转载请注明原创地址:http://www.54tianzhisheng.cn/2018/01/09/lombok/

    展开全文
  • Lombok安装及使用介绍

    万次阅读 2018-08-09 16:56:33
    Lombok浅析 简介:  lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码,lombok能够达到的效果就是在源码中不需要写一些通用的方法,但是在编译生成的字节码文件中会帮...
  • 引入lombok依赖

    万次阅读 2019-05-05 14:15:11
    lombok插件是为了方便实体类bean快速生成get set方法,从而不用手动添加 该插件可以在idea的file–>plugins–>搜索框搜索安装 <dependency> <groupId>org.projectlombok</groupId> <...
  • Lombok【汇总】

    千次阅读 2020-04-30 18:12:22
    https://blog.csdn.net/qq_36314960/article/details/79565899
  • Lombok

    千次阅读 2019-08-14 14:16:26
    Lombok介绍 Lombok是一个Java库,能自动插入编辑器并构建工具,简化Java开发。通过添加注解的方式,不需要为类编写getter或eques方法,同时可以自动化日志变量。 Lombok使用方法 Lombok的使用跟引用jar包一样,可以...
  • 点击进入Lombok官网下载Lombok jar包 使用Lombok可能需要注意的...(2)、在使用Lombok时,你的编辑器可能会报错,这时请在你的IDE中安装Lombok插件(如果使用的Idea则直接搜索Lombok插件,选择星级最高的,直接...
  • 深入理解Lombok

    万次阅读 多人点赞 2018-03-15 13:09:24
    说道Lombok,可能会鲜为人知。但是在实际的开发中,它起到了很大的作用,话不多说,直入正题:一、Lombok是什么 现在看一下Lombok官方对其进行的解释:Lombok官网:https://projectlombok.org第一句话,Lombok项目...
  • 十分钟搞懂Lombok使用与原理

    万次阅读 2018-06-07 16:15:19
    Lombok是一种Java™实用工具,可用来帮助开发人员消除Java的冗长代码,尤其是对于简单的Java对象(POJO)。它通过注释实现这一目的。通过在开发环境中实现Lombok,开发人员可以节省...
  • eclipse安装lombok

    万次阅读 多人点赞 2018-02-07 15:33:11
    由于项目中有@Slf4j 注解等,而eclipse需要安装lombok插件才能正常编译。由于之前对lombok 一片空白,查了多个帖子,详细总结了一下在window下eclipse安装lombok。 下载 lombok.jar ...
  • eclipse安装lombok插件

    万次阅读 2018-05-03 13:22:18
    由于项目中有@Slf4j 注解等,而eclipse需要安装lombok插件才能正常编译。由于之前对lombok 一片空白,查了多个帖子,详细总结了一下在window下eclipse安装lombok。 下载 lombok.jar ...
  • compile(‘org.projectlombok:lombok:1.18.2) 当构建项目的时候会出现如下信息 The following annotation processors were detected on the compile classpath: 'lombok.launch.AnnotationProce...
  • eclipse中安装lombok.jar

    万次阅读 2018-11-01 15:00:04
    下载lombok.jar(一定要最新版) 下载地址:https://projectlombok.org/download ... shift+右键唤出命令窗口,运行java -jar lombok.jar 或者 直接双击lombok.jar(后者操作更简单) ...
  • Lombok使用无效,个人情况解决方案

    万次阅读 2017-06-15 21:13:02
    Lombok安装成功后重启JDE,如果还是无法使用注解,记得引入lombok.jar包。 当我引入jar包,使用lombok注解后,并没有自动生成set、get等方法,注解使用无效 检查安装情况: 同目录文件下的lombok.jar存在 ...
  • IDEA报: Lombok Requires Annotation Processing

    万次阅读 2016-11-06 18:34:54
    IDEA使用lombok,提示: Lombok Requires Annotation Processing Annotation processing seems to be disabled for the project "jhipster". For plugin to function correctly, please enable it u
  • IDEA升级到2019.1版本,发现lombok插件提示不兼容。 解决方法: 用压缩工具打开用户目录下 .IdeaC2019.1->config->plugins->lombok-plugin/lib/lombok-plugin-xxxx.jar ,编辑META-INF/plugin.xml 文件第6...
  • 如过安装成功但是@Data等注解无效,可能是由于你的eclipse版本是新版本,你的lombok.jar版本太旧。那么请下载最新的lombok.jar再进行安装。 lombok.jar新版官方下载地址:https://projectlombok.org/
  • sts安装lombok

    万次阅读 热门讨论 2018-05-06 09:18:16
    由于springboot项目中有@Slf4j 注解等,而eclipse需要安装lombok插件才能正常编译打印日志方式:log.info("打印日志");如果不使用注解也可以使用传统的方式打印日志,就是麻烦点:private final Logger ...
1 2 3 4 5 ... 20
收藏数 56,206
精华内容 22,482
关键字:

lombok