uio--WebPageMain-Module

JAVA Reflection API

JAVA Reflection API

JAVA-B3 Reflection API Overview Annotations Basics Marker-Annotationen Annotationen mit Werten Multiple Annotations Type-Annotationen Deklaration Predefined Annotations @Deprecated @Override @SuppressWarnings @FunctionalInterface Meta-Annotationen @Retention @Documented @Target @Inherited @Repeatable Pluggable-Type-System Annotations Repeating-Annotations (Java 8) @Repeatable @Repeatable @ExampleAuthor Annotations FAQ Annotation Example: AOP AOP Aspect Oriented Programming mit Custom Annotations AopRechnerInterface AopRechnerImpl AopRechnerInterface AopCheckHatZugangInterceptor AopCheckHatZugangAnnotation AopZugangssystem

Predefined Interfaces Iterable RandomAccess Serializable Cloneable INDEX

Overview

JAVA-B3 | Overview

Die Java Reflection API ermöglicht es, dass ein Programmcode seine eigene Struktur mit Klassen, Methoden, Parametern und Annotationen untersuchen kann. Die API berücksichtigt Overloading und kann dahingehend auch gleichnamige Methoden mit verschiedenen Signaturen ebenso differenzieren wie auch Superklassen, Interfaces und vieles andere mehr ermitteln.

Die Java Reflection API ist die zentrale Voraussetzung für das Annotation-Processing, um mit Hilfe von Java-Programm-Code das Verhalten infolge von Annotationen überhaupt verändern zu können.

Reflection API | Basics

Mit Hilfe der Reflection API ist es möglich, sich für jedes Objekt im Programmcode über dessen .getClass() Methode eine Referenz auf das eigentliche Class Objekt zu beschaffen, dh. der Typ selbst lässt sich referenzieren und besitzt damit Methoden wie mitunter .getMethod(..).

Die weitere Nutzung der Reflection API ist im Grunde genommen für Entwickler, welche eine IDE wie Apache NetBeans oder Eclipse API verwenden und zuvor die Aspekte von Klassen, Methoden, Feldern, Interfaces, Vererbung, Signaturen, Overloading und dergleichen begriffen haben, in Verbindung mit Codehints der IDE selbst erklärend.

Der nachfolgende Programmcode zeigt, wie man die über zwei Custom Annotations, @MinValue und @MaxValue den Wertbereich für Methodenparameter einschränken kann.

Annotationen selbst sind aber nur Zusatzinformationen, haben also in dem Sinn keine eigentliche Funktionalität. Man beschafft sich die Werte der Annotation über Reflection und passt entsprechend die Werte an, wenn die mit falschen Werten geliefert wurden.

Hinweis: Das vollständige Beispiel findet sich im Themenbereich Annotation und Annotation-Processing. 



	/**
	 * Setter Methode für den Wert, annotiert mit {@link MinValue} und {@link MaxValue} mit interner
	 * Auswertung .
	 * 
	 * @param zahl Eine Zahl zwischen 0 und 10.
	 * @throws NoSuchMethodException
	 */
	public void setValue(@MinValue(0) @MaxValue(10) int zahl) throws NoSuchMethodException {

		Method method = this.getClass().getMethod("setValue", int.class); // (1)
		Parameter param = method.getParameters()[0]; // (2)

		int min = param.getAnnotation(MinValue.class).value(); // (3)
		int max = param.getAnnotation(MaxValue.class).value(); // (4)

		if (zahl < min)
			zahl = min; // (5)
		if (zahl > max)
			zahl = max; // (6)

		this.value = zahl; // (7)
	}

Annotationen können Informationen auslesen, diese aber nicht wirklich verändern.

Ein Compile-Time Annotation Processor (JSR-269) wäre in der Lage, Annotationen während des Compilings auszulesen, um beispielsweise auf @NotNull reagieren zu können.

Bytecode-Weaving / Java-Agent (z. B. ByteBuddy) ermöglicht es, dass Methoden-Aufrufe oder dcas Laden von Klassen abgefangen werden kann (Intercepting).

Man muss entsprechend beim Start einer Anwendung mit -javaagent:... noch einen Agenten angeben, damit diese Funktionalität überhaupt bewirkt werden kann.

Auf diesem Wege ist es möglich, dass ein Zugriff auf eine Methode im Programmcode abgefangen, @NotNull erkannt wird, um darauf mit Fehlern, Warnungen oder neuem Code reagieren zu können.

HINWEIS: DAS HAT MIT ÜBLICHER JAVA PROGRAMMIERUNG NICHTS MEHR ZU TUN. 



new AgentBuilder.Default()
 .type(any())
 .transform((b, d, cl, m) ->
 b.method(isAnnotatedWith(NotNull.class))
 .intercept(MethodDelegation.to(NotNullInterceptor.class))
 )
 .installOn(inst);

Ohne Tool-Unterstützung bleibt jede Type-Use-Annotation wirkungslos. Du brauchst mindestens: (1) Einen Annotation Processor, der zusätzlichen Code generiert oder Fehler meldet. (2) Bytecode-Weaving / Java-Agent (z. B. ByteBuddy) für Laufzeit-Interception. (3) AOP-Framework (AspectJ/Spring) für methodische Eingriffe.

FootNotes

    UI ORGANIZED.

    UIO3 Es ist einfacher als Du denkst.

    Stelle noch heute Deine Anfrage.

    Anfrage stellen.
    uio--WebPageFooter-Module