Java Reflection: Čo to je, ako funguje a príklady použitia

Autor:  Jozef Wagner

Java • 21 min. čítania • 27. 8. 2025

Autor:  Jozef Wagner •

Java • 21 min. čítania • 27. 8. 2025

Java Reflection ti umožní nahliadnuť „pod kapotu“ aplikácií a pracovať s triedami, metódami či atribútmi priamo za behu programu. V článku sa pozrieme na to, ako reflexia v Jave funguje, prečo ju používať, kde sa s ňou stretneš v praxi a aké sú jej výhody a úskalia.

Predstav si, že stojíš pred zrkadlom, ktoré namiesto tvojho odrazu odhaľuje vnútorné tajomstvá všetkého, čo pred neho položíš. V prípade Java Reflection API je tým zrkadlom samotná Java. Umožňuje ti počas behu programu získať podrobné informácie o triedach, metódach, poliach aj konštruktoroch, a dokonca ich dynamicky meniť za behu programu, a to bez prístupu k zdrojovému kódu.

Java Reflection ti otvára dvere k k možnosti preskúmať štruktúru a správanie tvojej aplikácie, reagovať na nové situácie a upravovať jej časti v runtime. Či už chceš zjednodušiť testovanie, načítavať pluginy alebo lepšie pochopiť, ako fungujú knižnice, reflexia je neoceniteľný nástroj, ktorý odhaľuje to, čo je bežne skryté.

Čo je Java Reflection a prečo sa používa?

Java Reflection je funkcia, ktorá umožňuje skúmať a upravovať správanie aplikácií za behu. Dáva ti možnosť dynamicky pristupovať k metadátam tried, ich metódam, poliam, konštruktorom a pracovať s nimi, aj keď pri kompilácii nie sú známe.

Hlavným dôvodom použitia reflexie v Jave je potreba pružne reagovať na meniace sa požiadavky či konfigurácie bez nutnosti manuálne upravovať a rekompilovať kód. Typickým príkladom je dynamické načítanie a registrácia pluginov, kontrola anotácií v testoch alebo tvorba inštancií na základe názvu triedy zo súboru či používateľského vstupu.

Reflexia v Jave umožňuje aj automatické spracovanie anotácií, napríklad vyhľadanie a spustenie metód označených ako testy, či načítanie konfiguračných údajov do objektov. Využitie nachádza aj pri generovaní kódu, tvorbe frameworkov či pokročilom ladení.

Kde sa využíva Java Reflection?

Reflexia je základným kameňom mnohých moderných Java frameworkov a nástrojov. Spomeniem niektoré príklady jej využitia:

• Vývojové frameworky (Spring, Hibernate): Používajú reflexiu na automatickú injekciu závislostí, prácu s anotáciami a mapovanie databázových entít na objekty.
• JUnit testovanie. Vyhľadáva testovacie metódy označené anotáciami a spúšťa ich automaticky bez potreby manuálneho zápisu.
• Serializácia a deserializácia (Jackson, Gson): Reflexia sa používa na čítanie a zápis hodnôt objektov pri konverzii z a do formátov ako JSON či XML, dokonca aj v prípade súkromných premenných.
• IDE a ladiace nástroje (IntelliJ IDEA, Eclipse): Tieto nástroje používajú reflexiu pri ladení na inšpekciu objektov, dynamické vyhodnocovanie výrazov či vizualizáciu stavu programu.
• Plugin systémy: V aplikáciách s modulárnou architektúrou slúži reflexia na dynamické načítanie a registráciu externých komponentov.

Výhody a nevýhody reflexie v Jave

Reflexia v Jave prináša celý rad výhod, ale aj rizík. Hoci otvára dvere k pokročilým technikám, zároveň so sebou nesie kompromisy v oblasti výkonu, bezpečnosti a čitateľnosti kódu.

Výhody reflexie

• Dynamická inšpekcia a manipulácia. Umožňuje získať informácie o triedach a objektoch za behu a podľa potreby s nimi pracovať.
• Flexibilita a rozšíriteľnosť. Kód môže pracovať s ľubovoľnými triedami bez toho, aby ich poznal v čase kompilácie. To je výhodné pre tvorbu generických knižníc či pluginov.
• Spracovanie anotácií a metadát. Frameworky môžu na základe anotácií meniť správanie aplikácie bez potreby dodatočnej konfigurácie.
• Podpora testovania a ladenia. Reflexia umožňuje dynamické spúšťanie testov a náhľad do objektov počas behu.
• Automatizácia serializácie. Knižnice vedia načítať a zapísať údaje bez potreby ručne implementovať konverziu.

Nevýhody reflexie

• Znížený výkon. Reflexívne operácie sú výrazne pomalšie než priame volania metód alebo prístupy k poliam.
• Typová nebezpečnosť. Obchádza sa kontrola typov vykonávaná kompilátorom, čo môže viesť k výnimkám za behu (napr. ClassCastException).
• Zložitosť a znížená čitateľnosť. Kód používajúci reflexiu môže byť menej prehľadný, ťažší na ladenie a udržiavanie.
• Bezpečnostné riziká. Možnosť manipulácie s privátnymi členmi triedy môže byť nebezpečná, ak sa používa neuvážene.
• Nekompatibilita s nástrojmi. Niektoré nástroje pre analýzu alebo refaktorovanie nemusia správne interpretovať reflexívny kód.

Reflection pre balíčky (packages)

Pri práci s reflexívnym API v Jave je prirodzené pýtať sa, či vieme získať informácie nielen o konkrétnych triedach, ale aj o balíčkoch, v ktorých sa tieto triedy nachádzajú. Aj keď reflexia pre balíčky nie je taká bohatá ako pre triedy či metódy, Java ponúka základné možnosti na získanie informácií o balíčkoch pomocou triedy java.lang.Package.

Trieda Package predstavuje runtime reprezentáciu balíčka. Pomocou nej môžeme zistiť názov balíčka, verziu, meno dodávateľa či ďalšie metadáta, ktoré sú definované v MANIFEST.MF súbore JAR archívu.

Získanie balíčka z triedy

Najjednoduchší spôsob, ako získať balíček, je cez triedu, ktorá doňho patrí:

V tomto úryvku zisťujeme názov balíčka, v ktorom sa nachádza trieda MyClass. Ak je trieda definovaná v predvolenom balíku (default, čiže v súbore bez package direktívy), výsledkom bude null.

Package p = MyClass.class.getPackage();
System.out.println(p.getName());

Získanie všetkých balíčkov

Je možné získať zoznam všetkých balíčkov, ktoré sú momentálne známe JVM. Slúži na to statická metóda Package.getPackages():

Tento kód ukáže všetky balíčky, ktoré JVM v danom okamihu pozná. Ide prevažne o tie, ktoré už boli načítané. Neobsahuje kompletný zoznam všetkých dostupných balíčkov v JAR súboroch alebo classpath.

Package[] packages = Package.getPackages();
for (Package p : packages) {
    System.out.println(p.getName());
}

Metadáta balíčka

Ak bol balíček súčasťou JAR súboru, ktorý obsahuje manifest s doplnkovými informáciami, môžeme získať údaje ako verzia alebo dodávateľ:

Tieto hodnoty sú často definované v nástrojoch ako Maven alebo Gradle počas balenia aplikácie. V bežných projektoch, ktoré nie sú distribuované ako JAR archívy, však môžu byť tieto hodnoty null.

Package p = SomeLibraryClass.class.getPackage();
System.out.println(p.getImplementationTitle());
System.out.println(p.getImplementationVersion());
System.out.println(p.getImplementationVendor());

Obmedzenia práce s balíčkami

Java Reflection pre balíčky má svoje limity. Neexistuje napríklad štandardný spôsob, ako zo samotného balíčka získať zoznam tried, ktoré sa v ňom nachádzajú. Dôvodom je, že balíček nie je kontajnerom tried v zmysle runtime reprezentácie.

Na získanie všetkých tried v balíčku je potrebné použiť externé knižnice (napr. Reflections, ClassGraph) alebo si napísať vlastný prehľadávač súborov.

Reflection pre konštruktory

Jednou z najsilnejších schopností Java Reflection API je možnosť pracovať s konštruktormi tried. Vďaka tomu dokážeš vytvárať nové inštancie objektov aj bez toho, že poznáš presné typy alebo máš k dispozícii verejný konštruktor. Trieda java.lang.reflect.Constructor ti umožňuje pristupovať ku všetkým konštruktorom danej triedy, zisťovať ich parametre, modifikátory, prípadne ich spúšťať.

Získanie konštruktorov

Ak chceš získať všetky verejné konštruktory triedy, použi metódu getConstructors(). Ak potrebuješ získať aj private alebo protected konštruktory (bez ohľadu na modifikátor prístupu), použi getDeclaredConstructors():

Constructor<?>[] publicConstructors = MyClass.class.getConstructors();
Constructor<?>[] allConstructors = MyClass.class.getDeclaredConstructors();

Vytvorenie novej inštancie pomocou konštruktora

Ak poznáš typy parametrov, môžeš získať konkrétny konštruktor a vytvoriť novú inštanciu triedy:

Constructor<MyClass> ctor = MyClass.class.getConstructor(String.class, int.class);
MyClass instance = ctor.newInstance("test", 82);

Ak je konštruktor súkromný (private), musíš najskôr povoliť jeho prístupnosť:

Constructor<MyClass> ctor = MyClass.class.getDeclaredConstructor();
ctor.setAccessible(true);
MyClass instance = ctor.newInstance();

Tento spôsob sa často používa v testovaní alebo pri práci s frameworkmi, kde je potrebné vytvárať objekty, ku ktorým by sme za bežných okolností nemali prístup.

Zisťovanie informácií o konštruktore

Trieda Constructor poskytuje viaceré metódy na získanie detailov o konštruktore, napríklad zoznam typov parametrov, typy výnimiek, ktoré môže vyhadzovať alebo modifikátory prístupu:

Class<?>[] paramTypes = ctor.getParameterTypes();
int modifiers = ctor.getModifiers();
boolean isPrivate = Modifier.isPrivate(modifiers);

Môžeš tak ľahko zistiť, či je konštruktor napríklad private, public alebo protected, čo sa môže hodiť napríklad pri generovaní dokumentácie alebo automatizovanom testovaní tried.

Možné riziká

Používanie reflexívneho vytvárania inštancií nie je bez rizika. Môže obísť bežné kontrolné mechanizmy, ktoré vývojár do triedy vložil, napríklad obmedzenie prístupu cez private konštruktory alebo rôzne validačné pravidlá. Navyše, ak sa pri vytváraní inštancie niečo pokazí (napríklad nesedia typy parametrov alebo sa vyhodí výnimka v konštruktore), výsledkom môže byť InvocationTargetException, ktorú treba správne ošetriť.

Java Reflection pre názvy tried a modifikátory

Reflection v Jave ti umožňuje nielen pracovať s konštruktormi či metódami, ale aj získavať základné informácie o samotných triedach. Medzi tie najdôležitejšie patria:

• názov triedy,
• jej úplná kvalifikácia (vrátane balíčka) a
• modifikátory prístupu.

Vďaka týmto údajom môžeš za behu analyzovať štruktúru aplikácie, overovať pravidlá dizajnu alebo automatizovať rôzne procesy ako dokumentovanie, mapovanie objektov či testovanie.

Získanie názvu triedy

Najjednoduchší spôsob, ako získať názov triedy, je použiť objekt typu Class, ktorý predstavuje runtime reprezentáciu danej triedy. Ak máš referenciu na triedu (napr. MyClass.class), môžeš použiť viacero metód podľa toho, aký formát názvu chceš:

// vracia plne kvalifikovaný názov, napr. com.example.MyClass
System.out.println(clazz.getName()); 
// vracia len názov triedy, napr. MyClass
System.out.println(clazz.getSimpleName());  
// podobné ako getName(), ale môže byť null pri anonymných triedach
System.out.println(clazz.getCanonicalName()); 

Tieto metódy sú užitočné napríklad pri logovaní, generovaní výstupov alebo pri výstavbe rôznych registrátorov tried.

Zistenie modifikátorov triedy

Každá trieda môže mať rôzne modifikátory, ako napríklad public, abstract, final, interface a tieto dokážeš jednoducho pomocou reflexie zistiť. Trieda Class poskytuje metódu getModifiers(), ktorá vracia celé číslo predstavujúce kombináciu modifikátorov. Na jeho rozpoznanie použi pomocnú triedu java.lang.reflect.Modifier:

int modifiers = clazz.getModifiers();
if (Modifier.isPublic(modifiers)) {
    System.out.println("Trieda je verejná.");
}
if (Modifier.isAbstract(modifiers)) {
    System.out.println("Trieda je abstraktná.");
}
if (Modifier.isFinal(modifiers)) {
    System.out.println("Trieda je finálna.");
}
if (Modifier.isInterface(modifiers)) {
    System.out.println("Ide o rozhranie.");
}

Tieto informácie môžu byť užitočné pri kontrole správneho návrhu tried, napríklad či implementácia rozhrania nie je zároveň final alebo či trieda, ktorú chceš rozšíriť, nie je náhodou abstract.

Práca s anonymnými a vnorenými triedami

Java Reflection ti umožňuje rozpoznať aj špeciálne typy tried, napríklad anonymné, vnorené alebo lokálne triedy. To sa hodí napríklad pri generovaní dokumentácie alebo pri špeciálnom spracovaní:

if (clazz.isAnonymousClass()) {
    System.out.println("Ide o anonymnú triedu.");
}
if (clazz.isMemberClass()) {
    System.out.println("Ide o vnorenú (členskú) triedu.");
}
if (clazz.isLocalClass()) {
    System.out.println("Ide o lokálnu triedu definovanú v rámci metódy.");
}

Tieto doplnkové informácie nie sú potrebné v bežnej aplikácii, no môžu byť dôležité pri vývoji frameworkov, testovacích nástrojov alebo v nástrojoch pre analýzu zdrojového kódu.

Java Reflection pre metódy

Jednou z najsilnejších a zároveň najčastejšie využívaných oblastí Java Reflection je práca s metódami. Pomocou triedy java.lang.reflect.Method môžeš dynamicky zisťovať, aké metódy trieda obsahuje, aké majú názvy, návratové typy, parametre, anotácie či modifikátory. A čo je ešte zaujímavejšie, tieto metódy dokážeš aj dynamicky spúšťať, aj keď sú napríklad súkromné alebo bežne neprístupné.

Získanie metód triedy

Na získanie metód môžeš použiť dve základné metódy triedy Class. Prvá vráti iba verejné metódy (vrátane zdedených), druhá všetky metódy definované v danej triede, bez ohľadu na ich viditeľnosť:

Method[] publicMethods = MyClass.class.getMethods();
Method[] allMethods = MyClass.class.getDeclaredMethods();

Ak teda chceš zoznam všetkých metód, ktoré trieda priamo definuje (vrátane private či package-private), použi getDeclaredMethods().

Získanie konkrétnej metódy

Ak chceš získať konkrétnu metódu podľa jej názvu a typov parametrov, môžeš použiť getMethod() alebo getDeclaredMethod():

Method method = MyClass.class.getMethod("sayHello", String.class);

Pri tejto metóde treba dávať pozor na správne typy parametrov. Ak signatúra metódy nesedí, vyhodí sa výnimka NoSuchMethodException.

Spustenie metódy pomocou reflexie

Najzaujímavejšia časť práce s metódami cez reflection je možnosť ich dynamicky spustiť. Použijeme na to metódu invoke():

Method method = MyClass.class.getMethod("sayHello", String.class);
Object instance = new MyClass();
Object result = method.invoke(instance, "Jano");

Metóda invoke() očakáva objekt, na ktorom sa má metóda spustiť a zoznam argumentov. Výsledok sa vracia ako Object, takže ho v prípade potreby môžeme pretypovať. Ak ide o statickú metódu, ako inštanciu môžeme odovzdať null.

Práca so súkromnými metódami

Ak je metóda označená ako private, nie je priamo prístupná. V takom prípade musíš najskôr povoliť prístup:

Method privateMethod = MyClass.class.getDeclaredMethod("secretPrivateMethod");
privateMethod.setAccessible(true);
privateMethod.invoke(instance);

Toto obchádza bežné pravidlá prístupnosti a treba s tým zaobchádzať opatrne, najmä z hľadiska bezpečnosti a dizajnových zásad.

Zisťovanie podrobnosti o metóde

Trieda Method poskytuje množstvo užitočných metód, pomocou ktorých môžeš zistiť rôzne vlastnosti metódy:

String name = method.getName();
Class<?> returnType = method.getReturnType();
Class<?>[] paramTypes = method.getParameterTypes();
int modifiers = method.getModifiers();
boolean isStatic = Modifier.isStatic(modifiers);

Môžeš tak zistiť, či je metóda napríklad static, public, final a podľa toho upraviť správanie aplikácie. To je veľmi užitočné pri tvorbe knižníc alebo nástrojov, kto    ré musia byť generické a pracovať s rôznymi typmi objektov.

Java Reflection pre atribúty

Okrem práce s metódami ti Java Reflection API umožňuje aj dynamickú prácu s atribútmi tried, teda s premennými, ktoré trieda obsahuje. Pomocou triedy java.lang.reflect.Field môžeme zisťovať názvy, typy a modifikátory atribútov, pristupovať k ich hodnotám, a dokonca ich za behu meniť, aj keď sú deklarované ako private.

Práca s atribútmi je veľmi podobná práci s metódami, no vyžaduje o niečo viac opatrnosti, najmä kvôli riziku narušenia vnútorného stavu objektu.

Získanie atribútov triedy

Trieda Class ponúka dve základné metódy na získanie atribútov. Ak chceš získať iba verejné atribúty (aj zdedené), použi getFields(). Ak ťa zaujímajú všetky atribúty definované priamo v triede, vrátane súkromných, použi getDeclaredFields():

Field[] publicFields = MyClass.class.getFields();
Field[] allFields = MyClass.class.getDeclaredFields();

Tieto metódy ti umožnia prechádzať všetky premenné triedy a analyzovať ich názvy, typy či modifikátory.

Získanie konkrétneho atribútu

Ak poznáš názov atribútu, vieš si ho vyžiadať priamo:

Field field = MyClass.class.getDeclaredField("surname");

Rovnako ako pri metódach, getDeclaredField() ti umožní získať aj súkromný atribút. Ak atribút neexistuje, vyhodí sa NoSuchFieldException.

Čítanie hodnoty atribútu

Ak chceš prečítať hodnotu atribútu z konkrétneho objektu, použi metódu get():

Object instance = new MyClass();
Field field = MyClass.class.getDeclaredField("name");
field.setAccessible(true);
Object value = field.get(instance);
System.out.println("Hodnota atribútu: " + value);

Ak je atribút verejný, volanie setAccessible(true) nie je potrebné. Ak ide o súkromný (private) atribút, musíš prístup povoliť, podobne ako pri súkromných metódach.

Zmena hodnoty atribútu

Atribút môžeš nielen čítať, ale aj prepísať:

Field field = MyClass.class.getDeclaredField("age");
field.setAccessible(true);
field.set(instance, 18);

Týmto spôsobom môžeš meniť hodnoty súkromných atribútov objektu zvonku, čo môže byť užitočné napríklad pri testovaní, serializácii alebo migrácii dát. Zároveň je to však zásah do vnútorného stavu objektu, s ktorým treba zaobchádzať opatrne.

Zisťovanie vlastností atribútu

Trieda Field umožňuje zistiť názov atribútu, jeho dátový typ, modifikátory a ďalšie informácie:

String fieldName = field.getName();
Class<?> type = field.getType();
int modifiers = field.getModifiers();
if (Modifier.isPrivate(modifiers)) {
    System.out.println("Atribút je súkromný.");
}

Tieto údaje môžeš využiť pri generovaní dokumentácie, mapovaní objektov (napr. ORM nástroje) alebo dynamickej validácii vstupov.

Java Reflection pre nadradenú triedu (superclass)

V objektovo orientovanom programovaní je dedenie jedným zo základných pilierov. Triedy môžu dediť vlastnosti a správanie zo svojich nadradených tried (superclass), čím sa podporuje opätovné použitie kódu a flexibilita návrhu. Pomocou Java Reflection API dokážeš aj túto hierarchiu za behu skúmať a analyzovať, či už z dôvodu dynamickej inštancie alebo pre automatizované nástroje ako sú serializéry, ORM a testovacie frameworky.

Zistenie nadradenej triedy

Najjednoduchší spôsob, ako získať referenciu na nadradenú triedu, je cez metódu getSuperclass() triedy Class. Táto metóda vráti triedu, z ktorej aktuálna trieda priamo dedí.

Class<?> superClass = MySubClass.class.getSuperclass();
System.out.println("Nadradená trieda: " + superClass.getName());

Ak je daná trieda priamo odvodená od Object, tak getSuperclass() vráti java.lang.Object. Ak voláme túto metódu na samotnej triede Object, výsledok bude null, pretože Object je koreňovou triedou v Jave.

Príklad použitia v praxi

Predstav si, že píšeš nástroj, ktorý má automaticky spracovať údaje z rôznych tried, ale tieto triedy môžu dediť z nejakej spoločnej abstraktnej triedy. Pomocou reflexie si vieš overiť, či daná trieda naozaj dedí z očakávanej nadradenej triedy:

Class<?> superClass = clazz.getSuperclass();
if (superClass != null && superClass.equals(BaseEntity.class)) {
    System.out.println("Trieda " + clazz.getSimpleName() + " dedí z BaseEntity.");
}

Takýto postup sa často používa v knižniciach ako Hibernate alebo Spring, kde sa z nadradenej triedy dedí bežná funkcionalita (napríklad ID).

Rekurzívna analýza dedičnosti

Ak chceš analyzovať celú reťazec dedenia (nielen najbližšiu nadradenú triedu), môžeš použiť jednoduchý rekurzívny prístup:

Class<?> current = clazz;
while (current != null) {
    System.out.println("Trieda: " + current.getName());
    current = current.getSuperclass();
}

Takto si vieš spätne vypísať celú hierarchiu až po koreňovú triedu Object.

Java Reflection pre rozhrania (interfaces)

Rozhrania (interfaces) v Jave predstavujú zmluvu o tom, aké metódy má trieda implementovať. Pomocou Java Reflection API vieš zistiť, ktoré rozhrania konkrétna trieda implementuje, čo je užitočné najmä pri dynamickom analyzovaní typov, validáciách, generovaní kódu či pri návrhu knižníc a frameworkov, ktoré pracujú s typovou introspekciou.

Zistenie implementovaných rozhraní

Trieda Class poskytuje metódu getInterfaces(), ktorá vráti pole typu Class<?>[], teda všetky rozhrania, ktoré trieda priamo implementuje.

Class<?>[] interfaces = MyClass.class.getInterfaces();
for (Class<?> i : interfaces) {
    System.out.println("Implementované rozhranie: " + i.getName());
}

Treba si uvedomiť, že getInterfaces() vracia iba tie rozhrania, ktoré trieda implementuje priamo. Ak niektoré rozhrania implementuje jej nadradená trieda, tieto sa týmto spôsobom nezobrazia. V takom prípade treba analyzovať aj hierarchiu dedenia.

Príklad: kontrola rozhrania

Povedzme, že chceš zistiť, či trieda implementuje konkrétne rozhranie, napríklad Serializable:

boolean implementsSerializable = Serializable.class.isAssignableFrom(clazz);
if (implementsSerializable) {
    System.out.println(clazz.getSimpleName() + " implementuje Serializable.");
}

Táto technika je praktická pri generovaní XML, JSON serializácie alebo pri kontrole, či trieda vyhovuje určitej zmluve (napr. Comparable, Runnable, AutoCloseable aťď).

Viacnásobná implementácia

Na rozdiel od tried môžu byť rozhrania implementované viaceré naraz. Reflection ti umožní tieto implementácie po jednom analyzovať a napríklad generovať dokumentáciu alebo ich automaticky registrovať do nejakej služby.

if (List.class.isAssignableFrom(clazz)) {
    System.out.println("Trieda " + clazz.getSimpleName() + " je zoznam (List).");
}

Týmto spôsobom vieš za behu identifikovať správanie objektov a pracovať s nimi dynamicky, napríklad pri dependency injection, plugin systémoch alebo testovacích nástrojoch.

Java reflection pre anotácie

Anotácie v Jave slúžia ako špeciálne značky, ktorými môžeme triedy, metódy, atribúty či konštruktory obohatiť o dodatočné informácie. Často sa používajú ako metadáta pre frameworky (napr. Spring, JUnit), generátory kódu alebo validátory. Pomocou Java Reflection API vieš tieto anotácie získať, čítať ich hodnoty a za behu programu rozhodovať sa na základe nich.

Zistenie, či je prítomná anotácia

Ak chceš zistiť, či daný prvok obsahuje určitú anotáciu, môžeš to urobiť napríklad takto:

boolean isAnnotated = MyClass.class.isAnnotationPresent(MyAnnotation.class);

Metóda isAnnotationPresent sa dá použiť na triedy, metódy, atribúty aj konštruktory. Výsledok ti povie, či je daný prvok anotovaný konkrétnou anotáciou.

Získanie samotnej anotácie

Ak chceš získať inštanciu anotácie a prečítať si jej vlastnosti, použi metódu getAnnotation():

MyAnnotation annotation = MyClass.class.getAnnotation(MyAnnotation.class);
String value = annotation.value();

Toto sa často používa, ak anotácia obsahuje nejaké parametre, ktoré určujú správanie aplikácie, napríklad názvy tabuliek, validačné pravidlá či URI cesty v REST API.

Všetky anotácie

Ak ťa zaujímajú všetky anotácie prítomné na danom prvku, môžeš použiť metódu getAnnotations():

Annotation[] annotations = method.getAnnotations();
for (Annotation a : annotations) {
    System.out.println("Metóda má anotáciu: " + a.annotationType().getSimpleName());
}

Týmto spôsobom sa vieš dostať k ľubovoľnej množine metadát, ktorými je prvok označený a dynamicky sa rozhodovať, čo s nimi urobiť.

Príklad: vlastná anotácia

Povedzme, že máš vlastnú anotáciu @LogExecution:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecution {
    String level() default "INFO";
}

A takúto triedu:

public class MyClass {
    @LogExecution(level = "DEBUG")
    public void debugMethod() {}

    @LogExecution
    public void defaultLevelMethod() {}

    public void regularMethod() {}
}

A chceš zistiť, ktoré metódy v triede túto anotáciu používajú:

for (Method method : MyClass.class.getDeclaredMethods()) {
    if (method.isAnnotationPresent(LogExecution.class)) {
        LogExecution log = method.getAnnotation(LogExecution.class);
        System.out.println("Metóda " + method.getName() + " má level: " + log.level());
    }
}

Všimni si, že anotácia musí byť označená @Retention(RetentionPolicy.RUNTIME), inak nie je za behu dostupná cez Reflection.

Jeden veľmi bežný prípad použitia anotácií v Jave je pri JUnit-testovaní. Napríklad JUnit 4 použije reflexiu na prehľadanie tvojich tried a nájdenie metód označených anotáciou @Test a potom ich pri spustení jednotkového testu zavolá.

Zdieľaj článok

Java Reflection: Čo to je, ako funguje a príklady použitia

O autorovi

Jozef Wagner

Java Developer Senior

Viac ako 10 rokov programujem v Jave, momentálne pracujem v msg life Slovakia ako Java programátor senior a pomáham zákazníkom implementovať ich požiadavky do poistného softvéru Life Factory. Vo voľnom čase si rád oddýchnem v lese, prípadne si zahrám nejakú dobrú počítačovú hru.