Java-annotaties

Handleidingen
Java

Java-annotaties bevatten informatie over de code. Java-annotaties hebben geen direct effect op de code die ze annoteren. In de Java-annotatietutorial zullen we de volgende onderwerpen behandelen;

  1. Ingebouwde Java-annotaties
  2. Hoe aangepaste annotatie te schrijven
  3. Gebruik van annotaties en hoe annotaties te ontleden met behulp van Reflection API.

Java-annotaties

Java 1.5 introduceerde annotaties en nu wordt het veel gebruikt in Java EE-frameworks zoals Hibernate, Jersey en Spring. Java-annotatie is metadata over het programma ingebed in het programma zelf. Het kan worden geparseerd door de annotatie-analysetool of door de compiler. We kunnen ook specificeren dat annotaties alleen beschikbaar zijn tot aan compileertijd of tot aan runtime. Voor java-annotaties waren programmametadata beschikbaar via java-opmerkingen of via Javadoc, maar annotatie biedt meer dan dat. Annotaties-metadata kan ook beschikbaar zijn tijdens runtime en annotatie-analysatoren kunnen het gebruiken om de processtroom te bepalen. Bijvoorbeeld, in Jersey-webservice voegen we een PATH-annotatie toe met een URI-string naar een methode en tijdens runtime analyseert Jersey het om de methode te bepalen die moet worden aangeroepen voor het gegeven URI-patroon.

Java-aangepaste annotatie

Het maken van aangepaste annotaties is vergelijkbaar met het schrijven van een interface, behalve dat het interface-trefwoord is voorafgegaan door het symbool _@_. We kunnen methoden declareren in annotaties. Laten we een voorbeeld van aangepaste Java-annotaties bekijken en vervolgens zullen we de functies en belangrijke punten bespreken.

package com.journaldev.annotations;

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

@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
	String author() default "Pankaj";
	String date();
	int revision() default 1;
	String comments();
}

Enkele belangrijke punten over Java-annotaties zijn:

  1. Annotatiemethoden kunnen geen parameters hebben.
  2. Het retourtype van annotatiemethoden is beperkt tot primitieven, String, Enums, Annotation of een array van deze types.
  3. Java-annotatiemethoden kunnen standaardwaarden hebben.
  4. Annotaties kunnen metagegevens hebben die eraan zijn gekoppeld. Metagegevens worden gebruikt om informatie over de annotatie te verstrekken.

Metagegevens in Java

Er zijn vijf soorten metagegevens:

  1. @Documented – geeft aan dat elementen die deze annotatie gebruiken, gedocumenteerd moeten worden door javadoc en vergelijkbare tools. Dit type moet worden gebruikt om de declaraties van typen te annoteren waarvan de annotaties het gebruik van geannoteerde elementen door hun clients beïnvloeden. Als een typeverklaring is geannoteerd met Documented, worden de annotaties ervan onderdeel van de publieke API van de geannoteerde elementen.
  2. – **@Doel** – geeft aan op welke soorten programmablokken een annotatietype van toepassing is. Enkele mogelijke waarden zijn TYPE, METHODE, CONSTRUCTOR, VELD, enzovoort. Als de meta-annotatie Doel niet aanwezig is, kan de annotatie worden gebruikt op elk programmablok.

  3. – **@Overgeërfd** – geeft aan dat een annotatietype automatisch wordt geërfd. Als een gebruiker het annotatietype op een klasseverklaring opvraagt en de klasseverklaring geen annotatie heeft voor dit type, wordt automatisch de superklasse van de klasse opgevraagd voor het annotatietype. Dit proces wordt herhaald totdat een annotatie voor dit type is gevonden of de bovenkant van de klassenhiërarchie (Object) is bereikt.

  4. – **@Bewaring** – geeft aan hoelang annotaties met het geannoteerde type moeten worden behouden. Het neemt een RetentionPolicy-argument aan waarvan de mogelijke waarden BRON, KLASSE en UITVOERING zijn.

  5. – **@Herhaalbaar** – wordt gebruikt om aan te geven dat het annotatietype waarvan het de verklaring annoteert, herhaalbaar is.

– **Ingebouwde annotaties in Java**

Java biedt vijf ingebouwde annotaties.

  1. @Override – Wanneer we een methode van Superclass willen overschrijven, moeten we deze annotatie gebruiken om de compiler te informeren dat we een methode overschrijven. Dus wanneer de methode van de superklasse wordt verwijderd of gewijzigd, zal de compiler een foutmelding weergeven. Leer waarom we altijd de java override annotatie moeten gebruiken bij het overschrijven van een methode.
  2. @Deprecated – wanneer we de compiler willen laten weten dat een methode verouderd is, moeten we deze annotatie gebruiken. Java raadt aan om in javadoc informatie te verstrekken over waarom deze methode verouderd is en wat het alternatief is om te gebruiken.
  3. @SuppressWarnings – Dit is gewoon om de compiler te vertellen specifieke waarschuwingen te negeren die ze produceren, bijvoorbeeld het gebruik van ruwe typen in java generics. Het retentiebeleid is BRON en het wordt verwijderd door de compiler.
  4. @FunctionalInterface – Deze annotatie werd geïntroduceerd in Java 8 om aan te geven dat de interface bedoeld is om een functionele interface te zijn.
  5. @SafeVarargs – Een programmeursverklaring dat het lichaam van de geannoteerde methode of constructor geen potentieel onveilige bewerkingen uitvoert op zijn varargs-parameter.

Voorbeeld van Java-annotaties

Laten we een Java-voorbeeld bekijken waarin het gebruik van ingebouwde annotaties in Java wordt getoond, evenals het gebruik van aangepaste annotatie die door ons is gemaakt in het bovenstaande voorbeeld.

package com.journaldev.annotations;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class AnnotationExample {

	public static void main(String[] args) {
	}

	@Override
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 1)
	public String toString() {
		return "Overriden toString method";
	}

	@Deprecated
	@MethodInfo(comments = "deprecated method", date = "Nov 17 2012")
	public static void oldMethod() {
		System.out.println("old method, don't use it.");
	}

	@SuppressWarnings({ "unchecked", "deprecation" })
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 10)
	public static void genericsTest() throws FileNotFoundException {
		List l = new ArrayList();
		l.add("abc");
		oldMethod();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Verwerking van Java-annotaties

We zullen Reflectie gebruiken om Java-annotaties uit een klasse te analyseren. Let op dat de annotatieretentiebeleid RUNTIME moet zijn, anders zijn de gegevens ervan niet beschikbaar tijdens runtime en kunnen we er geen gegevens van ophalen.

package com.journaldev.annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class AnnotationParsing {

	public static void main(String[] args) {
		try {
			for (Method method : AnnotationParsing.class.getClassLoader()
					.loadClass(("com.journaldev.annotations.AnnotationExample")).getMethods()) {
				// controleert of de MethodInfo-annotatie aanwezig is voor de methode
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// doorloopt alle beschikbare annotaties in de methode
						for (Annotation anno : method.getDeclaredAnnotations()) {
							System.out.println("Annotation in Method '" + method + "' : " + anno);
						}
						MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
						if (methodAnno.revision() == 1) {
							System.out.println("Method with revision no 1 = " + method);
						}

					} catch (Throwable ex) {
						ex.printStackTrace();
					}
				}
			}
		} catch (SecurityException | ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

De uitvoer van het bovenstaande programma is:

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

De Reflection API is zeer krachtig en wordt veel gebruikt in Java, J2EE-frameworks zoals Spring, Hibernate, JUnit, bekijk Reflectie in Java. Dat is alles voor het Java-annotatievoorbeeld, ik hoop dat je er iets van hebt geleerd. Updates van Java-annotaties:

  1. Servletspecificaties 3.0 introduceerden het gebruik van annotaties voor Servletconfiguratie en initialisatieparameters, lees meer op Java Servlet Tutorial.
  2. We kunnen annotaties gebruiken in Struts 2 om actieklassen en resultaatpagina’s te configureren, bekijk een werkend voorbeeld op Struts 2 Hello World Annotation Example.

Referentie: Oracle website

Source:
https://www.digitalocean.com/community/tutorials/java-annotations