Java Reflection Learning Summary Five (Annotation (annotations)-Basic article)

Annotation (note) Introduction:

Note the most impressive possibility is that JUnit does the unit test and uses it in various frameworks. This article mainly briefly introduces the use of annotations, the next article in-depth study.

annotation does not directly affect code semantics, but it can be seen as a program-like tool or class library, which in turn has an impact on the running program semantics.

Annotation can be read from source files, class files, or in various ways that are reflected at run time

The Java annotation system comes with the following main annotations:

The override annotation represents the corresponding method of the subclass to override (override) the parent class

Deprecated Annotation representation method is not recommended to be used

Suppress Warnings annotations indicate suppression warnings

How to customize annotations:

You only need to use @interface to define an annotation, for example:

[Java]View Plaincopy print?

1. Use @interface to declare an annotation (actually automatically inherits the Java.lang.annotation.Annotation interface)
2. Public @interface Annotationtest {
3. String value1 () default "Hello"; //Set the String Type property Value1 for the annotation and set the default value using the Defalut keyword
4. Enumtest value2 (); //Set value2 for enumeration type
5. String[] Value3 (); //Set Value3 of array type
6. }

How to use annotations, as follows:

[Java]View Plaincopy print?

2. @AnnotationTest (value2 = enumtest.age, value3={""})
4. Public class Annotationusage {
8. @AnnotationTest (value1 = "Test", value2 = Enumtest.name, value3={""})
10. String test;
14. @AnnotationTest (value1 = "Test", value2 = Enumtest.name, value3={""})
16. public Void Method () {
18. System.out.println ("Usage of Annotation");
20. }
22. }

As above, annotations can be labeled on properties, methods, and classes.

You need to assign a value to a property using Name=value, because value1 sets the default property, so you can ignore it, and if you don't set a default, all of the properties are assigned values.

There is also a special case, if the annotation only defines an attribute, the name is value, then you can directly assign the value, do not need to use the Name=value this assignment method, as follows:

[Java]View Plaincopy print?

1. Public @interface Annotationtest {
2. String value ();
3. }
5. @AnnotationTest ("test")
6. Public Void Method () {
7. System.out.println ("Usage of Annotation");
8. }

"Annotations" for retouching annotations

Annotations can also add annotations to the "annotations" to decorate, commonly used in the following two, one is retention, a target

Retention:

Using retention, you must provide an enumeration for the Java.lang.annotation.RetentionPolicy type.

The Retentionpolicy enumeration has the following 3 types:

SOURCE : Completes the task when the program is compiled with annotation information

class: The compiler stores annotation in a CLASS file and cannot be read into by the virtual machine

RUNTIME: The compiler stores the annotation in the class file, which can be read by the virtual machine

With these three kinds of retention prolicy you can decide whether annotations are read from source files, class files, or reflected at run time

Examples of retention in the last

Target:

Use Java.lang.annotation.Target to define where annotations are used

Similarly, when using a Java.lang.annotation.ElementType to specify an enumeration value type of his "properties"

The types of ElementType enumerations are as follows:

Annotation_type: Suitable for ANNOTATION
CONSTRUCTOR: suitable for construction methods
field: applies To field
local_variable: suitable for local variables
method: applies to methods
Package: for the package
PARAMETER: Suitable for PARAMETER on method
TYPE: for Class,interface,enum

As follows: Define an annotation mytarget, set the target type as method to modify the annotation so that the annotation can only be labeled on method

[Java]View Plaincopy print?

1. @Target (Elementtype.method)
2. Public @interface Mytarget {
3. String Hello () default "Hello";
4. }

[Java]View Plaincopy print?

1. @MyTarget //There will be an error, because he is marked on the class
2. Public class Mytargettest {
3. @MyTarget //callout does not error on method
4. public void DoSomething () {
5. System.out.println ("Hello World");
6. }
7. }

invoking annotations using reflection
In the following classes, Class Constructor Field Method package and other classes implement the Annotatedelement interface in the interface has the following important methods:
getannotations (Class annotationtype)gets a specified type of annotation
getannotations () get all the annotation
getdeclaredannotations () gets all the annotation that have been declared
isannotationpresent (class<? extends annotation> Annotationclass) Whether this annotation appears
With these methods, we can get the contents of the annotations when the program is running, with the following examples: [Java]View Plaincopy print?

1. @Retention (Retentionpolicy.runtime) //define an annotation and use the Retention callout as RUNTIME
2. Public @interface Myannotation {
3. String Hello () default "Hello";
4. String World ();
5. }

The note is marked as the runtime type, indicating that the note can be saved in the class file and read to the Java Virtual machine at run time

[Java]View Plaincopy print?

1. @Retention (Retentionpolicy.class) //define an annotation, Retention labeled as runtime
2. Public @interface MyAnnotation2 {
3. String Hello () default "Hello"; //Set the default value to Hello
4. }

Another custom annotation retention marked as class

[Java]View Plaincopy print?

2. Public class MyTest {
4. @SuppressWarnings ("unchecked") //java Annotated retention's policy is source
6. @Deprecated //java Annotations Retention's policy is runtime
8. @MyAnnotation (name="Dean", age=") //Custom annotations retention policy is runtime
10. @MyAnnotation2 //Custom annotations retention policy is class
12. public void TestMethod () {
14. System.out.println ("This is a method");
16. }
18. }

Define a TestMethod method that gives him 4 annotations, of which 2 Java comes with 2 that we customize. The retention properties of the annotations are different.

The following defines a test class to validate the results:

[Java]View Plaincopy print?

2. Public static void Main (string[] args) throws Exception {
6. MyTest MyTest = new MyTest ();
8. //Get the TestMethod method by reflection
10. class<mytest> C = MyTest.  class;
12. method = C.getmethod ("TestMethod", new class[]{});
16. method Isannotationpresent () in the//annotatedelement interface to determine whether an incoming annotation type exists
18. if (method.isannotationpresent (myannotation. Class)) {
20. Method.invoke (MyTest, new object[]{});
22. method Getannotation () in the//annotatedelement interface to get annotations of the incoming annotation type
24. Myannotation myannotation = method.getannotation (myannotation.   Class);
26. //Get the attributes in the annotation
28. String name = Myannotation.name ();
30. String age = Myannotation.age ();
32. System.out.println ("Name:" +name +"Age:" +age);
34. }
38. System.out.println ("-----------------------------------");
42. method Getannotations () in the//annotatedelement interface to get all annotations
44. annotation[] annotations = method.getannotations ();
46. //Loop annotation array prints the name of the annotation type
48. For (Annotation annotation:annotations) {
50. System.out.println (Annotation.annotationtype (). GetName ());
52. }
54. }

Print Result: This is a method
Name:dean age:25
-----------------------------------
java.lang.Deprecated
Gxy.text.annotation.MyAnnotation

Split Line: Describes how to use methods and reflections in the Annotatedelement interface to invoke annotations

Under Split line: It proves that only annotations that define the retention policy as runtime can be read by reflection.

The next article analyzes the use and rationale of reflection and annotations in JUnit

Java Reflection Learning Summary Five (Annotation (annotations)-Basic article)