Annotations are defined by the @interface keyword

public @interface TestAnnotation {
}
Copy the code

It looks like an interface, but with an @ sign in front of it. The above code creates an annotation named TestAnnotaion

Now that you have created an annotation, what is the usage of the annotation

@TestAnnotation
public class Test {}Copy the code

To annotate the class with TestAnnotation, create a class Test and add @testannotation to the class definition

However, for annotations to work properly, a new concept needs to be introduced: meta-annotations

Retention Retention means Retention period. When @Retention is applied to a annotation, it explains the annotation’s lifetime

Its values are as follows:

• The retentionPolicy.source annotation is only retained at the SOURCE stage and is discarded and ignored when the compiler compiles
• The retentionPolicy.class annotation is only retained until compilation and is not loaded into the JVM
• Retentionpolicy.runtime annotations can be retained until the application is run, and they are loaded into the JVM, so they can be retrieved while the application is running

@Retention is the equivalent of stamping a label with a time stamp that specifies the period in which the label was posted

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}
Copy the code

In the code above, we specified that the TestAnnotation notation can be accessed during the run cycle of the program, so its life cycle is very long

Target means Target, and @target specifies where the annotation should be used

By analogy, tags can be posted anywhere you want, but thanks to @target, they can only be posted to methods, classes, method parameters, and so on. At sign Target has the following values

• Elementtype. ANNOTATION_TYPE Annotates an annotation
• Elementtype. CONSTRUCTOR can be annotated to a CONSTRUCTOR
• Elementtype. FIELD can be used to annotate attributes
• Elementtype. LOCAL_VARIABLE can be used to annotate local variables
• ElementType.METHOD can annotate methods
• Elementtype. PACKAGE can annotate a PACKAGE
• Elementtype. PARAMETER can be used to annotate parameters within a method
• Elementtype. TYPE can annotate a TYPE, such as a class, interface, or enumeration

Repeatable means Repeatable

What annotations are used more than once? Usually the value of an annotation can be multiple at the same time

Take, for example, a person who is a programmer, a product manager, and a painter

@interface Persons {
	Person[]  value();
}


@Repeatable(Persons.class)
@interface Person{
	String role default "";
}


@Person(role="artist")
@Person(role="coder")
@Person(role="PM")
public class SuperMan{}Copy the code

Notice the code above, @REPEATable annotates Person. The class in parentheses after @REPEATable is equivalent to a container annotation

What are container annotations? It’s a place to store other notes. It is a note in itself

Let’s look again at the relevant container annotations in the code

@interface Persons {
	Person[]  value();
}
Copy the code

As specified, it must have a value property in it. The property type is an array of annotations annotated by @REPEATable. Note that it is an array

If it’s hard to understand, you can understand it this way. Persons is a generic tag filled with Person tags of the same type but with different content. To label Persons as SuperMan is to label him as programmer, product manager and painter.

Person(role= “PM”), which assigns PM to the role attribute of the annotation

We learned about custom annotations above, but the Java language itself already provides several ready-made annotations

This should be familiar, reminding subclasses to Override the @override method in their parent class

Parameter safety type annotations. Its purpose is to warn developers not to do anything unsafe with arguments, and its existence prevents compilers from generating such warnings

Annotations are obtained by reflection. You can first determine whether an annotation is applied to a Class object using the isAnnotationPresent() method

In the example above, we just check out the annotations on the class, but the annotations on the properties and methods are still ok

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

@TestAnnotation(msg="Hello")
public class HelloWorld {
	@Check(value="hi")
	int a;
	
	
	@Perform
	public void testMethod(a){}
	
	
	@SuppressWarnings("deprecation")
	public void test1(a){
		Hero hero = new Hero();
		hero.say();
		hero.speak();
	}


	public static void main(String[] args) {
		
		boolean hasAnnotation = HelloWorld.class.isAnnotationPresent(TestAnnotation.class);
		
		if ( hasAnnotation ) {
			TestAnnotation testAnnotation = HelloWorld.class.getAnnotation(TestAnnotation.class);
			// Get class annotations
			System.out.println("id:"+testAnnotation.id());
			System.out.println("msg:"+testAnnotation.msg());
		}
		
		
		try {
			// Get the attribute member of the class itself
			Field a = HelloWorld.class.getDeclaredField("a");
			// Sets the accessible flag of this object to the indicated Boolean value. A value of true indicates that the reflected object should be used without Java language access checks. A value of false indicates that the reflected object should perform Java language access checking.
			a.setAccessible(true);
			// Get an annotation on a member variable
			Check check = a.getAnnotation(Check.class);
			
			if( check ! =null ) {
				System.out.println("check value:"+check.value());
			} else {
				System.out.println("check is null");
			}
			
			Method testMethod = HelloWorld.class.getDeclaredMethod("testMethod");
			
			if( testMethod ! =null ) {
				// Get the annotation in the method
				Annotation[] ans = testMethod.getAnnotations();
				for( int i = 0; i < ans.length; i++) { System.out.println("method testMethod annotation:"+ans[i].annotationType().getSimpleName()); }}else {
				System.out.println("testMethod is null"); }}catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(e.getMessage());
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(e.getMessage());
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch blocke.printStackTrace(); System.out.println(e.getMessage()); }}}Copy the code

Viewing the Running result



Note that @Retention(retentionPolicy.runtime) is required if an annotation is to be successfully extracted at RUNTIME

To write A testing framework, test programmers for obvious exceptions in their code — Programmer A: I wrote A class called NoBug, because all its methods are error-free — me: Confidence is A good thing, but just in case of accidents, how about I test it? — Programmer A: How do you test it? — Me: Just add @jiecha to all the methods you write — Programmer A: Ok

NoBug.class

public class NoBug {
	@CheckError
	public void suanShu(a) {
		System.out.println("1234567890");
	}

	@CheckError
	public void jiafa(a) {
		System.out.println("1 + 1 =" + 1 + 1);
	}

	@CheckError
	public void jianfa(a) {
		System.out.println("1-1 =" + (1 - 1));
	}

	@CheckError
	public void chengfa(a) {
		System.out.println("3 x 5=" + 3 * 5);
	}

	@CheckError
	public void chufa(a) {
		System.out.println("6/0 =" + 6 / 0); }}Copy the code

This code above, some of these methods have the @checkerror annotation on them

@Retention(RetentionPolicy.RUNTIME)
public @interface CheckError {

}
Copy the code

Now you can test the corresponding method for NoBug

public class HelloWorld {
	public static void main(String[] args) {
		NoBug testobj = new NoBug();

		Class clazz = testobj.getClass();

		Method[] method = clazz.getDeclaredMethods();
		// To record the log information generated by the test
		StringBuilder log = new StringBuilder();
		// Record the number of exceptions
		int errornum = 0;

		for (Method m : method) {
			// Only methods marked by @checkerror are tested
			if (m.isAnnotationPresent(CheckError.class)) {
				try {
					m.setAccessible(true);
					// The target method used to execute an object
					m.invoke(testobj, null);

				} catch (Exception e) {
					// TODO Auto-generated catch block
					// e.printStackTrace();
					errornum++;
					log.append(m.getName());
					log.append("");
					log.append("has error:");
					log.append("\n\r caused by ");
					// Record the name of the exception that occurred during the test
					log.append(e.getCause().getClass().getSimpleName());
					log.append("\n\r");
					// Record specific information about exceptions that occur during the test
					log.append(e.getCause().getMessage());
					log.append("\n\r");
				}
			}
		}

		log.append(clazz.getSimpleName());
		log.append(" has ");
		log.append(errornum);
		log.append(" error.");

		// Generate a test reportSystem.out.println(log.toString()); }}Copy the code

Viewing the Running result



The chufa() method in the NoBug class has an exception called ArithmeticException because it divides 0

Thus, with annotations I accomplish my own purpose, which is to test someone else’s code

So, when are annotations used? All I can tell you is, it depends what you want to do with it

JUnit is a testing framework, typically used as follows:

public class MyMathTest {

    @Test
    public void add(a) {... }}Copy the code

@test marks the method to Test add()

Previous JUnit article portal