What's in Lombok? SpringBoot and IDEA support it!

SpringBoot e-commerce project mall (40K + STAR) address: github.com/macrozheng/…

Abstract

Recently, the last version of IDEA 2020 was released with the Lombok plug-in built in, and SpringBoot 2.1.x and later versions have Lombok dependencies built into the Starter. Why should they all support Lombok? Today I’m going to talk about using Lombok and see what’s amazing about it!

Introduction of Lombok

Lombok is a Java code enhancement library available on Github at 9.8K +Star. It automatically integrates into your editors and build tools to make your Java code more interesting. With Lombok annotations, you don’t have to write getters, setters, equals, etc. Lombok will automatically generate them for you at compile time.

Lombok integration

If you are using the latest version of IDEA 2020.3, Lombok is already built in and you do not need to install it.

Lombok does not need to be specified after SpringBoot 2.1.x. SpringBoot is already built in SpringBoot – Dependencies.

<! - lombok dependence - >
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
Copy the code

Lombok use

There are many annotations in Lombok that make it easier to write Java code. Here’s how to use them.

val

Using val annotations can replace any type as a local variable, so we don’t have to write complex ArrayList and Map.entry types, as shown in the following example.

/** * Created by macro on 2020/12/16. */
public class ValExample {

    public static void example(a) {
        //val replaces ArrayList
      
        and String types
      
        val example = new ArrayList<String>();
        example.add("Hello World!");
        val foo = example.get(0);
        System.out.println(foo.toLowerCase());
    }

    public static void example2(a) {
        // Val replaces map. Entry
      ,string>
        val map = new HashMap<Integer, String>();
        map.put(0."zero");
        map.put(5."five");
        for (val entry : map.entrySet()) {
            System.out.printf("%d: %s\n", entry.getKey(), entry.getValue()); }}public static void main(String[] args) { example(); example2(); }}Copy the code

When we use the val annotation, Lombok will infer the specific type from the initialization expression of the local variable, which when compiled generates the following code.

public class ValExample {
    public ValExample(a) {}public static void example(a) {
        ArrayList<String> example = new ArrayList();
        example.add("Hello World!");
        String foo = (String)example.get(0);
        System.out.println(foo.toLowerCase());
    }

    public static void example2(a) {
        HashMap<Integer, String> map = new HashMap();
        map.put(0."zero");
        map.put(5."five");
        Iterator var1 = map.entrySet().iterator();

        while(var1.hasNext()) {
            Entry<Integer, String> entry = (Entry)var1.next();
            System.out.printf("%d: %s\n", entry.getKey(), entry.getValue()); }}}Copy the code

@NonNull

Using the @nonNULL annotation on a method can make a non-null judgment and throw a NullPointerException if a null value is passed in.

/** * Created by macro on 2020/12/16. */
public class NonNullExample {
    private String name;
    public NonNullExample(@NonNull String name){
        this.name = name;
    }

    public static void main(String[] args) {
        new NonNullExample("test");
        // NullPointerException is thrown
        new NonNullExample(null); }}Copy the code

Non-null judgments are added to the constructor after compilation, as shown below.

public class NonNullExample {
    private String name;

    public NonNullExample(@NonNull String name) {
        if (name == null) {
            throw new NullPointerException("name is marked non-null but is null");
        } else {
            this.name = name; }}public static void main(String[] args) {
        new NonNullExample("test");
        new NonNullExample((String)null); }}Copy the code

@Cleanup

When we use resources in Java, we inevitably need to close the resources after use. Use the @cleanup annotation to automatically close the resource.

/** * Created by macro on 2020/12/16. */
public class CleanupExample {
    public static void main(String[] args) throws IOException {
        String inStr = "Hello World!";
        // Use input and output streams to close automatically, without writing a try catch and calling the close() method
        @Cleanup ByteArrayInputStream in = new ByteArrayInputStream(inStr.getBytes("UTF-8"));
        @Cleanup ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        while (true) {
            int r = in.read(b);
            if (r == -1) break;
            out.write(b, 0, r);
        }
        String outStr = out.toString("UTF-8"); System.out.println(outStr); }}Copy the code