A detailed introduction to custom annotations in Java

This article mainly introduces relevant information about the detailed explanation of Java custom annotations. Java annotations provide some information about the code, but do not directly affect the content of the code it annotates. Friends in need can refer to it

Java Custom Annotations

Java annotations provide some information about the code, but do not directly affect the content of the code it annotates. In this tutorial, we will learn about Java annotations, how to customize annotations, their use and how to parse annotations through reflection.

Java1.5 introduced annotations, which are currently widely used in many java frameworks, such as hibernate, Jersey, and spring. Annotations are embedded into the program as metadata of the program. Annotations can be parsed by some parsing tools or compilation tools. We can also declare annotations to have an effect during compilation or execution.

Before using annotations, program source data only passed through java comments and javadoc, but the functions provided by annotations far exceed these. Annotations not only contain metadata, they can also be used during program running. The annotation interpreter can determine the execution order of the program through annotations. For example, in Jersey webservice we add the **PATH** annotation in the form of a URI string to the method, then during the running of the program, the jersey interpreter will determine the method to call the given URI.

Create Java custom annotations

Creating a custom annotation is similar to creating an interface, but the interface keyword of the annotation needs to start with the @ symbol. We can declare methods for annotations. Let's first look at an example of annotation, and then we'll discuss some of its features.

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();
}

• Annotation methods cannot have parameters;

• The return value type of annotation methods is limited to: basic Type, String, Enums, Annotation or arrays of these types;

• Annotation methods can have default values;

• The annotation itself can contain elements Annotations, meta-annotations are used to annotate other annotations.
  

There are four types of meta-annotations:

1. @Documented ——Indicates that the element with this annotation can be Documentation tools such as javadoc. This type should be used to annotate types that affect client declarations using annotated elements. If a declaration is annotated with Documented, this type of annotation is used as the public API of the annotated program member.

2. @Target——Indicates the range of program elements that this type of annotation can annotate. The value of this meta-annotation can be TYPE, METHOD, CONSTRUCTOR, FIELD, etc. If the Target meta-annotation is not present, the defined annotation can be applied to any element of the program.

3. @Inherited——Indicates that the annotation type is automatically inherited. If the user queries this meta-annotation type in the current class and the declaration of the current class does not contain this meta-annotation type, then the parent class of the current class will also be automatically queried to see if there is an Inherited meta-annotation. This action will be executed repeatedly until this annotation type is known. is found, or the top-level parent class is queried.

4.@Retention——Indicates the length of time the Annotation is retained. The values ​​of RetentionPolicy are SOURCE, CLASS, and RUNTIME.

Java built-in annotations

Java provides three built-in annotations.

1. @Override——When we want to override a method in the parent class, we need to use this annotation to tell the compiler that we want to override this method. In this way, the compiler will prompt an error message when the method in the parent class is removed or changed.

2. @Deprecated - We should use this annotation when we want the compiler to know that a certain method is deprecated. Java recommends the use of this annotation in the javadoc, and we should provide why this method is deprecated and alternatives.

3. @SuppressWarnings - This just tells the compiler to ignore specific warning messages, such as using native data types in generics. Its retention policy is SOURCE (Translator's Note: valid in source files) and is discarded by the compiler.

Let’s look at an example of java’s built-in annotations and refer to the custom annotations mentioned above.

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 this example is self-explanatory and can show its application in different scenarios.

Java annotation parsing

We will use reflection technology to parse the annotations of java classes. Then the RetentionPolicy of the annotation should be set to RUNTIME. Otherwise, the annotation information of the java class will not be available during execution, and we will not be able to get any annotation-related data from it.

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()) {
    // checks if MethodInfo annotation is present for the method
    if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
      try {
    // iterates all the annotations available in the method
        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();
     }
  }
 
}

Running the above program will output:

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

The above is the detailed content of A detailed introduction to custom annotations in Java. For more information, please follow other related articles on the PHP Chinese website!