Mga anotasyon. Ikalawang bahagi. Lombok

Mga anotasyon. Unang bahagi, medyo boring Sa bahaging ito, nagpasya akong hawakan ang Lombok library bilang isang kilalang kinatawan ng Source annotation. Gamit ang mga anotasyon ng Runtime sa susunod na artikulo. Noong unang panahon mayroong isang java programmer, araw-araw ay sumusulat siya ng ordinaryong code, halimbawa ito:

package lombok;

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

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

    public Chelovek() {
    }

    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;

        Chelovek chelovek = (Chelovek) o;

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

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

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

Isa itong tipikal na klase na may 2 field lamang (ngunit kung minsan ay may higit sa 10-15 field). Oo, siyempre, ang lahat ng ito ay maaaring mabuo sa IDE, ngunit sumpain, ito ay tumatagal ng espasyo. Kung mayroong 15-20 na mga patlang, lahat ng mga ito ay nangangailangan ng mga getter, setter, constructor... Sa lahat ng ito, ang ilang iba pang mga pamamaraan na hindi nakikita ng mata ay madaling mawala. Paano ko matutulungan ang gayong programmer na magsulat nang mas mabilis at mas kaunti? Lombok. Diretso sa init, ang parehong klase ngunit gumagamit ng Lombok:

package lombok;

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

Oo, yun lang. Malamig? Ano ang gagawin ng @Data annotation ? Sa yugto ng compilation, bubuo ito ng mga getter/setters para sa lahat ng field, toString at muling tukuyin ang mga katumbas at hashCode ayon sa mga pamantayan. Maaari kang mag-install ng isang plugin sa IDE at makikita nito ang lahat ng mga pamamaraan na hindi pa nagagawa. Umaasa ako na ikaw, ang mambabasa, ay natagpuan na kawili-wili, dahil sa susunod ay magkakaroon ng maikling pagpapakilala at mga link sa mga detalye. Nagbibigay din ang Lombok ng pagkakataong i-customize ang henerasyon; hindi lahat ng getter, setter, o hashcode ay dapat na mabuo nang iba. Samakatuwid, may mga hiwalay na anotasyon (sa palagay ko marami sa kanila ang hindi nangangailangan ng paglalarawan) @Getter/@Setter @ToString @EqualsAndHashCode @NoArgsConstructor, @RequiredArgsConstructor at @AllArgsConstructor @Log Ito ang mga pinakakaraniwan, ang buong set ay maaaring tingnan dito var at val ay nararapat na espesyal na atensyon. Posibleng magsulat ng ganito:

package lombok;

import lombok.experimental.var;

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

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

Bakit kailangan ito? Halimbawa, mayroon kaming klase ng RandomAccessFileChannel. Well, bakit kailangan namin itong isulat nang ganito:

RandomAccessFileChannel channel = new RandomAccessFileChannel();

Kung maaari ay ganito:

var channel2 = new RandomAccessFileChannel();

Sa aking palagay, hindi ito palaging katanggap-tanggap. Halimbawa, mayroon kaming masamang pamamaraan na nagbabalik ng masamang mapa:

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

kung ganito ang tawag mo:

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

Ito ay higit pa o hindi gaanong malinaw kung ano ang ginagawa namin. Kung ang tawag ay ganito:

var listSetMap = evilMap();

kung gayon sino ang nakakaalam kung ano ang ibinabalik ng evilMap(), at hanggang sa tingnan mo ang mismong pamamaraan, hindi mo malalaman. Bakit mag-abala sa pamamagitan ng mga mapagkukunan? Sa pangkalahatan, kailangan mong maging mas maingat dito. Pang-eksperimentong thread: Dito nais kong tandaan ang mga anotasyon: @UtilityClass Lumilikha ito ng isang pribadong konstruktor at nagtatapon ng eksepsiyon doon (upang ang mga kamay na marumi mula sa pagmuni-muni ay hindi makapasok dito). At napakaganda sa simula ng klase sinasabi nito sa amin na mayroong mga pamamaraan ng utility. @Delegate Ipinapatupad ang pattern ng delegasyon. Kung mayroon kang klase na nagde-delegate ng isang bagay sa isa pang klase, habang gumagawa lang ng mga pagbabago sa ilang pamamaraan, ang anotasyong ito ay magliligtas sa iyo mula sa pagdodoble ng mga pamamaraan + susubaybayan ang mga ito. Kung aalisin o idinagdag ang isang paraan, mapapansin niya ito. Mga pang-eksperimentong anotasyon thread GITHUB Opisyal na website Upang gumana nang normal ang IDE sa lombok, at hindi i-highlight ang mga pamamaraan bilang wala, kailangan mong i-install ang plugin. Sa opisyal na website, mayroong isang seksyon ng pag-setup kung saan makikita mo kung paano ikonekta ang plugin para sa bawat IDE. Gaya ng nakikita mo, sikat ang Lombok. >5000 bituin at >1000 tinidor. Gumagamit si Spring ng lombok sa kanyang mga klase. Kung may spring ka sa project mo, hanapin mo, baka hinila pataas ang lombok, hindi mo lang alam.