คำอธิบายประกอบ ตอนที่ 2. ลอมบอก

คำอธิบายประกอบ ตอนที่ 1 — น่าเบื่อนิดหน่อย ในส่วนนี้ ฉันตัดสินใจพูดถึงไลบรารีลอมบอก เนื่องจากไลบรารีนี้เป็นตัวแทนที่รู้จักกันดีของคำอธิบายประกอบซอร์สโค้ด ฉันจะกล่าวถึงคำอธิบายประกอบรันไทม์ในบทความถัดไป กาลครั้งหนึ่งมีโปรแกรมเมอร์จาวาคนหนึ่ง ทุกๆ วันเธอเขียนโค้ดธรรมดาๆ เช่นนี้

package lombok;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

คลาสนี้เป็นคลาสธรรมดา — มีเพียง 2 ฟิลด์เท่านั้น (บางครั้งอาจมีมากกว่า 10-15 ฟิลด์) แน่นอนว่าทั้งหมดนี้สามารถสร้างได้ใน IDE แต่ให้ตายเถอะ มันเกิดขึ้นแล้ว หากมี 15-20 ฟิลด์ แต่ละฟิลด์จำเป็นต้องมี getters, setters, Constructor... ในบรรดาทั้งหมดนี้ มีวิธีการอื่นอีกสองสามวิธีที่มองไม่เห็นด้วยตาเปล่า อาจสูญหายได้ง่าย เราจะช่วยให้โปรแกรมเมอร์คนนี้เขียนเร็วขึ้นและน้อยลงได้อย่างไร? ลอมบอก ออกจากกระทะแล้วเข้ากองไฟไปพร้อมกับคุณ นี่คือคลาสเดียวกัน แต่ตอนนี้เราใช้ลอมบอก:

package lombok;

@Data
public class Person {
    private String name;
    private int age;
}

นั่นคือทั้งหมดที่ เจ๋งใช่มั้ย? คำอธิบาย ประกอบ@Dataทำหน้าที่อะไร ในระหว่างการคอมไพล์ คำอธิบายประกอบนี้จะสร้าง getters/setters สำหรับทุกฟิลด์ และแทนที่ toString(), เท่ากับ() และ hashCode() ตามกฎมาตรฐาน คุณสามารถติดตั้งปลั๊กอินใน IDE ได้ ก็จะเห็นวิธีการต่างๆ ที่ยังไม่ได้สร้าง ณ จุดนี้ ฉันหวังว่าคุณผู้อ่านของฉันจะสนใจ เพราะต่อไปนี้จะเป็นการแนะนำสั้นๆ พร้อมลิงก์ไปยังรายละเอียดต่างๆ ลอมบอกยังให้คุณปรับแต่งการสร้างโค้ดได้ เช่น ไม่จำเป็นต้องใช้ getters และ setters ทั้งหมด หรือคุณอาจต้องใช้อัลกอริธึมอื่นเพื่อสร้างโค้ดแฮช เพื่อให้บรรลุเป้าหมายนี้ มีคำอธิบายประกอบแยกกัน (ฉันคิดว่าหลายคำอธิบายไม่ต้องการคำอธิบาย): @Getter/@Setter, @ToString, @EqualsAndHashCode, @NoArgsConstructor, @RequiredArgsConstructor และ @AllArgsConstructor, @Log สิ่งเหล่านี้คือคำอธิบายประกอบที่มากที่สุด ทั่วไป. สามารถดูชุดทั้งหมดได้ที่นี่ ให้ความสนใจเป็นพิเศษกับ var และ val ซึ่งหมายความว่าคุณสามารถเขียนโค้ดได้ดังนี้:

package lombok;

import lombok.experimental.var;

@Data
public class Person {
    private String name;
    private int age;

    public static void main(String[] args) {
        var person = new Person();
        person.setAge(22);
        System.out.println(person);
    }
}

เหตุใดจึงจำเป็น? ตัวอย่างเช่น เรามีคลาส RandomAccessFileChannel ทำไมเราถึงอยากเขียนโค้ดแบบนี้?

RandomAccessFileChannel channel = new RandomAccessFileChannel();

ถ้าเราสามารถทำได้?

var channel2 = new RandomAccessFileChannel();

ในความคิดของฉัน สิ่งนี้ไม่เป็นที่ยอมรับเสมอไป ตัวอย่างเช่น เรามีวิธีการชั่วร้ายที่ส่งคืนแผนที่ชั่วร้าย:

public static Map<List<Set<Integer>>, Set<List<String>>> evilMap() {
    return new HashMap<>();
}

หากคุณเรียกสิ่งนี้ว่า:

Map<List<Set<Integer>>, Set<List<String>>> listSetMap = evilMap();

ถ้าอย่างนั้นก็ชัดเจนไม่มากก็น้อยว่าเรากำลังทำงานกับอะไร หากการโทรเป็นดังนี้:

var listSetMap = evilMap();

มีเพียงมารเท่านั้นที่รู้ว่า evilMap() จะกลับมาที่นั่น และคุณก็ไม่รู้จนกว่าคุณจะดูวิธีการนั้นเอง ทำไมต้องรันไฟล์ต้นฉบับ? โดยทั่วไปคุณต้องระวังสิ่งนี้ สาขาทดลอง: ที่นี่ฉันต้องการพูดถึงคำอธิบายประกอบ@UtilityClass มันสร้างคอนสตรัคเตอร์ส่วนตัวที่ส่งข้อยกเว้น (ดังนั้นมือเล็กๆ สกปรกอย่าใช้การสะท้อนเพื่อเข้าไปยุ่ง) และมันสวยงามมากในช่วงเริ่มต้นของชั้นเรียน — มันบอกเราว่ามีวิธีการที่เป็นประโยชน์มากมาย คำ อธิบายประกอบ @Delegateใช้รูปแบบการมอบหมาย สมมติว่าคุณมีคลาสที่มอบหมายบางสิ่งให้กับคลาสอื่น และคุณทำการเปลี่ยนแปลงกับวิธีการบางวิธีเท่านั้น คำอธิบายประกอบนี้จะช่วยให้คุณไม่ต้องทำซ้ำวิธีการต่างๆ และจะติดตามวิธีการเหล่านั้น หากคุณลบหรือเพิ่มวิธีการ คำอธิบายประกอบนี้จะสังเกตเห็น สาขาคำอธิบายประกอบเชิงทดลอง เว็บไซต์อย่างเป็นทางการของ GitHub เพื่อให้ IDE ทำงานได้อย่างถูกต้องกับลอมบอก และไม่เน้นวิธีการว่าไม่มีอยู่จริง คุณต้องติดตั้งปลั๊กอิน เว็บไซต์อย่างเป็นทางการมี ส่วน การตั้งค่า ที่คุณสามารถดูวิธีเชื่อมต่อปลั๊กอินสำหรับ IDE แต่ละตัวได้ อย่างที่คุณเห็น ลอมบอกเป็นที่นิยม: มากกว่า 5,000 ดาวและส้อมมากกว่า 1,000 อัน Spring ใช้ลอมบอกในชั้นเรียน หากคุณมี Spring อยู่ในโปรเจ็กต์ของคุณ ลองดูสิ — มันอาจจะดึงลอมบอกเข้ามาโดยที่คุณไม่รู้