Anotasi (juga dikenal sebagai metadata) memberikan cara formal bagi kami untuk menambahkan informasi dalam kode kami, memungkinkan kami untuk menggunakan data ini dengan sangat nyaman di beberapa saat kemudian.
1. Sintaks dasar
Java SE5 memiliki tiga anotasi standar bawaan
@Override: Menunjukkan bahwa definisi metode saat ini akan menimpa metode dalam superclass. Jika Anda secara tidak sengaja mengeja ejaan yang salah, atau tanda tangan metode tidak cocok dengan metode yang ditimpa, kompiler akan mengeluarkan pesan kesalahan.
@Deprecated: Jika programmer menggunakan elemen beranotasi, kompiler akan mengeluarkan pesan peringatan
@SupperessWarnings: Tutup pesan peringatan kompiler yang tidak pantas.
Java Se5 memiliki empat anotasi meta bawaan
@Target: Menunjukkan di mana anotasi ini dapat digunakan. Parameter elementType yang mungkin meliputi:
1) Konstruktor: Pernyataan konstruktor
2) Bidang: Deklarasi Domain (termasuk instance enum)
3) Local_variable: Deklarasi Variabel Lokal
4) Metode: Pernyataan Metode
5) Paket: Pernyataan Paket
6) Parameter: Deklarasi Parameter
7) Ketik: Kelas, Antarmuka (termasuk Jenis Anotasi) atau Deklarasi ENUM
@Retention: Menunjukkan pada tingkat apa untuk menyimpan informasi anotasi. Parameter retensi opsional meliputi:
1) Sumber: Anotasi akan dibuang oleh kompiler
2) Kelas: Anotasi tersedia di file kelas, tetapi akan dibuang oleh VM
3) Runtime: VM juga akan mempertahankan anotasi selama runtime, sehingga informasi anotasi dapat dibaca melalui mekanisme refleksi.
@Documented: Sertakan anotasi ini di javadoc
@InHerited: Izinkan subclass untuk mewarisi anotasi di kelas orang tua sebagian besar waktu, programmer terutama menentukan anotasi mereka sendiri dan menulis prosesor mereka sendiri untuk menanganinya.
Usecase.java
paket com; impor java.lang.annotation.elementType; impor java.lang.annotation.Retention; impor java.lang.annotation.RetentionPolicy; impor java.lang.annotation.target; @Target (elementType.method) // Gunakan untuk menentukan di mana anotasi Anda akan diterapkan, dan ini diterapkan sebagai metode // Gunakan untuk menentukan level mana anotasi tersedia, dalam kode sumber (kelas) atau runtime (runtime) @retention (retentionPolicy.runtime) publik @interface usecase {publik int int (); deskripsi string publik () default "tidak ada deskripsi"; } Passwordutils. Java Package com; Public Class Passwordutils {@Usecase (id = 47, description = "Kata sandi harus berisi setidaknya satu numerik") public boolean validatePassword () {return true; } @Usecase (id = 48) Public String encryptPassword (kata sandi string) {return kata sandi; } @Usecase (id = 49, description = "jong_cai") public void showame () {System.out.println ("jong_cai"); }}
2. Tulis prosesor anotasi
Jika tidak ada alat untuk membaca anotasi, anotasi tidak akan lebih berguna daripada anotasi. Dalam proses penggunaan anotasi, bagian penting adalah membuat dan menggunakan prosesor anotasi. Java SE5 memperluas API mekanisme refleksi untuk membantu pemrogram membangun alat tersebut. Pada saat yang sama, ini juga menyediakan alat eksternal yang cenderung membantu pemrogram menguraikan kode sumber Java dengan anotasi. Di bawah ini adalah prosesor anotasi yang sangat sederhana, yang akan kami gunakan untuk membaca kelas kata sandi dan menggunakan mekanisme refleksi untuk menemukan tag @usecase. Kami menyediakannya dengan satu set nilai ID, dan kemudian mencantumkan kasus penggunaan yang ditemukan dalam kata sandi, serta kasus penggunaan yang hilang.
Paket Usecasetracker.java; impor java.lang.reflect.method; impor java.util.arraylist; impor java.util.collections; impor java.util.list; kelas publik usecasetracker {public static void trackusecases (daftar <integer> daftar, kelas <?> cl) {for (metode m: cl.getDecLaredMethods ()) {usecase us = m.getannotation (usecase.class); if (us! = null) {System.out.println ("Temukan Kasus Gunakan:" + us.id () + "" + us.description ()); list.remove (bilangan bulat baru (us.id ())); }} untuk (int i: list) {System.out.println ("Peringatan: Hilang Use case-" + i); }} public static void main (string [] args) {list <integer> list = new ArrayList <Integer> (); Collections.addall (daftar, 47,48,49,50,51); TrackUsecases (Daftar, Passwordutils.class); }}
Program ini menggunakan dua metode refleksi: getDeclaredMethods () dan getAnnotation (). Keduanya termasuk dalam AnnotatedElement Interface (kelas, metode dan bidang dan kelas lainnya mengimplementasikan antarmuka ini). Metode getannotation () mengembalikan objek anotasi dari jenis yang ditentukan, yang merupakan usecase. Jika metode beranotasi tidak memiliki anotasi jenis, ia mengembalikan nilai nol. Kemudian kami mengekstrak nilai elemen dari objek Usecase yang dikembalikan dengan memanggil metode ID () dan deskripsi (). Metode encryptPassWord () tidak menentukan nilai deskripsi saat anotasi, jadi ketika prosesor memproses anotasi yang sesuai, nilai default metode deskripsi () diperoleh dengan metode deskripsi ().
Anotasi menyebar di dunia Jawa. Jika Anda punya waktu, tulis artikel anotasi sederhana ini. Ini adalah pengantar anotasi. Saya harap Anda bisa melempar batu bata dan belajar bersama ...
Jika Anda berhenti berbicara omong kosong, latihan adalah intinya.
3. Contoh
Mari kita bicara tentang konsep anotasi terlebih dahulu, dan kemudian berbicara tentang bagaimana merancang anotasi Anda sendiri.
Pertama, dalam paket java.lang.annotation yang dilengkapi dengan JDK, buka file sumber berikut:
Sumber File Target.java
@Documented @retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface target {elementType [] value (); @Documented @retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface target {elementType [] value (); }
@Interface adalah kata kunci. Saat merancang anotasi, jenis harus didefinisikan sebagai @Interface, dan Anda tidak dapat menggunakan kata kunci kelas atau antarmuka (menurut Anda Sun agak pelit, tetapi terlihat sangat mirip dengan antarmuka).
Sumber File Retention.java
@Documented @retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface retention {retentionPolicy value (); } @Documented @retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface retention {retentionPolicy value (); }
Setelah melihat ini, Anda mungkin tidak jelas dan tidak tahu apa yang Anda bicarakan. Jangan khawatir, lihatlah. File -file di atas menggunakan dua bidang retensipolicy dan elementType, dan Anda mungkin menebak bahwa ini adalah dua file java. Memang, kode sumber dari kedua file ini adalah sebagai berikut:
Sumber File RetentionPolicy.java
Retensi Public EnumPolicy {Source, Class, Runtime} Public Enum RetentionPolicy {Source, Class, Runtime} Ini adalah tipe enum, dengan tiga nilai, yaitu sumber, kelas dan runtime.
Sumber berarti bahwa informasi jenis anotasi hanya akan disimpan dalam kode sumber program. Jika kode sumber dikompilasi, data anotasi akan hilang dan tidak akan disimpan dalam file .class yang dikompilasi.
Kelas berarti bahwa informasi jenis anotasi disimpan dalam kode sumber program, dan juga akan disimpan dalam file .class yang dikompilasi. Saat mengeksekusi, informasi ini tidak akan dimuat ke mesin virtual (JVM). Perhatikan bahwa ketika Anda tidak menetapkan nilai retensi dari jenis anotasi, nilai default sistem adalah kelas.
Yang ketiga adalah runtime, yang berarti bahwa informasi disimpan dalam kode sumber dan menyusun file .class, dan informasi ini akan dimuat ke dalam JVM selama eksekusi.
Misalnya, jika retensi di @Override diatur ke sumber, jika kompilasi berhasil, Anda tidak memerlukan informasi yang diperiksa ini; Sebaliknya, retensi dalam @Deprecated diatur ke runtime, yang berarti bahwa selain memperingatkan kami metode mana yang digunakan selama kompilasi, Anda juga dapat memeriksa apakah metode tersebut sudah tidak digunakan lagi saat mengeksekusi.
Sumber File ElementType.java
Publik enum elementType {type, bidang, metode, parameter, konstruktor, local_variable, annotation_type, package} public enum elementType {type, bidang, metode, parameter, konstruktor, local_variable, annotation_type, paket} ＠Type element dalam target digunakan untuk menentukan jenis anotasi elemen yang dapat digunakan. Mari kita jelaskan: ketik (ketik), bidang (atribut), metode (metode), parameter (parameter), konstruktor (konstruktor), local_variable (variabel lokal), annotation_type, paket (paket), di mana tipe (tipe) mengacu padanya digunakan pada kelas, antarmuka, enum dan jenis anotasi.
Selain itu, dapat dilihat dari kode sumber 1 bahwa @target sendiri juga menggunakan dirinya untuk menyatakan dirinya sendiri, dan hanya dapat digunakan pada annotation_type.
Jika jenis anotasi tidak menentukan elemen mana @target yang digunakan, itu dapat digunakan pada elemen apa pun, dan elemen di sini mengacu pada delapan jenis di atas.
Izinkan saya memberi Anda beberapa contoh yang benar:
@Target (elementType.method)
@Target (value = elementType.method)
@Target (elementType.method, elementType.constructor)
Silakan merujuk ke dokumentasi Javadoc untuk detailnya
Semua file sumber menggunakan @Documented. Tujuan @Documented adalah untuk mengaktifkan informasi jenis anotasi ini untuk ditampilkan pada dokumen deskripsi Javaapi; Jika tidak ditambahkan, informasi yang dihasilkan oleh jenis ini tidak akan ditemukan saat menggunakan Javadoc untuk menghasilkan dokumen API.
Poin lain adalah bahwa jika Anda perlu mewarisi data anotasi ke subclass, Anda akan menggunakan anotasi tipe @inHerited.
Berikut ini adalah contoh anotasi paling sederhana untuk desain, yang terdiri dari empat file;
Deskripsi.java
paket lebih ringan.javaeye.com; impor java.lang.annotation.Documented; impor java.lang.annotation.elementType; impor java.lang.annotation.Retention; impor java.lang.annotation.RetentionPolicy; impor java.lang.annotation.target; @Target (elementType.type) @retention (retentionPolicy.runtime) @Documented public @interface Deskripsi {string value (); } paket lebih ringan.javaeye.com; impor java.lang.annotation.Documented; impor java.lang.annotation.elementType; impor java.lang.annotation.Retention; impor java.lang.annotation.RetentionPolicy; impor java.lang.annotation.target; @Target (elementType.type) @retention (retentionPolicy.runtime) @Documented public @interface Deskripsi {string value (); }
Catatan: Semua anotasi akan secara otomatis mewarisi antarmuka java.lang.annotation, sehingga Anda tidak dapat mewarisi kelas atau antarmuka lain.
Poin yang paling penting adalah cara mengatur parameter dalam jenis anotasi:
Pertama, Anda hanya dapat menggunakan hak akses publik atau default untuk memodifikasinya. Misalnya, nilai string (); Di sini atur metode default metode ke default.
Kedua, anggota parameter hanya dapat menggunakan delapan tipe data dasar: byte, short, char, int, long, float, double, boolean, dan tipe data seperti string, enum, kelas, anotasi, serta array jenis ini. Misalnya, nilai string (); Anggota parameter di sini adalah string.
Ketiga, jika hanya ada satu anggota parameter, yang terbaik adalah mengatur nama parameter ke "nilai" dan menambahkan kurung sesudahnya. Contoh: Contoh di atas hanya memiliki satu anggota parameter.
Name.java
paket lebih ringan.javaeye.com; impor java.lang.annotation.Documented; impor java.lang.annotation.elementType; impor java.lang.annotation.Retention; impor java.lang.annotation.RetentionPolicy; impor java.lang.annotation.target; // Perhatikan bahwa @Target di sini berbeda dari @description, dan anggota parameter juga berbeda @Target (elementType.method) @Retention (retentionPolicy.runtime) @documented public @interface nama {string originate (); String community (); } paket lebih ringan.javaeye.com; impor java.lang.annotation.Documented; impor java.lang.annotation.elementType; impor java.lang.annotation.Retention; impor java.lang.annotation.RetentionPolicy; impor java.lang.annotation.target; // Perhatikan bahwa @Target di sini berbeda dari @description, dan anggota parameter juga berbeda @Target (elementType.method) @Retention (retentionPolicy.runtime) @documented public @interface nama {string originate (); String community (); }
Javaeyer.java
paket lebih ringan.javaeye.com; @Description ("JavaEye, Jadilah Komunitas Pertukaran Pengembangan Perangkat Lunak Terbaik") Kelas Publik Javaeyer {@name (originate = "Founder: Robbin", community = "javaeye") public string getName () {return null; } @Name (originate = "Founder: Jiangnan Baiyi", Community = "Springside") Public String getName2 () {return "Pinjam dua id id, tolong maafkan saya karena menulis contoh ini!"; }} paket lebih ringan.javaeye.com; @Description ("JavaEye, Jadilah Komunitas Pertukaran Pengembangan Perangkat Lunak Terbaik") Kelas Publik Javaeyer {@name (originate = "Founder: Robbin", community = "javaeye") public string getName () {return null; } @Name (originate = "Founder: Jiangnan Baiyi", Community = "Springside") Public String getName2 () {return "Pinjam dua id id, tolong maafkan saya karena menulis contoh ini!"; }}Tulis kelas testanotasi yang dapat menjalankan informasi ekstrak javaeyer
paket lebih ringan.javaeye.com; impor java.lang.reflect.method; impor java.util.hashset; impor java.util.set; TestAnnotation kelas publik { / *** Penulis lebih ringan* Catatan: Untuk detailnya, silakan merujuk ke dokumentasi Javadoc untuk penggunaan API anotasi* / public static void main (string [] args) melempar pengecualian {string class_name = "lighter.javaeye.com.javaeyer"; Class test = class.forname (class_name); Metode [] Method = test.getMethods (); bendera boolean = test.isannotationPresent (description.class); if (flag) {description des = (description) test.getAnnotation (description.class); System.out.println ("Deskripsi:"+des.value ()); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Hashset <at Method> (); System.out.println (Komunitas yang Dibuat: "+Name.Community ()); Annotation API*/ public static void main (string [] args) melempar Exception {string class_name = "ligher.javaeye.com.javaeyer"; Class test = class.forname (class_name); Metode [] Method = test.getMethods (); bendera boolean = test.isannotationPresent (description.class); if (flag) {description des = (description) test.getAnnotation (description.class); System.out.println ("Deskripsi:"+des.value ()); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Boolean OtherFlag = Metode [i] .IsAnnotationPresent (Name.Class); Hasil Menjalankan:
Deskripsi: Javaeye, Pendiri Pengembangan Perangkat Lunak Terbaik Pendiri: Robbin Ciptakan Komunitas: Javaeye Pendiri: Javaeye Ciptakan Komunitas: Springside