Ang pangunahing benepisyo ng mga anotasyon ay hindi nagmumula sa paggamit ng mga karaniwang nasa JDK na. Kasabay nito, bihirang kailanganing gumawa ng sarili mong anotasyon. Ngunit kung kami ay bubuo ng isang malaking sistema o gumagawa ng isang hiwalay na library, kung gayon sa antas ng arkitektura, ang pagpapatupad ng aming sariling anotasyon ay tiyak na magbubunga ng mga dibidendo.
Subukan nating gumawa ng anotasyon.
Upang gawin ito, lumikha ng isang file, ngunit sa halip na magsulat ng klase o interface , isulat ang @interface . Ito ang magiging file para sa aming anotasyon. Ang panloob na istraktura ng isang anotasyon ay katulad ng sa isang interface.
public @interface Sum {
int sum() default 0;
}Ipinapahiwatig ng @interface na ito ay isang anotasyon,
ang default ay nagsasabi na ang parameter ay magkakaroon ng isang partikular na default na halaga.
Ta-da! Gumawa kami ng anotasyon! Sa teoryang magagamit na natin ito, ngunit mas mabuti munang i-configure ito.
Kung walang configuration, ang aming anotasyon ay maaaring ilapat sa anumang bagay (sa mga klase, pamamaraan, katangian, atbp.), kaya hindi gaanong makatuwirang gamitin ito sa puntong ito. Bagama't mukhang kakaiba, ang aming anotasyon ay kailangang i-annotate kasama ng iba pang mga anotasyon!
Magsimula tayo sa @Target .
Ang @Target annotation (may kaugnayan mula noong Java 1.5) ay naghihigpit sa kakayahang maglapat ng anotasyon. Upang limitahan ang paggamit sa isang partikular na antas, kailangan naming magpasa ng argumento sa @Target na anotasyon upang isaad kung sa aling mga uri ito mailalapat. Narito ang ilan sa mga karaniwang ginagamit na uri:
| @Target(ElementType.PACKAGE) | para sa mga pakete |
| @Target(ElementType.TYPE) | para sa mga klase |
| @Target(ElementType.CONSTRUCTOR) | para sa mga konstruktor |
| @Target(ElementType.METHOD) | para sa mga pamamaraan |
| @Target(ElementType.FIELD) | para sa mga katangian (mga variable) sa isang klase |
| @Target(ElementType.PARAMATER) | para sa mga parameter ng pamamaraan |
| @Target(ElementType.LOCAL_VARIABLE) | para sa mga lokal na variable |
Kung kailangan mo ng anotasyon para sa ilang uri, maaari kang magpasa ng ilang argumento bilang array:
@Target({ ElementType.PARAMETER, ElementType.LOCAL_VARIABLE })Ang susunod na mahalagang bahagi ng configuration ay ang @Retention annotation.
Isinasaad ng anotasyong ito ang mga bahagi ng ikot ng buhay ng code kung saan magiging available ang aming anotasyon:
| RetentionPolicy.SOURCE | Ang mga anotasyon na minarkahan ng patakaran sa pagpapanatili ng SOURCE ay itinatapon sa oras ng pagtakbo. |
| RetentionPolicy.CLASS | Ang mga anotasyong minarkahan ng patakaran sa pagpapanatili ng CLASS ay isinulat sa .class na file, ngunit inaalis sa oras ng pagtakbo. |
| RetentionPolicy.RUNTIME | Ang mga anotasyong minarkahan ng patakaran sa pagpapanatili ng RUNTIME ay nananatili sa oras ng pagtakbo at maaaring ma-access sa aming programa sa oras ng pagtakbo. |
May ilan pang anotasyon na magagamit mo para sa pagsasaayos:
| Anotasyon | Halaga |
|---|---|
| @Minana | Isinasaad na ang isang nagmula na klase ay nagmamana ng pagpapatupad ng isang parent na klase ng anotasyon. |
| @Nakadokumento | Isinasaad nito na ang anotasyon ay isasama sa nabuong dokumentasyon ng Javadoc. |
Ngayon subukan nating lumikha ng sarili nating anotasyon.
Gagawa kami ng anotasyon na para sa mga klase at pamamaraan at naglalaman ng impormasyon tungkol sa may-akda at bersyon ng code:
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Info {
String author() default "Author";
String version() default "0.0";
}Maaari naming ilapat ang aming anotasyon sa mga pamamaraan at klase. Magiging available ang metadata ng aming anotasyon sa oras ng pagtakbo. Bigyang-pansin ang mga parameter ng aming anotasyon: Maaari kaming magbigay ng dalawang argumento (may-akda at bersyon), o maaari naming alisin ang mga ito. Kung aalisin namin ang mga ito, gagamitin ang mga tinukoy na default na halaga ( default "May-akda" at default "0.0" ).
Kapansin-pansin na hindi namin kailangang tumukoy ng default na halaga para sa mga parameter. Sa kasong ito, ang parameter ay nagiging sapilitan.
Kapag nagpapasa ng mga argumento, dapat nating tukuyin ang kaukulang parameter gamit ang notation value = "value" . Ang parameter ay dapat palaging pinangalanan nang tahasan, kahit na ang anotasyon ay may isang parameter.
Ilapat natin ang ating anotasyon sa ilang klase:
@Info
public class MyClass1 {
@Info
public void myClassMethod() {}
}
@Info(version = "2.0")
public class MyClass2 {
@Info(author = "Anonymous")
public void myClassMethod() {}
}
@Info(author = "Anonymous", version = "2.0")
public class MyClass3 {
@Info(author = "Anonymous", version = "4.0")
public void myClassMethod() {}
}