Pular para o conteúdo

Conheça Walt Disney World

Java annotation

An annotation, in the Java computer programming language, is a special form of syntactic metadata that can be added to Java source code.[1] Classes, methods, variables, parameters and packages may be annotated. Unlike Javadoc tags, Java annotations can be reflective in that they can be embedded in class files generated by the compiler and may be retained by the Java VM to be made retrievable at run-time[2] It is possible to create meta-annotations out of the existing ones in Java, which makes this concept more sophisticated than in other languages like C#.[3]

Contents

History

The Java platform has had various ad-hoc annotation mechanisms—for example, the transient modifier, or the @deprecated javadoc tag. The general purpose annotation (also known as metadata) facility was introduced to the Java Community Process as JSR-175 in 2002 and approved in September 2004.[4] Annotations became available in the language itself beginning with version 1.5 of the JDK. A provisional interface for compile-time annotation processing was provided by the apt tool in JDK version 1.5, and was formalized through JSR-269 and integrated into the javac compiler in version 1.6.

Built-In Annotations

Java defines a set of annotations that are built into the language.[5]

Annotations applied to java code:

  • @Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.
  • @Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.
  • @SuppressWarnings - Instructs the compiler to suppress the compile time warnings specified in the annotation parameters

Annotations applied to other annotations:

  • @Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at runtime through reflection.
  • @Documented - Marks another annotation for inclusion in the documentation.
  • @Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to
  • @Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

Example

This example shows the use of the @Override annotation. It instructs the compiler to check parent classes for matching functions. In this case, an error is generated that the Cat's gettype() function does not in fact override Animal's getType() as desired, but instead declares a new function due to the name mismatch.

Built-in annotations

public class Animal {
 
    public void speak() {
    }
 
    public String getType() {
       return "Generic animal";
    }
}
 
public class Cat extends Animal {
 
    @Override
    public void speak() { // This is a good override.
       System.out.println("Meow."); 
    }
 
    @Override
    public String gettype() { // throws compile warning due to mistyped name.
       return "Cat";
    }
}

Custom annotations

  // @Twizzle is an annotation to method toggle().
  @Twizzle
  public void toggle() {
  }
 
  // Declares the annotation Twizzle.
  public @interface Twizzle {
  }

Annotations may include an optional list of key-value pairs:

  // Same as: @Edible(value = true)
  @Edible(true)
  Item item = new Carrot();
 
  public @interface Edible {
    boolean value() default false;
  }
 
  @Author(first = "Oompah", last = "Loompah")
  Book book = new Book();
 
  public @interface Author {
    String first();
    String last();
  }

Annotations themselves may be annotated to indicate where and when they can be used:

  @Retention(RetentionPolicy.RUNTIME) // Make this annotation accessible at runtime via reflection.
  @Target({ElementType.METHOD})       // This annotation can only be applied to class methods.
  public @interface Tweezable {
  }

The compiler reserves a set of special annotations (including @Deprecated, @Override and @SuppressWarnings) for syntactic purposes.

Annotations are often used by frameworks as a way of conveniently applying behaviours to user-defined classes and methods that must otherwise be declared in an external source (such as an XML configuration file) or programmatically (with API calls). The following, for example, is an annotated EJB 3.0 data class:

  @Entity                                           // Declares this an entity bean
  @Table(name = "people")                           // Maps the bean to SQL table "people"
  class Person implements Serializable {
    @Id                                             // Map this to the primary key column.
    @GeneratedValue(strategy = GenerationType.AUTO) // Database will generate new primary keys, not us.
    private Integer id;
 
    @Column(length = 32)                            // Truncate column values to 32 characters.
    private String name;
 
    public Integer getId() {
      return id;
    }
 
    public void setId(Integer id) {
      this.id = id;
    }
 
    public String getName() {
      return name;
    }
 
    public void setName(String name) {
      this.name = name;
    }
  }

A complete example is given below:

package com.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD,
 ElementType.CONSTRUCTOR,ElementType.ANNOTATION_TYPE,
 ElementType.PACKAGE,ElementType.FIELD,ElementType.LOCAL_VARIABLE})
@Inherited
 
public @interface Unfinished {
        public enum Priority { LOW, MEDIUM, HIGH }
        String value();
        String[] changedBy() default "";
        String[] lastChangedBy() default "";
        Priority priority() default Priority.MEDIUM;
        String createdBy() default "James Gosling";
        String lastChanged() default "08/07/2011";
}

package com.annotation;
 
public @interface UnderConstruction {
        String owner() default "Patrick Naughton";
        String value() default "Object is Under Construction.";
        String createdBy() default "Mike Sheridan";
        String lastChanged() default "08/07/2011";
}

package com.validators;
 
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
 
import com.annotation.UnderConstruction;
import com.annotation.Unfinished;
import com.annotation.Unfinished.Priority;
import com.util.Util;
 
@UnderConstruction(owner="Navin Gujarish")
public class DateValidator implements Validator{
 
        public void validate(FacesContext context, UIComponent component, Object value)
                        throws ValidatorException 
        {
                String date = (String) value;
                String errorLabel = "Please enter a valid date.";
                if(!component.getAttributes().isEmpty())
                {
                        errorLabel = (String) component.getAttributes().get("errordisplayval");
                }
 
                if(!Util.validateAGivenDate(date))
                {
                        @Unfinished(changedBy = "Steve"
                                ,value="whether to add message to context or not, confirm"
                                ,priority=Priority.HIGH
                        )
                        FacesMessage message = new FacesMessage(); 
                        message.setSeverity(FacesMessage.SEVERITY_ERROR); 
                        message.setSummary(errorLabel); 
                        message.setDetail(errorLabel); 
                        throw new ValidatorException(message); 
                }
        }
}

The annotations are not method calls and will not, by themselves, do anything. Rather, the class object is passed to EJB implementation at run-time, which then extracts the annotations to generate an ORM.

Processing

When Java source code is compiled, annotations can be processed by compiler plug-ins called annotation processors. Processors can produce informational messages or create additional Java source files or resources, which in turn may be compiled and processed, and also modify the annotated code itself.[6] The Java compiler conditionally stores annotation metadata in the class files if the annotation has a RetentionPolicy of CLASS or RUNTIME. Later, the JVM or other programs can look for the metadata to determine how to interact with the program elements or change their behavior.

References

  1. ^ "Annotations". Sun Microsystems. http://download.oracle.com/javase/1,5.0/docs/guide/language/annotations.html. Retrieved 2011-09-30. .
  2. ^ Sun Microsystems (2005). Java(TM) Language Specification (3rd ed.). Prentice Hall. ISBN 0-321-24678-0. http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html .
  3. ^ [|Dare Obasanjo] (2007). "A COMPARISON OF MICROSOFT'S C# PROGRAMMING LANGUAGE TO SUN MICROSYSTEMS' JAVA PROGRAMMING LANGUAGE: Metadata Annotations". Dare Obasanjo. Archived from the original on 2007. http://stackoverflow.com/questions/1327544/what-is-the-equivalent-of-javas-final-in-c. Retrieved 2012-09-06. 
  4. ^ Coward, Danny (2006-11-02). "JSR 175: A Metadata Facility for the JavaTM Programming Language". Java Community Process. http://www.jcp.org/en/jsr/detail?id=175#2. Retrieved 2008-03-05. 
  5. ^ http://www.java2s.com/Tutorial/Java/0020__Language/TheBuiltInAnnotations.htm
  6. ^ Replacing illegal access calls with the equivalent Java Reflection API calls processing @Test annotation, April 16, 2011

See also

External links

fonte: https://web.archive.org/web/20121011110353/https://en.wikipedia.org/wiki/Java_annotation
Personal tools
  • Create account
  • Log in
Namespaces

Variants
Actions
Navigation
Toolbox
Print/export
Marcações: