Detaillierte Erläuterung der Java-Annotation-Funktionen

Was ist Annotation?

Annotation wird ins Chinesische als Annotation übersetzt, was bedeutet, zusätzlich zur Logik des Programms selbst zusätzliche Dateninformationen bereitzustellen. Annotation hat keinen direkten Einfluss auf den annotierten Code. Sie kann nicht direkt mit dem annotierten Code interagieren, aber andere Komponenten können diese Informationen verwenden.

Anmerkungsinformationen können in Klassen-Dateien kompiliert oder in der Java Virtual Machine gespeichert werden, sodass sie zur Laufzeit abgerufen werden können. Annotation kann sogar zu Annotation selbst hinzugefügt werden.

Diese Objekte können mit Annotation

Klassen, Methoden, Variablen, Parametern und Paketen hinzugefügt werden kann Anmerkung hinzugefügt werden.

Eingebaute Anmerkung

@Override ÜberladungDie Methode oder der Typ @Deprecated in der übergeordneten Klasse wird nicht mehr empfohlen

@SuppressWarnings Kompilierung verhindern -Zeitliche Warnmeldungen. Es muss ein Array von String als Parameter empfangen. Die verfügbaren Parameter sind:

• ungeprüft

• Pfad

• seriell

• endlich

• Fallthrough

kann mit Anmerkung

@ verwendet werden Retention

bestimmt den

Lebenszyklus der zu speichernden Annotation und muss ein Enum-Objekt RetentionPolicy als Parameter erhalten.

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Documented Documented

@Target

gibt den Bereich an, den die Annotation ändern kann, und erhält eine Enum Array von Objekten EnumType als Parameter.

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE
}

@Inherited

Diese Annotation kann sich auf Unterklassen der annotierten Klasse auswirken.

Benutzerdefinierte Annotation

Wir können Annotation nach JSE5.0 anpassen. Hier ist ein einfaches Beispiel.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodAnnotation {

}

Das folgende Person-Objekt verwendet eine benutzerdefinierte MethodAnnotation.

public class Person {

    public void eat() {
        System.out.println("eating");
    }

    @MethodAnnotation
    public void walk() {
        System.out.print("walking");
    }

}

Wir können Anmerkungsinformationen durch Reflexion erhalten.

 Class<Person> personClass = Person.class;
        Method[] methods = personClass.getMethods();
        for(Method method : methods){
            if (method.isAnnotationPresent(MethodAnnotation.class)){
                method.invoke(personClass.newInstance());
            }
        }

Ausgabe:

walking

Wir können benutzerdefinierten Annotationen auch Methoden hinzufügen.

@Target(ElementType.TYPE)
public @interface personAnnotation {
    int id() default 1;
    String name() default "bowen";
}

Das Folgende ist die Verwendung von personAnnotation.

@personAnnotation(id = 8, name = "john")
public class Person {

    public void eat() {
        System.out.println("eating");
    }

    @MethodAnnotation
    public void walk() {
        System.out.print("walking");
    }

}

Wie Annotationen verarbeitet werden

Wenn der Java-Quellcode kompiliert wird, verarbeitet ein Plug-in-Annotationsprozessor des Compilers diese Annotationen. Der Prozessor kann Berichtsinformationen generieren oder zusätzliche Java-Quelldateien oder -Ressourcen erstellen. Wenn die Annotation selbst zur RenttentionPolicy-Laufzeitklasse hinzugefügt wird, speichert der Java-Compiler die Metadaten der Annotation in der Klassendatei. Anschließend können die Java Virtual Machine oder andere Programme diese Metadaten nachschlagen und entsprechend verarbeiten.

Zusätzlich zum Annotationsprozessor, der Annotationen verarbeiten kann, können wir natürlich auch Reflektion verwenden, um Annotationen selbst zu verarbeiten. Java SE 5 verfügt über eine

Schnittstelle mit dem Namen AnnotatedElement. Die reflektierenden Objektklassen Class, Constructor, Field, Method und Package implementieren alle diese Schnittstelle. Diese Schnittstelle wird verwendet, um die kommentierten Programmelemente darzustellen, die derzeit in der Java Virtual Machine ausgeführt werden. Über diese Schnittstelle können Sie Reflektion zum Lesen von Anmerkungen verwenden. Die AnnotatedElement-Schnittstelle kann auf mit RUNTIME markierte Annotationen zugreifen. Die entsprechenden Methoden sind getAnnotation, getAnnotations und isAnnotationPresent. Da Annotationstypen wie Klassen in Binärdateien kompiliert und gespeichert werden, können die von diesen Methoden zurückgegebenen Annotations wie gewöhnliche Java-Objekte abgefragt werden. Umfangreiche Verwendung von Annotation

Annotation wird häufig in verschiedenen

Frameworks

und Bibliotheken verwendet.

Junit

Junit ist ein sehr bekanntes

Unit-Testing

-Framework. Wenn Sie Junit verwenden, müssen Sie mit vielen Anmerkungen konfrontiert werden.

@Runwith benutzerdefinierte Testklasse Runner

• @ContextConfiguration Set Spring's ApplicationContext

• @DirtiesContext Reload den ApplicationContext, bevor der nächste Test ausgeführt wird.

• @Vor der Initialisierung vor dem Aufruf der Testmethode

• @Nach der Verarbeitung nach dem Aufruf der Testmethode

• @Test gibt an, dass die Methode eine Testmethode ist

• @Ignore kann zur Testklasse oder Testmethode hinzugefügt werden, um den Vorgang zu ignorieren.

• @BeforeClass: Wird aufgerufen, bevor alle Testmethoden in der Testklasse ausgeführt werden, und nur einmal aufgerufen (die markierte Methode muss
statisch
• sein)

• @AfterClass: Wird aufgerufen, nachdem alle Testmethoden in der Testklasse ausgeführt wurden, und nur einmal ausgeführt (die markierte Methode muss statisch sein)

Spring

Der Frühling ist als Konfigurationshölle bekannt und es gibt viele Anmerkungen.

• @Service kommentiert die Serviceklasse

• @Repository kommentiert die DAO-Klasse

• @Component Kommentieren Sie die Komponentenklasse

• @Autowired Lass Spring Bohnen automatisch zusammenbauen

• @Transactional Dinge konfigurieren

• @Scope konfiguriert den Überlebensbereich des Objekts

• @Controller kommentiert die Controller-Klasse

• @RequestMapping URL-Pfadzuordnung

• @PathVariable ordnet Methodenparameter Pfaden zu

• @RequestParam bindet Anforderungsparameter an Methodenvariablen

• @ModelAttribute ist an die gebunden model

• @SessionAttributes wird auf das Sitzungsattribut gesetzt

Hibernate

• @Entity ändert das Entity Bean

• @Table ordnet die Entity-Klasse der Tabelle in der Datenbank zu

• @Column ordnet die Spalte zu

• @Id-Zuordnungs-ID

• @GeneratedValue Dieses Feld erhöht sich selbst

• @Version Versionskontrolle oder Parallelitätskontrolle

• @OrderBy Collation

• @Lob Large Object Annotation

Hibernate und vieles mehr In Bezug auf die Anmerkungen der Vereinigung und der Anmerkungen zum Erben , ist es sinnlos, sie hier aufzulisten.

JSR 303 – Bean Validation

JSR 303 – Bean Validation ist eine Datenvalidierungsspezifikation, und ihre Überprüfung von Java Beans wird hauptsächlich durch Java-Annotation implementiert.

• @NullAnnotated by Das Element von muss null sein

• @NotNull annotated The Element darf nicht null sein

• @AssertTrueDas mit Anmerkungen versehene Element muss wahr sein@AssertFalseDas mit Anmerkungen versehene Element muss falsch sein@Min(Wert)Das mit Anmerkungen versehene Element muss eine Zahl sein, deren Wert größer sein muss als oder gleich dem angegebenen Mindestwert

• @Max(value) Das mit Anmerkungen versehene Element muss eine Zahl sein und sein Wert muss kleiner oder gleich dem angegebenen Maximalwert

• @DecimalMin(value)Das mit Anmerkungen versehene Element muss eine Zahl sein und sein Wert muss größer oder gleich dem angegebenen Mindestwert sein

• @DecimalMax( value)Das mit Anmerkungen versehene Element muss eine Zahl sein, deren Wert kleiner oder gleich dem angegebenen Maximalwert sein muss

• @Size(max, min) Die Größe des mit Anmerkungen versehenen Elements muss sein innerhalb des angegebenen Bereichs

• @Digits (Ganzzahl, Bruch) Das mit Anmerkungen versehene Element muss eine Zahl sein und sein Wert muss innerhalb eines akzeptablen Bereichs liegen

• @Past Das annotierte Element muss ein Datum in der Vergangenheit sein

• Das mit @Future annotierte Element muss ein Datum in der Zukunft sein

• Das mit @Pattern(value) annotierte Element muss dem angegebenen

  regulären Ausdruck entsprechen

Tatsächlich gibt es viele Frameworks oder Bibliotheken, die Annotationen verwenden Ich werde sie hier nicht einzeln auflisten. Ich hoffe, dass jeder mehr über Annotationen in Java erfahren kann.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Java-Annotation-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!