Java annotation and code application examples

Annotations can eliminate sample code, make the source code more readable, and provide higher-level error checks. From EJB3 to JUnit4, it is used everywhere. This article will show you how to use it.

Java 5 introduced Annotations to Java, and its use quickly became an indispensable part of modern Java development. Before officially introducing it, let's take a look at why we need to invent an annotation, which is very worthwhile.

Since the birth of Java, people have been solving some problems that they ignored at the beginning: lack of metadata and lack of ability to embed code other than Java into Java source code files. When Java was available, the JavaDoc launched to address these problems finally made it complete. JavaDoc uses the concept of specifically marking comments in the Code, so that it can extract additional information, specifically the document, and convert it into a familiar JavaDoc document. This is a simple technology that everyone can use. First, there will be Doclet to allow people to expand the output of documents. Then Xdoclet, which uses JavaDoc to generate code like a tag, makes the entire process easy. This part is a response to the complexity of J2EE. J2EE originally relied on a lot of sample code (boilerplate code) to bundle objects into the J2EE framework. However, these solutions have some problems. First, the markup in the annotation never enters the final source code, so you cannot find it during runtime unless you generate code to reflect the markup. Secondly, it will add the entire preprocessing layer (ideally, it should be) to a simple compilation process. Finally, annotation-based markup is not easy to check during compilation, nor can it be easily checked by many ides. If you misspell the annotation, the compiler will not notice it, the compiler will only focus on the tags whose names know the exact name.

Java has added annotations to solve all these problems. Annotation is a native metadata tag for Java. Their input is strictly similar to other parts of the Java language and can be identified by reflection, making it easier for IDE and compiler writers to manage them. Now let's look at some annotated code. We start with BaseExample, which is a simple class with only one method -- myMethod:

Public class BaseExample {

Public BaseExample (){}

Public void myMethod (){

System. out. println ("This is the BaseExample ");

}

}

Now we want to extend BaseExample and replace myMethod. The following is the Example1 code for completing this task:

Public class Example1 extends BaseExample {

Public Example1 (){}

@ Overridepublic void myMethod (){

System. out. println ("This is the Example1 ");

}

}

In this way, we have the first comment on myMethod -- @ Override. This is one of a series of built-in annotations. @ Override indicates that "a method must replace one of its superclasses. If this is not done, something goes wrong and the compiler produces an error ". Without @ Override, the code will still work normally, but assume that someone modifies BaseExample so that myMethod has a parameter. If you do not use the @ Override annotation, the code will still be compiled, hiding the problem that subclass does not replace the superclass method. If @ Override exists, you will see an error during compilation.

You may think that "Is it possible that the Language extension does not solve this problem, and additional keywords may exist?" Yes, it may have implemented this, however, this not only does not bring any flexibility to the language, but also causes many source code compatibility problems. This method of annotation avoids changing the Java language itself (in addition to adding @ markup, of course), and can also be placed in different parts of the code, not just in the markup method.

Another thing about annotation is that you can create your own annotation tag, which is exactly what we will discuss right away. Think about the following question: we have some simple Java Beans programs with different string fields. We hope to have some common form display code that can correctly mark these fields with other display prompts (such as width. Now we can write a super class that can extract the data, for example, from a static array with some static support methods in each class, but this also means to force code layering. Using annotations is much easier. Now let's start by defining the FormLabel annotation in FormLabel. java:

Import java. lang. annotation .*;

@ Retention (RetentionPolicy. RUNTIME)

@ Target (ElementType. METHOD)

Public @ interface FormLabel {String label ();

Int width () default 40;

}

The first thing you should note is that Java uses some of its built-in annotations to determine the annotation: @ Retention and @ Target. @ Retention is used to define how long the RetentionPolicy value annotation can survive during build-run. Here we use RUNTIME, which means that the annotation we define will be retained in the code during RUNTIME. RetentionPolicy. SOURCE will be used for an annotation that we want to use by the compiler and then discard. RetentionPolicy. CLASS keeps them in the generated CLASS file, but can be accessed by the Java Virtual Machine (JVM) during runtime.

By default, you can apply annotations anywhere in your code. @ Target annotation allows you to restrict it to a specific part of the code. In this article, we aim at ElementType. METHOD, which means it can only be associated with methods. Other ElementTypes include CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PACKAGE, PARAMETER, and TYPE. Each annotation can be restricted to Java language elements of this TYPE. For example, setting the TYPE option only allows the annotation to be defined. For example:

@ OurAnnotation

Public class OurAnnotatedClass {...

It is worth noting that the @ Target annotation can accept a single ElementType or an ElementType array, if you want to restrict the annotation to a series of language elements.
The following part is the definition of the annotation interface. This is like a common interface declaration, except that we use @ interface to mark it as an annotation. In this interface, we then define the annotation method, just as we want to use the abstract method on the information associated with the annotation, so we have the String label (), it is used for a string attribute called label. If there is no method, the annotation can only be used for "marking", and the @ Overrides annotation is an example. If you only have one attribute, it is best to name it "value", because it works best when an annotation with an unnamed parameter is set. The property can also have default values, such as "int width () de






Fault 40; "is an integer attribute with a default value of 40.

This is the annotation definition. Now we can use it in the code. The following SimpleData class uses it.

Public class SimpleData {

Private String firstname;

Private String lastname;

Private String postcode;

Public SimpleData (){}

@ FormLabel (label = "First Name ")

Public String getFirstname () {return firstname ;}

Public void

SetFirstname (String firstname) {this. firstname = firstname ;}

@ FormLabel (label = "Last Name", width = 80)

Public String getLastname () {return lastname ;}

Public void setLastname (String lastname ){

This. lastname = lastname;

}

@ FormLabel (label = "Postal code", width = 10)

Public String getPostcode () {return postcode ;}

Public void setPostcode (String postcode ){

This. postcode = postcode;

}

}

Of course, if we don't look for comments, they won't make any difference in code execution. All we need is to use the annotation method during running; we use the Reflection API to achieve this purpose. Now let's create a simple processForm method that can search for comments in any object.

Public void processForm (Object o ){

For (Method m: o. getClass (). getMethods ()){

We will define all methods in the class of the object passed to the method. Now, we need to check each method to see if they have FormLabel annotations and whether a String is returned. (To briefly illustrate the problem, we will return more code for all the results ):

If (m. isAnnotationPresent (FormLabel. class )&&

M. getReturnType () = String. class ){

Now we can use the getAnnotation () Method of Method to extract the FormLabel annotation:

FormLabel formLabel =

M. getAnnotation (FormLabel. class );

Now we execute the method to obtain its string value, and access the annotation attribute through the method defined in the annotation interface. Below we will print them out:

Try {

String value = (String) m. invoke (o );

String label = formLabel. label ();

Int width = formLabel. width ();

System. out. printf ("% s [% d]: % s", label, width, value );

} Catch (IllegalArgumentException ex ){

Ex. printStackTrace ();

}

Catch (IllegalAccessException ex ){

Ex. printStackTrace ();}

Catch (InvocationTargetException ex ){

Ex. printStackTrace ();

}

}

}

}

Now we can create new classes containing @ FormLabel annotations and pass them to the processForm method. This is the basis for accessing your own annotations during running.

Now, let's look back at other comments in Java 5. The first is the compiler instruction -- @ Deprecated and @ SuppressWarnings. @ Deprecated indicates a method as a negative enhancement method. It is not recommended to use it in new code to prevent future deletion. @ Deprecated can be used to generate a warning from the compiler.

@ SuppressWarnings will prevent the compiler from warning you in the closed code element, so you can use @ SuppressWarnings at the beginning of the class definition or for specific methods. It can contain parameters to specify the type of the error to be canceled, for example:

@ SuppressWarnings ("unchecked ")

Public List getList (){

List l =