Application of Java annotation-dynamic parsing of annotation during runtime (3)

In the first two articles:

This section introduces the basic concepts of annotation and how to customize annotation.
This article describes how to dynamically parse annotation during runtime.
As mentioned above, annotation is only the additional information appended to the code. annotation itself will not affect the code execution.

In this case, what role does annotation play?
1. Compilation tools or other tools can automatically generate configuration files, documents, and other external files based on the annotation information attached to the code.
For example, Sun provides the apt tool (annotation processing tool), which is a command line tool that can handle annotation. APT provides source code-level parsing during compilation, new source code and other files can be generated during parsing, And the generated source code can also be compiled.
2. Other programs can dynamically parse annotation information in the program to be executed at runtime, and perform different operations according to the appended annotation information.
For example, the ejb3 specification widely uses the Annotation Feature. For example, if the @ stateless annotation is specified for the class in pojo, The EJB container registers the pojo as a stateless Session Bean based on this annotation. Ejb3 uses annotation to greatly simplify the EJB development and configuration process. We will introduce the principles and usage of EJB annotation in other articles.

This article uses a simple example to illustrate how to dynamically parse annotation at runtime. We will introduce the apt tool in other recent articles.

For example, we have defined myannotation3 annotation:
Myannotation3.java

Java code

1. Package com. Test. annotation;
2. Import java. Lang. annotation. annotation;
3. Import java. Lang. annotation. inherited;
4. Import java. Lang. annotation. retention;
5. Import java. Lang. annotation. retentionpolicy;
6. @ Retention (retentionpolicy. runtime)
7. Public @ interface myannotation3 {
8. Public String Value ();
9. Public String [] multivalues ();
10. Int number () default 0;
11. }

 

A comment named myannotation3 is defined above.
Let's define another getmyannotation class, which uses myannotation3 annotation:
Getmyannotation. Java:

 

 

Java code

1. Package com. Test. annotation. test;
3. Import java. Lang. annotation. annotation;
4. Import java. Lang. Reflect. field;
5. Import java. Lang. Reflect. method;
6. Import javax. EJB. EJB;
7. Import javax. Naming. initialcontext;
8. Import javax. Naming. namingexception;
9. Import com. Test. annotation. myannotation3;
11. // Append the myannotation3 annotation to the getmyannotation class
12. @ Myannotation3 (value = "class getmyannotation", multivalues = {"1", "2 "})
13. Public class getmyannotation {
15. // Append the myannotation3 annotation to the testfield1 attribute
16. @ Myannotation3 (value = "Call testfield1", multivalues = {"1"}, number = 1)
17. Private string testfield1;
19. // Append the myannotation3 annotation to the testmethod1 Method
20. @ Myannotation3 (value = "Call testmethod1", multivalues = {"1", "2"}, number = 1)
21. Public void testmethod1 (){
22. }
24. @ Deprecated
25. @ Myannotation3 (value = "Call testmethod2", multivalues = {"3", "4", "5 "})
26. Public void testmethod2 (){
27. }
28. }

In the above example, getmyannotation is very simple and does not have any functions in it. However, the myannotation3 annotations are added for class, field, and method declarations.
Next we will use the program testmyannotation3 to parse the myannotation3 annotation in getmyannotation.
Annotation parsing during runtime
Testmyannotation3.java

 

 

 

Java code

1. Public class testmyannotation3 {
3. Public static void main (string [] ARGs ){
5. System. Out. println ("-- class annotations --");
7. If (getmyannotation. Class. isannotationpresent (myannotation3.class )){
8. System. Out. println ("[getmyannotation]. annotation :");
10. Myannotation3 classannotation = getmyannotation. Class
11. . Getannotation (myannotation3.class );
12. Printmyannotation3 (classannotation );
13. }
14. System. Out. println ("-- fields annotations --");
16. Field [] fields = getmyannotation. Class. getdeclaredfields ();
18. For (field: fields ){
20. If (field. isannotationpresent (myannotation3.class )){
22. System. Out. println ("[getmyannotation." + field. getname ()
23. + "]. Annotation :");
25. Myannotation3 fieldannotation = Field
26. . Getannotation (myannotation3.class );
28. Printmyannotation3 (fieldannotation );
29. }
30. }
31. System. Out. println ("-- Methods annotations --");
33. Method [] Methods = getmyannotation. Class. getdeclaredmethods ();
35. For (method: Methods ){
37. System. Out. println ("[getmyannotation." + method. getname ()
38. + "]. Annotation :");
40. If (method. isannotationpresent (myannotation3.class )){
42. Myannotation3 methodannotation = Method
43. . Getannotation (myannotation3.class );
45. Printmyannotation3 (methodannotation );
46. }
47. }
48. }
50. Private Static void printmyannotation3 (myannotation3 annotation3 ){
52. If (annotation3 = NULL ){
53. Return;
54. }
55. System. Out. println ("{value =" + annotation3.value ());
56. String multivalues = "";
58. For (string value: annotation3.multivalues ()){
59. Multivalues + = "," + value;
60. }
62. System. Out. println ("multivalues =" + multivalues );
64. System. Out. println ("number =" + annotation3.number () + "}");
65. }
66. }

 

 

Output:

 

 

-- Class annotations --
[Getmyannotation]. annotation:
{Value = Class getmyannotation
Multivalues =, 1, 2
Number = 0}
-- Fields annotations --
[Getmyannotation. testfield1]. annotation:
{Value = call testfield1
Multivalues =, 1
Number = 1}
-- Methods annotations --
[Getmyannotation. testmethod1]. annotation:
{Value = call testmethod1
Multivalues =, 1, 2
Number = 1}
[Getmyannotation. testmethod2]. annotation:
{Value = call testmethod2
Multivalues =, 3, 4, 5
Number = 0}

Jdk1.5APIS related to annotation provided in later versions:

 

Java code

1. Interface java. Lang. Reflect. annotatedelement {
3. Boolean isannotationpresent (class <? Extends annotation> annotationclass );
5. <T extends annotation> T getannotation (class <t> annotationclass );
7. Annotation [] getannotations ();
9. Annotation [] getdeclaredannotations ();
11. }

 

 

This interface is used to obtain annotation information attached to classes, constructor, field, method, and package.
Jdk1.5 has implemented the annotatedelement interface for several classes related to this:

 

Therefore, the reflection function can be used to dynamically parse the attached annotation information in the program.
Summary:
This article provides an example to illustrate how to dynamically parse annotation. You can use the Annotation Feature of Java to complete more complex functions.