Vytvorenie vlastnej anotácie v prostredí Java

1. Úvod

Anotácie jazyka Java sú mechanizmom na pridanie informácií o metadátach do nášho zdrojového kódu. Sú silnou súčasťou Javy a boli pridané do JDK5. Anotácie ponúkajú alternatívu k použitiu deskriptorov XML a značkovacích rozhraní.

Aj keď ich môžeme pripojiť k balíkom, triedam, rozhraniam, metódam a poliam, samotné anotácie nemajú žiadny vplyv na vykonávanie programu.

V tejto príručke sa zameriame na to, ako vytvárať vlastné anotácie a ako ich spracovávať. Viac sa o anotáciách dočítame v našom článku o základných anotáciách.

2. Vytváranie vlastných anotácií

Vytvoríme tri vlastné anotácie s cieľom serializácie objektu do reťazca JSON.

Prvý použijeme na úrovni triedy, aby sme kompilátoru naznačili, že náš objekt je možné serializovať. Ďalej použijeme druhú na polia, ktoré chceme zahrnúť do reťazca JSON.

Na záver použijeme tretiu anotáciu na úrovni metódy, aby sme určili metódu, ktorú použijeme na inicializáciu nášho objektu.

2.1. Príklad anotácie na úrovni triedy

Prvým krokom k vytvoreniu vlastnej anotácie je deklarovať to pomocou @rozhranie kľúčové slovo:

public @interface JsonSerializable {}

Ďalším krokom je pridajte meta-anotácie, aby ste určili rozsah a cieľ našej vlastnej anotácie:

@Retention (RetentionPolicy.RUNTIME) @Target (ElementType.Type) public @interface JsonSerializable {}

Ako vidíme, naša prvá anotácia má runtime viditeľnosť a môžeme ho aplikovať na typy (triedy). Navyše nemá žiadne metódy, a slúži tak ako jednoduchý marker na označenie tried, ktoré je možné serializovať do formátu JSON.

2.2. Príklad anotácie na úrovni poľa

Rovnakým spôsobom vytvoríme našu druhú anotáciu, aby sme označili polia, ktoré zahrnieme do vygenerovaného JSON:

@Retention (RetentionPolicy.RUNTIME) @Target (ElementType.FIELD) public @interface JsonElement {public String key () default ""; }

Anotácia deklaruje ako predvolenú hodnotu jeden reťazcový parameter s názvom „kľúč“ a prázdnym reťazcom.

Pri vytváraní vlastných anotácií pomocou metód by sme si mali uvedomiť, že tieto metódy nesmú mať žiadne parametre a nemôžu spôsobiť výnimku. Tiež návratové typy sú obmedzené na primitívne funkcie, reťazec, trieda, výčty, anotácie a polia týchto typov,a predvolená hodnota nemôže byť nulová.

2.3. Príklad anotácie na úrovni metódy

Poďme si predstaviť, že pred serializáciou objektu na reťazec JSON chceme vykonať nejakú metódu na inicializáciu objektu. Z tohto dôvodu vytvoríme anotáciu na označenie tejto metódy:

@Retention (RetentionPolicy.RUNTIME) @Target (ElementType.METHOD) public @interface Init {}

Deklarovali sme verejnú anotáciu s viditeľnosťou za behu, ktorú môžeme použiť na metódy našich tried.

2.4. Aplikácia anotácií

Teraz sa pozrime, ako môžeme použiť naše vlastné anotácie. Predstavme si napríklad, že máme objekt typu Osoba že chceme serializovať do reťazca JSON. Tento typ má metódu, ktorá slúži na začiatočné písmeno prvého mena a priezviska. Pred serializáciou objektu budeme chcieť túto metódu zavolať:

@JsonSerializable verejná trieda Osoba {@JsonElement private String firstName; @JsonElement private String priezvisko; @JsonElement (key = "personAge") private Vek reťazca; súkromná adresa reťazca; @Init private void initNames () {this.firstName = this.firstName.substring (0, 1) .toUpperCase () + this.firstName.substring (1); this.lastName = this.lastName.substring (0, 1) .toUpperCase () + this.lastName.substring (1); } // Štandardní zakladatelia a zakladatelia}

Použitím našich vlastných anotácií naznačujeme, že môžeme serializovať a Osoba namietajte proti reťazcu JSON. Výstup by mal navyše obsahovať iba znak krstné meno, priezviskoa Vek polia daného objektu. Okrem toho chceme: initNames () metóda, ktorá sa má zavolať pred serializáciou.

Nastavením kľúč parameter parametra @JsonElement anotácia k „personAge“, naznačujeme, že tento názov použijeme ako identifikátor poľa vo výstupe JSON.

Kvôli demonštrácii sme urobili initNames () súkromné, takže nemôžeme inicializovať náš objekt manuálnym volaním a naši konštruktéri ho tiež nepoužívajú.

3. Spracovanie anotácií

Doteraz sme videli, ako vytvárať vlastné anotácie a ako ich používať na zdobenie Osoba trieda. Teraz, uvidíme, ako ich využiť pomocou rozhrania Java Reflection API.

Prvým krokom bude skontrolovať, či je náš objekt nulový alebo nie, ako aj to, či jeho typ má @JsonSerializable anotácia alebo nie:

private void checkIfSerializable (Object object) {if (Objects.isNull (object)) {throw new JsonSerializationException ("The object to serialize is null"); } Trieda clazz = object.getClass (); if (! clazz.isAnnotationPresent (JsonSerializable.class)) {throw new JsonSerializationException ("The class" + clazz.getSimpleName () + "nie je anotovaný pre JsonSerializable"); }}

Potom hľadáme ľubovoľnú metódu s anotáciou @Init a vykonáme ju na inicializáciu polí nášho objektu:

private void initializeObject (Object object) throws Exception {Class clazz = object.getClass (); pre (Metóda metóda: clazz.getDeclaredMethods ()) {if (method.isAnnotationPresent (Init.class)) {method.setAccessible (true); method.invoke (objekt); }}}

Výzva metóda.setAccessible(pravda) umožňuje nám vykonávať súkromné ​​operácie initNames () metóda.

Po inicializácii iterujeme cez polia nášho objektu, načítame kľúč a hodnotu prvkov JSON a vložíme ich do mapy. Potom vytvoríme reťazec JSON z mapy:

private String getJsonString (Object object) throws Exception {Class clazz = object.getClass (); Mapa jsonElementsMap = new HashMap (); pre (Field field: clazz.getDeclaredFields ()) {field.setAccessible (true); if (field.isAnnotationPresent (JsonElement.class)) {jsonElementsMap.put (getKey (field), (String) field.get (object)); }} Reťazec jsonString = jsonElementsMap.entrySet () .stream () .map (entry -> "\" "+ entry.getKey () +" \ ": \" "+ entry.getValue () +" \ "") .collect (Collectors.joining (",")); return "{" + jsonString + "}"; }

Opäť sme použili lúka.setAccessible(true) pretože Osoba polia objektu sú súkromné.

Naša trieda serializátora JSON kombinuje všetky vyššie uvedené kroky:

public class ObjectToJsonConverter {public String convertToJson (Object object) throws JsonSerializationException {try {checkIfSerializable (object); initializeObject (objekt); návrat getJsonString (objekt); } catch (Výnimka e) {hodiť novú JsonSerializationException (e.getMessage ()); }}}

Nakoniec spustíme test jednotky, aby sme overili, že náš objekt bol serializovaný tak, ako je definované v našich vlastných anotáciách:

@Test public void givenObjectSerializedThenTrueReturned () hodí JsonSerializationException {Person person = new Person ("soufiane", "cheouati", "34"); Serializátor JsonSerializer = nový JsonSerializer (); Reťazec jsonString = serializer.serialize (osoba); assertEquals ("{\" personAge \ ": \" 34 \ ", \" meno \ ": \" Soufiane \ ", \" priezvisko \ ": \" Cheouati \ "}", jsonString); }

4. Záver

V tomto článku sme videli, ako vytvoriť rôzne typy vlastných anotácií. Potom sme diskutovali o tom, ako ich použiť na zdobenie našich predmetov. Nakoniec sme sa pozreli na to, ako ich spracovať pomocou Java Reflection API.

Celý kód je ako vždy k dispozícii na stránkach GitHub.


$config[zx-auto] not found$config[zx-overlay] not found