Java retention annotations

retention annotations

Retention (reserved) Note that this type of annotation is retained at that stage. There are three values:
1.retentionpolicy.source--This type of annotations is preserved only at the source level and is ignored at compile time
2.retentionpolicy.class--This type of annotations is preserved at compile time and exists in the CLASS file, but the JVM ignores
3.retentionpolicy.runtime--This type of annotations will be retained by the JVM, so they can be read and used by the JVM or other code that uses the reflection mechanism at runtime.
Example 5 demonstrates the declaration of Retentionpolicy.runtime:

Example 1 for Java annotations:

Copy CodeThe code is as follows:
@Retention (Retentionpolicy.runtime)
Public @interface Test_retention {
String dotestretention ();
}

In this example, the @Retention (retentionpolicy.runtime) Note indicates that the test_retention annotation will be retained by the virtual machine so that it can be read by reflection at run time.

Conclusion

This article shows you how to make development easier by using the JDK5 annotation feature. Annotations do not directly affect the semantics of a program.  Development and deployment Tools can read these annotations in some way and process them, using a program that contains annotations to replace additional Java source files, XML documents, or other ancient artifacts. Annotations can be used to do the same thing with less code, and there is a better compile-time error detection mechanism. The purpose of the annotations is to spend less time focusing more on business logic rules in the diehard and useless details.

Definition of annotations:

The definition of the annotation uses the keyword @interface, and @rentention (ARG) or @target (args) in the line above, as in the following example:

@Rentention (Retentionpolicy.runtime)

Public @interface Annotation01 {

Defining a public final static property

.....

public abstract methods.

......

}

Common basic built-in annotations

@Override when we want to rewrite a method, add @override to the method, and when the name of our method goes wrong, the compiler will error. Defined as follows:

@Retention (Retentionpolicy.source)

Java uses @interface annotation{} to define an annotation @Annotation, and one annotation is a class.
@Override, @Deprecated, @SuppressWarnings 3 common annotations.
Annotations are equivalent to a mark, and adding annotations to a program is tantamount to adding some kind of markup to the program,
Javac compilers, development tools and other programs can use reflection to understand your class and the various elements have no markup, see what you have the mark, go to do the corresponding thing.

Java uses @interface annotation{} to define an annotation @Annotation, and one annotation is a class.
@Override, @Deprecated, @SuppressWarnings 3 common annotations.
Annotations are equivalent to a mark, and adding annotations to a program is tantamount to adding some kind of markup to the program,
Javac compilers, development tools and other programs can use reflection to understand your class and the various elements have no markup, see what you have the mark, go to do the corresponding thing.

Note @override is used on methods, when we want to rewrite a method, add @override to the method, when we approach
When the name is wrong, the compiler will error

Annotation @deprecated, which is used to indicate that a class's properties or methods are obsolete and do not want others to use in properties and methods
Modified with @deprecated,

Note @suppresswarnings is used to suppress warnings from the program, such as when no generics are used or the method is obsolete.

Annotation @retention can be used to modify annotations, which are annotations, called meta-annotations.
The retention annotation has an attribute value, which is of type Retentionpolicy, and enum Retentionpolicy is an enumeration type,
This enumeration determines how retention annotations should be maintained, and can also be understood as rentention with Rententionpolicy. Retentionpolicy has 3 values:CLASS RUNTIME SOURCE
Annotated with @retention (Retentionpolicy.class), which indicates that the information of the annotations is kept in the CLASS file (bytecode file) when the program is compiled, but is not read by the virtual machine at run time;
@retention (Retentionpolicy.source) modified annotations, indicating that the information of the annotations will be discarded by the compiler, will not be left in the class file, the information will only remain in the source file;
Annotated with @retention (Retentionpolicy.runtime), indicating that the information of the annotations is retained in the class file (bytecode file) when the program compiles, the virtual machine is kept at runtime,
So they can be read in a reflective way. Retentionpolicy.runtime allows you to read the annotation annotation information from the JVM so that it can be used when analyzing the program.

[Java]View PlainCopy

2. Package com.self;
4. Import java.lang.annotation.Retention;
6. Import Java.lang.annotation.RetentionPolicy;
10. @Retention (Retentionpolicy.runtime)
12. Public @interface Mytarget
14. { }
16. Define an annotated @MyTarget and modify it with Retentionpolicy.runtime;
18. Package com.self;
20. Import Java.lang.reflect.Method;
22. Public class Mytargettest
24. {
26. @MyTarget
28. public void DoSomething ()
30. {
32. System.out.println ("Hello World");
34. }
38. public static void Main (string[] args) throws Exception
40. {
42. method = Mytargettest.  Class.getmethod ("dosomething",null);
44. if (method.isannotationpresent (mytarget. Class)//True if annotation @mytarget is present on the DoSomething method
46. {
48. System.out.println (Method.getannotation (mytarget.   Class));
50. }
52. }
54. }
56. The above program prints:@com. Self.mytarget () and does not print if the Retentionpolicy value is not runtime.
60. @Retention (Retentionpolicy.source)
62. Public @interface Override
66. @Retention (Retentionpolicy.source)
68. Public @interface Suppresswarnings
72. @Retention (Retentionpolicy.runtime)
74. Public @interface Deprecated
76. As can be seen, only annotations @Deprecated can be read by the JVM at run time
80. You can define attributes in the annotations to see examples:
82. @Retention (Retentionpolicy.runtime)
84. Public @interface Myannotation
86. {
88. String Hello () default "Gege";
90. String World ();
92. int[] Array () default { 2, 4, 5, 6};
94. Enumtest.trafficlamp lamp ();
96. Testannotation lannotation () default @TestAnnotation (value = "ddd");
98. Class style () default String.   Class
100. }
102. In the above program, define an annotation @MyAnnotation, define 6 attributes, their name is:
104. Hello,world,array,lamp,lannotation,style.
106. Property Hello type is string, default value is Gege
108. Property world Type is string, no default value
110. Property array type is an array with default values of 2,4,5,6
112. Attribute lamp Type is an enumeration with no default value
114. The attribute lannotation type is annotated, the default value is @TestAnnotation, and the attribute in the annotation is the annotation
116. Property style type is class, default value is String type class type
120. Take a look at the following example: Defines a mytest class, with annotations @MyAnnotation adornments, annotations @MyAnnotation defined properties are assigned values
122. @MyAnnotation (hello = "Beijing", world="Shanghai", array={},lamp=trafficlamp.red,style=Int.Class)
124. Public class MyTest
126. {
128. @MyAnnotation (lannotation=@TestAnnotation (value="Baby"), world = "Shanghai", array={1,2, 3},lamp=trafficlamp.yellow)
130. @Deprecated
132. @SuppressWarnings ("")
134. public void output ()
136. {
138. System.out.println ("Output something!");
140. }
142. }
144. The information of the annotations is then read by reflection:
146. Public class Myreflection
148. {
150. public static void Main (string[] args) throws Exception
152. {
154. MyTest MyTest = new MyTest ();
156. class<mytest> C = MyTest.  class;
158. method = C.getmethod ("Output", new class[] {});
160. true if the MyTest class name has annotations @myannotation adornments
162. if (MyTest. Class.isannotationpresent (myannotation. Class))
164. {
166. System.out.println ("have annotation");
168. }
170. if (method.isannotationpresent (myannotation. Class))
172. {
174. Method.invoke (myTest, null); //Call the output method
176. //Get information on method annotations @myannotation
178. Myannotation myannotation = method.getannotation (myannotation.   Class);
180. String Hello = Myannotation.hello ();
182. String world = Myannotation.world ();
184. System.out.println (hello + "," + World); Print properties Hello and world values
186. System.out.println (Myannotation.array (). length); //Print Properties The length of array arrays
188. System.out.println (Myannotation.lannotation (). value ()); //Print the value of the attribute Lannotation
190. System.out.println (Myannotation.style ());
192. }
194. //Get all annotations on the output method, of course, are retentionpolicy.runtime modified
196. annotation[] annotations = method.getannotations ();
198. For (Annotation annotation:annotations)
200. {
202. System.out.println (Annotation.annotationtype (). GetName ());
204. }
206. }
208. }
210. The above program prints:
212. have annotation
214. Output something!
216. Gege, Shanghai
218. 3
220. Baby
222. Class Java.lang.String
224. Com.heima.annotation.MyAnnotation
226. java.lang.Deprecated
230. If there is an attribute name called value in the annotation, you can omit the property name from being applied.
232. Visible,in the @Retention (retentionpolicy.runtime) annotation, retentionpolicy.runtime is the annotation attribute value, the property name is value,
234. The return type of the property is Retentionpolicy, as follows:
236. Public @interface Mytarget
238. {
240. String value ();
242. }
244. This can be used:
246. @MyTarget ("AAA")
248. public void DoSomething ()
250. {
252. System.out.println ("Hello World");
254. }
258. Annotation @Target is also a meta-annotation used to modify annotations, which has an attribute ElementType is also an enumeration type.
260. Value: Annotation_type CONSTRUCTOR FIELD local_variable METHOD Package PARAMETER TYPE
262. An annotated note such as @Target (Elementtype.method) indicates that the annotation can only be used to decorate the method.
264. @Target (Elementtype.method)
266. @Retention (Retentionpolicy.runtime)
268. Public @interface Mytarget
270. {
272. String value () default "hahaha";
274. }
276. If the @MyTarget modified on the class, then the program error, such as:
278. @MyTarget
280. Public class Mytargettest
282. Most of the annotations are used in the development framework, so much for the annotations to learn, thank you.
     1. This article turns from http://blog.csdn.net/liuwenbo0920/article/details/7290586/

Java retention annotations