Jak i gdzie są używane Adnotacje w Javie?

Jakie są główne obszary, w których możemy używać Adnotacji? Czy ta funkcja zastępuje konfigurację opartą na XML?

Adnotacje to meta-obiekty, które można wykorzystać do opisania innych meta-obiektów . Meta-obiekty to klasy, pola i metody. Pytanie obiektu o jego meta-obiekt (np. anObj.getClass()) Nazywa się introspekcją . Introspekcja może pójść dalej i możemy zapytać meta-obiekt, jakie są jego adnotacje (np aClass.getAnnotations.). Introspekcja i adnotacje należą do tak zwanych refleksji i metaprogramowania .

Adnotacja musi być interpretowana w taki czy inny sposób, aby była przydatna. Adnotacje mogą być interpretowane w czasie programowania przez IDE lub kompilator, lub w czasie wykonywania przez środowisko.

Przetwarzanie adnotacji jest bardzo silnym mechanizmem i może być używane na wiele różnych sposobów:

• opisywać ograniczenia lub użycie elementu: np. @Deprecated, @Overridelub@NotNull
• opisywać „naturę” elementu, np @Entity, @TestCase, @WebService
• opisać zachowanie elementu: @Statefull, @Transaction
• opisać jak przetwarzać element: @Column, @XmlElement

We wszystkich przypadkach adnotacja służy do opisu elementu i wyjaśnienia jego znaczenia .

Przed JDK5 informacje wyrażane teraz adnotacjami musiały być przechowywane gdzie indziej, a pliki XML były często używane. Jednak wygodniej jest używać adnotacji, ponieważ będą one należeć do samego kodu Java, a zatem są znacznie łatwiejsze do manipulowania niż XML.

Wykorzystanie adnotacji:

• Dokumentacja, np. XDoclet
• Kompilacja
• IDE
• Środowisko testowe, np. JUnit
• Pojemnik IoC np. Jako wiosna
• Serializacja, np. XML
• Programowanie aspektowe (AOP), np. Spring AOP
• Serwery aplikacji, np. Kontener EJB, usługa sieci Web
• Mapowanie obiektowo-relacyjne (ORM), np. Hibernacja, JPA
• i wiele więcej...

... spójrz na przykład na projekt Lombok , który używa adnotacji do zdefiniowania sposobu generowania equalslub hashCodemetod.

Istnieją różne aplikacje do adnotacji Java. Przede wszystkim mogą być używane przez kompilator (lub rozszerzenia kompilatora). Rozważmy na przykład adnotację Zastąp :

class Foo {

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

Ten jest faktycznie wbudowany w Java JDK. Kompilator zasygnalizuje błąd, jeśli jakaś metoda zostanie do niego oznaczona, co nie zastąpi metody odziedziczonej z klasy podstawowej. Ta adnotacja może być pomocna w celu uniknięcia typowego błędu, polegającego na tym, że faktycznie zamierzasz zastąpić metodę, ale tego nie zrobisz, ponieważ podpis podany w metodzie nie pasuje do podpisu zastępowanej metody:

class Foo {

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

Począwszy od JDK7, adnotacje są dozwolone na dowolnym typie. Tej funkcji można teraz używać do adnotacji kompilatora, takich jak NotNull , takich jak:

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

co pozwala kompilatorowi ostrzegać cię przed niewłaściwym / niesprawdzonym użyciem zmiennych i wartości zerowych .

Kolejna bardziej zaawansowana aplikacja do adnotacji obejmuje przetwarzanie refleksji i adnotacji w czasie wykonywania. To jest (myślę) to, co miałeś na myśli, mówiąc o adnotacjach jako „zamienniku konfiguracji opartej na XML”. Jest to rodzaj przetwarzania adnotacji wykorzystywanego na przykład przez różne frameworki i standardy JCP (trwałość, wstrzykiwanie zależności, jak go nazywasz) w celu zapewnienia niezbędnych metadanych i informacji o konfiguracji.

Adnotacje są formą metadanych (danych o danych) dodawanych do pliku źródłowego Java. Są one w dużej mierze wykorzystywane przez frameworki w celu uproszczenia integracji kodu klienta. Kilka przykładów ze świata rzeczywistego:

• JUnit 4 - dodajesz @Testadnotację do każdej metody testowej, którą chcesz uruchomić program uruchamiający JUnit. Istnieją również dodatkowe adnotacje związane z konfigurowaniem testowania (jak @Beforei @BeforeClass). Wszystkie te są przetwarzane przez moduł uruchamiający JUnit, który odpowiednio uruchamia testy. Można powiedzieć, że zastępuje konfigurację XML, ale adnotacje są czasem mocniejsze (mogą na przykład używać odbicia), a także są bliższe kodowi, do którego się odnoszą ( @Testadnotacja jest tuż przed metodą testową, więc cel tej metody jest jasne - służy również jako dokumentacja). Z drugiej strony konfiguracja XML może być bardziej złożona i może zawierać znacznie więcej danych niż adnotacje.

• Terakota - wykorzystuje zarówno adnotacje, jak i pliki konfiguracyjne XML. Na przykład @Rootadnotacja informuje środowisko wykonawcze Terracotta, że ​​pole z adnotacjami jest elementem głównym, a jego pamięć powinna być współużytkowana między instancjami VM. Plik konfiguracyjny XML służy do skonfigurowania serwera i podania mu klas, które mają być instrumentowane.

• Google Guice - przykładem może być @Injectadnotacja, która po zastosowaniu do konstruktora powoduje, że środowisko wykonawcze Guice szuka wartości dla każdego parametru na podstawie zdefiniowanych wtryskiwaczy. @InjectAdnotacja byłoby dość trudne do powtórzenia przy użyciu plików konfiguracyjnych XML, a jego bliskość do konstruktora jest wykorzystywana do jest bardzo przydatne (wyobrazić konieczności wyszukiwania do ogromnego pliku XML znaleźć wszystkie wstrzykiwanie zależności zostały ustawione).

Mam nadzieję, że dałem wam przedsmak tego, jak adnotacje są używane w różnych ramach.

Adnotacje w Javie stanowią sposób na opisanie klas, pól i metod. Zasadniczo są one formą metadanych dodawanych do pliku źródłowego Java, nie mogą bezpośrednio wpływać na semantykę programu. Jednak adnotacje można odczytać w czasie wykonywania za pomocą Reflection, a proces ten nosi nazwę introspekcji. Następnie można go użyć do modyfikacji klas, pól lub metod.

Ta funkcja jest często wykorzystywana przez biblioteki i zestawy SDK (hibernacja, JUnit, Spring Framework) w celu uproszczenia lub zmniejszenia ilości kodu, który programista by zrobił, chyba że zrobiłby to inaczej, aby pracować z tymi bibliotekami lub zestawami SDK. Dlatego słusznie jest powiedzieć Adnotacje i Odbicie działa ręka w rękę w Javie.

Możemy również ograniczyć dostępność adnotacji do czasu kompilacji lub środowiska wykonawczego. Poniżej znajduje się prosty przykład tworzenia niestandardowej adnotacji

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";
}

Czy zastępuje konfigurację opartą na XML?

Nie do końca, ale konfiguracja, która ściśle odpowiada strukturom kodu (takim jak odwzorowania JPA lub wstrzykiwanie zależności na wiosnę), często może być zastąpiona adnotacjami, a wtedy jest zwykle znacznie mniej szczegółowa, denerwująca i bolesna. Prawie wszystkie znaczące frameworki dokonały tego przełączenia, chociaż stara konfiguracja XML zwykle pozostaje opcją.

Istnieją 2 widoki adnotacji

1. widok użytkownika przez większość czasu adnotacje działają jak skrót, pozwalają zaoszczędzić kilka naciśnięć klawiszy lub sprawiają, że program jest bardziej czytelny

2. widok dostawcy, procesorowy opis adnotacji jest raczej lekkim „interfejsem”, twój program MUSI skonfrontować się z COŚ, ale bez wyraźnego „implementowania” określonego interfejsu (tutaj aka adnotacja)

np. w jpa definiujesz coś podobnego

@Entity class Foo {...}

zamiast

class Foo implements Entity {...}

oboje mówią to samo „Foo jest klasą Entity”

Gdzie można używać adnotacji

Adnotacje mogą być stosowane do deklaracji: deklaracji klas, pól, metod i innych elementów programu. W przypadku użycia w deklaracji każda adnotacja często pojawia się, zgodnie z konwencją, w osobnej linii.

Aktualizacja Java SE 8: adnotacje można również zastosować do użycia typów. Oto kilka przykładów:

• Wyrażenie tworzenia instancji klasy:

  new @Interned MyObject ();

• Typ obsady:

  myString = (@NonNull String) str;

• implementuje klauzulę:

  klasa UnmodifiableList implementuje @Readonly List <@Readonly T> {...}

• Zgłoszona wyjątek:

  void monitorTemperature () zgłasza @Critical TemperatureException {...}

Szkielety takie jak Hibernacja, w których wymagane jest wiele konfiguracji / mapowania, mocno wykorzystują Adnotacje.

Spójrz na adnotacje hibernacji

JPA (z Java EE 5) jest doskonałym przykładem (nad) korzystania z adnotacji. Java EE 6 wprowadzi także adnotacje w wielu nowych obszarach, takich jak usługi sieciowe RESTful i nowe adnotacje dla każdego starego, dobrego API Servleta.

Oto kilka zasobów:

• Sun - Java Persistence API
• Samouczek Java EE 5 - JPA
• Przedstawiamy platformę Java EE 6 (sprawdź wszystkie trzy strony).

Adnotacje przejmują nie tylko specyfikę konfiguracji, ale mogą też służyć do kontrolowania zachowania. Widzisz to dobrze w przykładach JAX-RS Java EE 6.

Jest przydatny do opisywania klas, na poziomie metody, klasy lub pola, czegoś o tej klasie, co nie jest całkiem związane z klasą.

Możesz mieć własne adnotacje, używane do oznaczania niektórych klas tylko do użytku testowego. Może to być po prostu do celów dokumentacyjnych lub można go wymusić, odfiltrowując go podczas kompilacji kandydata do wydania produkcyjnego.

Możesz użyć adnotacji do przechowywania niektórych metadanych, na przykład w ramach wtyczki, np. Nazwy wtyczki.

To tylko kolejne narzędzie, ma wiele celów.

Dołącza dodatkowe informacje o kodzie poprzez (a) sprawdzenie kompilatora lub (b) analizę kodu

**

• Poniżej znajdują się wbudowane adnotacje :: 2 typy

**

Typ 1) Adnotacje zastosowane do kodu 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"})

Typ 2) Adnotacje stosowane do innych adnotacji:

@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).

**

• Adnotacje niestandardowe ::

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

ABY LEPSZE ZROZUMIEĆ WYPRÓBUJ PONIŻEJ LINK: OPRACUJ PRZYKŁADY

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

Adnotacje mogą być używane jako alternatywa dla zewnętrznych plików konfiguracyjnych, ale nie mogą być uważane za całkowitą zamianę. Można znaleźć wiele przykładów, w których do zamiany plików konfiguracyjnych użyto adnotacji, takich jak Hibernate, JPA, EJB 3 i prawie wszystkie technologie zawarte w Javie EE.

W każdym razie nie zawsze jest to dobry wybór. Używanie plików konfiguracyjnych ma zwykle na celu oddzielenie kodu od szczegółów środowiska, w którym aplikacja jest uruchomiona. W takich sytuacjach, a głównie gdy konfiguracja jest używana do mapowania aplikacji do struktury systemu zewnętrznego, adnotacje nie są dobrym zamiennikiem pliku konfiguracyjnego, ponieważ zawierają szczegółowe informacje o systemie zewnętrznym w kodzie źródłowym Twoje zgłoszenie. Tutaj pliki zewnętrzne należy uznać za najlepszy wybór, w przeciwnym razie będziesz musiał zmodyfikować kod źródłowy i ponownie skompilować za każdym razem, gdy zmienisz odpowiedni szczegół w środowisku wykonawczym.

Adnotacje są znacznie bardziej przydatne do ozdabiania kodu źródłowego dodatkowymi informacjami, które instruują narzędzia przetwarzania, zarówno w czasie kompilacji, jak i w czasie wykonywania, w celu specjalnego obsługiwania klas i struktur klas. @Overridea JUnit @Testto dobre przykłady takiego użycia, wyjaśnione szczegółowo w innych odpowiedziach.

W końcu zasada jest zawsze taka sama: trzymaj w źródle rzeczy, które zmieniają się wraz ze źródłem, i trzymaj poza źródłem rzeczy, które zmieniają się niezależnie od źródła.

Java EE 5 preferuje stosowanie adnotacji zamiast konfiguracji XML. Na przykład w EJB3 atrybuty transakcji w metodzie EJB są określane za pomocą adnotacji. Używają nawet adnotacji, aby oznaczyć POJO jako EJB i określić konkretne metody jako metody cyklu życia, zamiast wymagać implementacji interfejsu.

Adnotacja Java ma na celu jedynie powiązanie informacji z elementem programu z adnotacjami. Adnotacje Java mogą być używane jako modyfikatory w dowolnej deklaracji, niezależnie od tego, czy pakiet, klasa (w tym wyliczenia), interfejs (w tym typy adnotacji), pole, metoda, parametr formalny, konstruktor czy zmienna lokalna.

Adnotacje Java mogą być również używane w przypadku stałych wyliczeniowych. Takie adnotacje są umieszczane bezpośrednio przed stałą wyliczania, którą adnotują. Adnotacje Java są tradycyjnie umieszczane przed wszystkimi innymi modyfikatorami, ale nie jest to wymagane; mogą być dowolnie mieszane z innymi modyfikatorami.

Przeczytaj szczegółowo o Adnotacjach Java .

Oto niektóre z miejsc, w których można używać adnotacji.

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

Możesz polecić ten link aby uzyskać więcej informacji na temat adnotacji.

Możesz skorzystać z tego linku, aby zobaczyć, w jaki sposób adnotacje są używane do budowy prostego pakietu testowego.