Lombok annotation example

Author: rajeshkawali

src/main/java/com/rajeshkawali/lombok/Actor.java

@@ -0,0 +1,41 @@
+package com.rajeshkawali.lombok;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.Singular;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+@EqualsAndHashCode(callSuper = true, onlyExplicitlyIncluded = true)
+@ToString(callSuper = true, onlyExplicitlyIncluded = true)
+public class Actor extends ActorSuper {
+
+    @ToString.Exclude
+    private String email;
+
+    @ToString.Include
+    @EqualsAndHashCode.Include
+    private String surname;
+}
+
+@Data
+@SuperBuilder
+class ActorSuper {
+    private String firstName;
+    private String gender;
+
+    @Singular
+    private List<String> tags;
+}
+/*
+The @Singular annotation is used together with Lombok @Builder annotation.
+If you annotate one of the collection valued field with @Singular annotation Lombok generates for the field :
+
+1.One ‘adder’ method for adding single element to collection.
+2.Another ‘adder’ method for adding another collection to the collection, this name is plural for the field name .
+3.Clear method to clear collection elements.
+ */

src/main/java/com/rajeshkawali/lombok/Address.java

@@ -0,0 +1,25 @@
+package com.rajeshkawali.lombok;
+
+import lombok.*;
+
+@ToString(includeFieldNames = false) // includeFieldNames = false --> field name will not add while printing the object
+@EqualsAndHashCode
+@Getter
+@Setter
+//@RequiredArgsConstructor
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class Address {
+
+    public String city;
+
+    @EqualsAndHashCode.Exclude // We can exclude field from equal and hashcode methods.
+    public String state;
+
+    @Builder.Default // We can provide default value to the field
+    public String country = "India";
+
+    @ToString.Exclude
+    public Long pin;
+}

src/main/java/com/rajeshkawali/lombok/ImmutableClass.java

@@ -0,0 +1,33 @@
+package com.rajeshkawali.lombok;
+
+
+import lombok.Value;
+/*
+@Value annotation -->is shorthand for the annotation combination of
+@Getter
+@FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE)
+@AllArgsConstructor
+@ToString
+@EqualsAndHashCode .
+ */
+@Value
+//@Value(staticConstructor = "getInstance") //Constructor will be private, a static factory method is created to that other classes can use to create instances.
+public class ImmutableClass {
+    private Long id;
+    private String username;
+}
+
+/*
+@Data	                                                @Value
+1.Lombok generated class is not final.	                1.Lombok generated class is final.
+2.Generates required-args constructor.	                2.Generates all-args constructor.
+3.Generates equals(), hashCode() and toString().	    3.Generates equals(), hashCode() and toString().
+4.Does not make fields final.	                        4.Makes all non-static fields final.
+
+5.Generates setters and getters.
+No getters/setters are generated for
+static fields and no setters
+generate for final fields.	                            5.No setters generate for any filed as it makes all
+                                                        fields final except static fields, and obviously no getters
+                                                        generate for static fields.
+ */

src/main/java/com/rajeshkawali/lombok/LombokCleanup.java

@@ -0,0 +1,48 @@
+package com.rajeshkawali.lombok;
+
+import lombok.Cleanup;
+import lombok.SneakyThrows;
+import lombok.Synchronized;
+
+import java.io.*;
+
+public class LombokCleanup {
+    public static void main(String[] args) throws IOException {
+
+        @Cleanup // This will close all the connections/opened files before exit
+        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);
+        }
+
+        sneakyThrowsExample();
+    }
+
+    //If we remove this annotation then we forced to handle it or use throws. (Unhandled exception: java.io.FileNotFoundException)
+    //You can pass any number of exceptions to the @SneakyThrows annotation. If you pass no exceptions, you may throw any exception sneakily.
+    @SneakyThrows // @SneakyThrows - can be used to sneakily throw checked exceptions without actually declaring this in your method's throws clause.
+    public static String sneakyThrowsExample(){
+        if(true){
+            throw new FileNotFoundException("");
+        }else {
+            return "";
+        }
+    }
+
+    /*
+    @Synchronized is a safer variant of the synchronized method modifier.
+    Like synchronized, the annotation can be used on static and instance methods only.
+    It operates similarly to the synchronized keyword, but it locks on different objects.
+    The keyword locks on this, but the annotation locks on a field named $lock, which is private.
+     */
+    @Synchronized
+    public void foo() {
+        System.out.println("bar");
+    }
+}

src/main/java/com/rajeshkawali/lombok/LombokMain.java

@@ -0,0 +1,46 @@
+package com.rajeshkawali.lombok;
+
+
+import lombok.extern.slf4j.Slf4j;
+import lombok.val;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Rajesh_Kawali
+ *
+ * @see "https://projectlombok.org/features/"
+ */
+@Slf4j //@Slf4j - Logger to print on console
+public class LombokMain {
+    public static void main(String[] args) {
+
+        val phone = List.of("9988776655","9944556677"); //Lombok also contain var -> var works exactly like val, except the local variable is not marked as final.
+        //@Builder - Builder annotation uses the Builder pattern to construct the object
+        User user = User.builder()
+                .id(1L)
+                .age(24)
+                //.role("Sr.Software Engineer")
+                .gender("Male")
+                .firstName("Keshav")
+                .lastName("Koli")
+                .phone(phone)
+                .address(Address.builder().city("Mumbai").state("Maharashtra").country("India").pin(400091L).build())
+                .build();
+
+        log.info("User Details are: {}", user);
+        log.info("-----------------------------------");
+        Actor actor = Actor.builder().build();
+        actor.setFirstName("Rajesh");
+        actor.setSurname("Kawali");
+        actor.setEmail("rajesh@gmail.com");
+        actor.setGender("Male");
+        actor.setTags(Arrays.asList("software developer","UI developer"));
+        log.info("Actor Details are: {}", actor);
+        log.info("-----------------------------------");
+        Actor actor2 = Actor.builder().clearTags().build(); // clearTags() --> added by @Singular annotation
+        log.info("Actor Details are: {}", actor);
+        log.info("Actor two Details are: {}", actor2);
+    }
+}

src/main/java/com/rajeshkawali/lombok/User.java

@@ -0,0 +1,38 @@
+package com.rajeshkawali.lombok;
+
+import lombok.*;
+import lombok.experimental.NonFinal;
+
+import java.util.List;
+
+/**
+ * @author Rajesh_Kawali
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+@Data // @Data annotation is shortcut for @ToString, @EqualsAndHashCode, @Getter on all fields, @Setter on all non-final fields, and @RequiredArgsConstructor
+@Builder //Builder annotation uses the Builder pattern to construct the object
+//@Builder(builderClassName = "HelloWorldBuilder", buildMethodName = "execute", builderMethodName = "helloWorld", toBuilder = true, access = AccessLevel.PRIVATE, setterPrefix = "set")
+public class User {
+
+    private Long id;
+
+    @NonNull //null-check for field,If null throw NullPointerException("param is marked non-null but is null").
+    private String firstName;
+
+    private String lastName;
+
+    @Setter(AccessLevel.PACKAGE)
+    private Integer age;
+
+    @Setter(AccessLevel.PUBLIC) // We can provide access level to the field
+    private String gender;
+
+    @NonFinal // We can make final field/final class as non-final using @NonFinal.
+    @Getter(lazy = true)// First time this getter is called, and cache it- It is useful when there is complex task perform once and cache it.
+    private final String role = "Software Engineer";
+
+    private List<String> phone;
+
+    private Address address;
+}