Bagaimana dan di mana Anotasi digunakan di Jawa?

Apa area utama yang dapat kita gunakan Anotasi? Apakah fitur pengganti untuk konfigurasi berbasis XML?

Anotasi adalah objek meta-meta yang dapat digunakan untuk menggambarkan objek meta lainnya . Meta-objek adalah kelas, bidang, dan metode. Meminta objek untuk objek meta (mis anObj.getClass()) disebut introspeksi . Introspeksi dapat melangkah lebih jauh dan kita dapat menanyakan objek-meta apa penjelasannya (misalnya aClass.getAnnotations). Introspeksi dan anotasi adalah milik apa yang disebut refleksi dan meta-pemrograman .

Anotasi perlu ditafsirkan dengan satu atau lain cara agar bermanfaat. Anotasi dapat diartikan pada saat pengembangan oleh IDE atau kompiler, atau saat dijalankan oleh suatu kerangka kerja.

Pemrosesan anotasi adalah mekanisme yang sangat kuat dan dapat digunakan dalam banyak cara berbeda:

• untuk menggambarkan kendala atau penggunaan elemen: misalnya @Deprecated, @Override, atau@NotNull
• untuk menggambarkan "sifat" suatu elemen, misalnya @Entity, @TestCase, @WebService
• untuk menggambarkan perilaku elemen: @Statefull, @Transaction
• untuk menjelaskan cara memproses elemen: @Column, @XmlElement

Dalam semua kasus, anotasi digunakan untuk menggambarkan elemen dan memperjelas artinya .

Sebelum JDK5, informasi yang sekarang diungkapkan dengan anotasi perlu disimpan di tempat lain, dan file XML sering digunakan. Tetapi lebih nyaman menggunakan anotasi karena mereka akan menjadi milik kode Java itu sendiri, dan karenanya lebih mudah untuk dimanipulasi daripada XML.

Penggunaan anotasi:

• Dokumentasi, misalnya XDoclet
• Kompilasi
• IDE
• Kerangka pengujian, misalnya JUnit
• Kontainer IoC misalnya sebagai Spring
• Serialisasi, mis. XML
• Pemrograman berorientasi aspek (AOP), misalnya Pegas AOP
• Server aplikasi, mis. Wadah EJB, Layanan Web
• Object-relational mapping (ORM), misalnya Hibernate, JPA
• dan masih banyak lagi...

... lihat misalnya di proyek Lombok , yang menggunakan anotasi untuk menentukan cara membuat equalsatau hashCodemetode.

Ada beberapa aplikasi untuk anotasi Java. Pertama-tama, mereka dapat digunakan oleh kompiler (atau ekstensi kompiler). Pertimbangkan misalnya anotasi Timpa :

class Foo {

    @Override public boolean equals(Object other) {
        return ...;
    }
}

Yang ini sebenarnya dibangun di Java JDK. Compiler akan menandakan kesalahan, jika beberapa metode ditandai dengan itu, yang tidak menimpa metode yang diwarisi dari kelas dasar. Anotasi ini mungkin berguna untuk menghindari kesalahan umum, di mana Anda sebenarnya bermaksud untuk menimpa metode, tetapi gagal melakukannya, karena tanda tangan yang diberikan dalam metode Anda tidak cocok dengan tanda tangan dari metode yang ditimpa:

class Foo {

    @Override public boolean equals(Foo other) {  // Compiler signals an error for this one
        return ...;
    }
}

Pada JDK7, anotasi diizinkan pada jenis apa pun. Fitur ini sekarang dapat digunakan untuk anotasi kompiler seperti NotNull , seperti di:

public void processSomething(@NotNull String text) {
    ...
}

yang memungkinkan kompiler untuk memperingatkan Anda tentang penggunaan variabel dan nilai null yang tidak benar .

Aplikasi lain yang lebih maju untuk anotasi melibatkan proses refleksi dan anotasi saat run-time. Ini (saya pikir) apa yang ada dalam pikiran Anda ketika Anda berbicara tentang anotasi sebagai "pengganti untuk konfigurasi berbasis XML". Ini adalah jenis pemrosesan anotasi yang digunakan, misalnya, oleh berbagai kerangka kerja dan standar JCP (ketekunan, injeksi ketergantungan, sebut saja) untuk memberikan meta-data dan informasi konfigurasi yang diperlukan.

Anotasi adalah bentuk metadata (data tentang data) yang ditambahkan ke file sumber Java. Mereka sebagian besar digunakan oleh kerangka kerja untuk menyederhanakan integrasi kode klien. Beberapa contoh dunia nyata dari atas kepala saya:

• JUnit 4 - Anda menambahkan @Testanotasi ke setiap metode pengujian yang Anda inginkan untuk dijalankan oleh pelari JUnit. Ada juga anotasi tambahan yang harus dilakukan dengan mengatur pengujian (seperti @Beforedan @BeforeClass). Semua ini diproses oleh pelari JUnit, yang menjalankan tes sesuai. Anda bisa mengatakan itu adalah pengganti untuk konfigurasi XML, tetapi anotasi terkadang lebih kuat (mereka dapat menggunakan refleksi, misalnya) dan juga mereka lebih dekat dengan kode yang mereka rujuk ( @Testanotasi tepat sebelum metode pengujian, jadi tujuannya dari metode itu jelas - berfungsi sebagai dokumentasi juga). Konfigurasi XML di sisi lain bisa lebih kompleks dan dapat memasukkan lebih banyak data daripada penjelasan.

• Terracotta - menggunakan anotasi dan file konfigurasi XML. Sebagai contoh, @Rootanotasi memberitahukan runtime Terracotta bahwa bidang yang dianotasi adalah root dan memorinya harus dibagi antara instance VM. File konfigurasi XML digunakan untuk mengkonfigurasi server dan memberi tahu kelas mana yang akan diinstrumentasi.

• Google Guice - contohnya adalah @Injectanotasi, yang bila diterapkan pada konstruktor membuat Guice runtime mencari nilai untuk setiap parameter, berdasarkan pada injector yang ditentukan. The @Injectanotasi akan cukup sulit untuk meniru menggunakan file konfigurasi XML, dan kedekatannya dengan konstruktor itu referensi untuk cukup berguna (bayangkan harus mencari ke file XML besar untuk menemukan semua suntikan ketergantungan Anda telah mengatur).

Semoga saya telah memberi Anda rasa bagaimana anotasi digunakan dalam kerangka kerja yang berbeda.

Anotasi di Jawa, menyediakan sarana untuk menggambarkan kelas, bidang, dan metode. Pada dasarnya, mereka adalah bentuk metadata yang ditambahkan ke file sumber Java, mereka tidak dapat mempengaruhi semantik program secara langsung. Namun, anotasi dapat dibaca pada saat run-time menggunakan Refleksi & proses ini dikenal sebagai Introspeksi. Kemudian dapat digunakan untuk memodifikasi kelas, bidang, atau metode.

Fitur ini, sering dieksploitasi oleh Libraries & SDKs (hibernate, JUnit, Spring Framework) untuk menyederhanakan atau mengurangi jumlah kode yang akan dilakukan oleh seorang programmer kecuali jika bekerja untuk Perpustakaan atau SDK ini. Oleh karena itu, wajar untuk mengatakan Anotasi dan Refleksi bekerja bergandengan tangan di Jawa.

Kami juga dapat membatasi ketersediaan anotasi untuk waktu kompilasi atau runtime. Berikut adalah contoh sederhana tentang membuat anotasi khusus

Driver.java

package io.hamzeen;

import java.lang.annotation.Annotation;

public class Driver {

    public static void main(String[] args) {
        Class<TestAlpha> obj = TestAlpha.class;
        if (obj.isAnnotationPresent(IssueInfo.class)) {

            Annotation annotation = obj.getAnnotation(IssueInfo.class);
            IssueInfo testerInfo = (IssueInfo) annotation;

            System.out.printf("%nType: %s", testerInfo.type());
            System.out.printf("%nReporter: %s", testerInfo.reporter());
            System.out.printf("%nCreated On: %s%n%n",
                    testerInfo.created());
        }
    }
}

TestAlpha.java

package io.hamzeen;

import io.hamzeen.IssueInfo;
import io.hamzeen.IssueInfo.Type;

@IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.")
public class TestAlpha {

}

IssueInfo.java

package io.hamzeen;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Hamzeen. H.
 * @created 10/01/2015
 * 
 * IssueInfo annotation definition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IssueInfo {

    public enum Type {
        BUG, IMPROVEMENT, FEATURE
    }

    Type type() default Type.BUG;

    String reporter() default "Vimesh";

    String created() default "10/01/2015";
}

Apakah itu pengganti untuk konfigurasi berbasis XML?

Tidak sepenuhnya, tetapi konfigurasi yang berhubungan erat dengan struktur kode (seperti pemetaan JPA atau injeksi dependensi di Spring) sering kali dapat diganti dengan anotasi, dan kemudian biasanya jauh lebih sedikit bertele-tele, menjengkelkan dan menyakitkan. Hampir semua kerangka kerja terkenal telah membuat peralihan ini, meskipun konfigurasi XML lama biasanya tetap sebagai opsi.

Ada 2 tampilan anotasi

1. tampilan pengguna, sebagian besar waktu, anotasi bekerja seperti jalan pintas, menyelamatkan Anda beberapa goresan kunci, atau membuat program Anda lebih mudah dibaca

2. tampilan vendor, pandangan prosesor tentang anotasi lebih merupakan 'antarmuka' berbobot ringan, program Anda TIDAK menghadapi SESUATU tetapi tanpa secara eksplisit "mengimplementasikan" antarmuka tertentu (di sini alias anotasi)

misalnya di jpa Anda mendefinisikan sesuatu seperti

@Entity class Foo {...}

dari pada

class Foo implements Entity {...}

keduanya berbicara hal yang sama "Foo adalah kelas Entity"

Di mana Anotasi Dapat Digunakan

Anotasi dapat diterapkan ke deklarasi: deklarasi kelas, bidang, metode, dan elemen program lainnya. Ketika digunakan pada deklarasi, setiap anotasi sering muncul, berdasarkan konvensi, pada barisnya sendiri.

Pembaruan Java SE 8: anotasi juga dapat diterapkan untuk penggunaan tipe. Berikut ini beberapa contohnya:

• Ekspresi pembuatan instance kelas:

  baru @Interned MyObject ();

• Jenis cor:

  myString = (@NonNull String) str;

• mengimplementasikan klausa:

  class UnmodifiableList mengimplementasikan @Readonly List <@Readonly T> {...}

• Deklarasi pengecualian yang dilemparkan:

  membatalkan monitorTemperature () melempar @Critical TemperatureException {...}

Kerangka kerja seperti Hibernate sedang banyak konfigurasi / pemetaan diperlukan menggunakan Anotasi berat.

Lihatlah Anotasi Hibernasi

JPA (dari Java EE 5) adalah contoh luar biasa dari penggunaan anotasi (berlebih). Java EE 6 juga akan memperkenalkan anotasi di banyak area baru, seperti layanan web RESTful dan anotasi baru untuk masing-masing API Servlet lama yang baik.

Berikut ini beberapa sumber:

• Sun - Java Persistence API
• Tutorial Java EE 5 - JPA
• Memperkenalkan platform Java EE 6 (periksa ketiga halaman).

Bukan hanya konfigurasi spesifik yang akan / dapat diambil alih oleh anotasi, tetapi mereka juga dapat digunakan untuk mengontrol perilaku. Anda melihat ini bagus di contoh JAX-RS Java EE 6.

Ini berguna untuk membubuhi keterangan kelas Anda, baik di metode, kelas, atau tingkat bidang, sesuatu tentang kelas yang tidak cukup terkait dengan kelas.

Anda dapat memiliki anotasi Anda sendiri, yang digunakan untuk menandai kelas-kelas tertentu sebagai uji-pakai saja. Itu bisa saja untuk keperluan dokumentasi, atau Anda bisa menegakkannya dengan memfilternya selama kompilasi kandidat rilis produksi Anda.

Anda bisa menggunakan anotasi untuk menyimpan beberapa data meta, seperti dalam kerangka kerja plugin, misalnya, nama plugin.

Ini hanyalah alat lain, memiliki banyak tujuan.

Ini melampirkan informasi tambahan tentang kode dengan (a) pemeriksaan kompiler atau (b) analisis kode

**

• Berikut ini adalah anotasi Bawaan :: 2 jenis

**

Tipe 1) Anotasi yang diterapkan pada kode java:

@Override // gives error if signature is wrong while overriding.
Public boolean equals (Object Obj) 

@Deprecated // indicates the deprecated method
Public doSomething()....

@SuppressWarnings() // stops the warnings from printing while compiling.
SuppressWarnings({"unchecked","fallthrough"})

Tipe 2) Anotasi yang diterapkan pada anotasi lain:

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

**

• Anotasi Khusus ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations

UNTUK MEMAHAMI TRY DI BAWAH Tautan yang LEBIH BAIK: BERLIHAT DENGAN CONTOH

http://www.javabeat.net/2007/08/annotations-in-java-5-0/

Anotasi dapat digunakan sebagai alternatif untuk file konfigurasi eksternal, tetapi tidak dapat dianggap sebagai pengganti yang lengkap. Anda dapat menemukan banyak contoh di mana annotationi telah digunakan untuk mengganti file konfigurasi, seperti Hibernate, JPA, EJB 3 dan hampir semua teknologi yang termasuk dalam Java EE.

Lagi pula ini tidak selalu pilihan yang baik. Tujuan menggunakan file konfigurasi biasanya untuk memisahkan kode dari detail lingkungan tempat aplikasi berjalan. Dalam situasi seperti itu, dan sebagian besar ketika konfigurasi digunakan untuk memetakan aplikasi ke struktur sistem eksternal, anotasi bukan pengganti yang baik untuk file konfigurasi, karena mereka membawa Anda untuk memasukkan rincian sistem eksternal di dalam kode sumber aplikasi Anda. Di sini file eksternal dianggap sebagai pilihan terbaik, jika tidak, Anda harus memodifikasi kode sumber dan mengkompilasi ulang setiap kali Anda mengubah detail yang relevan di lingkungan eksekusi.

Anotasi jauh lebih cocok untuk menghias kode sumber dengan informasi tambahan yang menginstruksikan alat pemrosesan, baik pada waktu kompilasi dan pada saat runtime, untuk menangani kelas dan struktur kelas dengan cara khusus. @Overridedan JUnit@Test adalah contoh yang baik dari penggunaan seperti itu, sudah dijelaskan secara rinci dalam jawaban lain.

Pada akhirnya aturannya selalu sama: tetap di dalam sumber hal-hal yang berubah dengan sumber, dan tetap di luar sumber hal-hal yang berubah secara independen dari sumber.

Java EE 5 lebih menyukai penggunaan anotasi daripada konfigurasi XML. Misalnya, dalam EJB3 atribut transaksi pada metode EJB ditentukan menggunakan anotasi. Mereka bahkan menggunakan anotasi untuk menandai POJO sebagai EJBs dan untuk menentukan metode tertentu sebagai metode siklus hidup alih-alih mengharuskan implementasi antarmuka.

Tujuan dari anotasi Java hanya untuk mengaitkan informasi dengan elemen program beranotasi. Anotasi Java dapat digunakan sebagai pengubah dalam deklarasi apa pun, baik paket, kelas (termasuk enum), antarmuka (termasuk jenis anotasi), bidang, metode, parameter formal, konstruktor, atau variabel lokal.

Anotasi Java juga dapat digunakan pada konstanta enum. Anotasi semacam itu ditempatkan tepat sebelum enum konstan yang dianotasi. Anotasi Java secara konvensional ditempatkan di depan semua pengubah lainnya, tetapi ini bukan persyaratan; mereka dapat secara bebas dicampur dengan pengubah lain.

Baca secara terperinci tentang Java Annotations .

Berikut ini adalah beberapa tempat di mana Anda dapat menggunakan anotasi.

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

Anda dapat merujuk tautan ini untuk detail lebih lanjut tentang anotasi.

Anda dapat merujuk tautan ini untuk melihat bagaimana anotasi digunakan untuk membangun rangkaian uji sederhana.