GeezerVisonThe World Wide Web, restored to 800 pixels of glory. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Home|About|Gaming cabinet|Archives|How it works|Starter sites | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
GeezerVison is showing en.wikipedia.org — Java annotation - Wikipedia In the Java computer programming language, an annotation is a form of syntactic metadata that can be added to Java source code, like an attribute.[1] Classes, methods, variables, parameters and Java packages may be annotated. Like Javadoc tags, Java annotations can be read from source files. Unlike Javadoc tags, Java annotations can also be embedded in and read from Java class files generated by the Java compiler. This allows annotations to be retained by the Java virtual machine at run-time and read via reflection.[2] It is possible to create meta-annotations out of the existing ones in Java.[3] HistoryThe Java platform has various ad-hoc annotation mechanisms—for example, the Annotations became available in the language itself beginning with version 1.5 of the Java Development Kit (JDK). The Built-in annotationsJava defines a set of annotations that are built into the language. Of the seven standard annotations, three are part of java.lang, and the remaining four are imported from
In Jakarta EE (formerly Java Platform, Enterprise Edition), the following annotations also exist in
There was previously an annotation, ExampleBuilt-in annotationsThis example demonstrates the use of the 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() { // Compile-time error due to typo: should be getType() not gettype(). return "Cat"; } } Custom annotationsAnnotation type declarations are similar to normal interface declarations. An at-sign (@) precedes the keyword "interface". // @Twizzle is an annotation to method toggle(). @Twizzle public void toggle() { } // Declares the annotation Twizzle. public @interface Twizzle { } Annotations may include a set of key-value pairs, which are modeled as methods of the annotation type. Each method declaration defines an element of the annotation type. Method declarations must not have any parameters or a throws clause. Return types are restricted to primitives, // 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: import java.lang.annotation.*; @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 Annotations are widely used by frameworks as a way of conveniently applying behaviors 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).[11] For instance, the library Project Lombok makes extensive usage of annotations to reduce boilerplate.[12] The following, for example, is an annotated Jakarta Persistence data class: package org.wikipedia.examples; import java.io.Serializable; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GenerationType; import jakarta.persistence.GeneratedValue; import jakarta.persistence.Id; import jakarta.persistence.Table; @Entity // Declares this an entity bean @Table(name = "people") // Maps the bean to SQL table "people" public 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; } } The annotations are not method calls and will not, by themselves, do anything. Rather, the class object is passed to the Jakarta Persistence implementation at run-time, which then extracts the annotations to generate an object–relational mapping. A complete example is given below: package org.wikipedia.examples.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 "2011-07-08"; } package org.wikipedia.examples.annotation; public @interface UnderConstruction { String owner() default "Patrick Naughton"; String value() default "Object is Under Construction."; String createdBy() default "Mike Sheridan"; String lastChanged() default "2011-07-08"; } Then, using Jakarta Faces: package org.wikipedia.examples.validators; import jakarta.faces.application.FacesMessage; import jakarta.faces.component.UIComponent; import jakarta.faces.context.FacesContext; import jakarta.faces.validator.Validator; import jakarta.faces.validator.ValidatorException; import org.wikipedia.examples.annotation.UnderConstruction; import org.wikipedia.examples.annotation.Unfinished; import org.wikipedia.examples.annotation.Unfinished.Priority; import org.wikipedia.examples.util.Util; @UnderConstruction(owner = "Jon Doe") 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); } } } ProcessingWhen 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. However, annotation processors cannot modify the annotated code itself. (Code modifications may be implemented using methods beyond the Java Language Specification.) The Java compiler conditionally stores annotation metadata in the class files, if the annotation has a In addition to processing an annotation using an annotation processor, a Java programmer can write their own code that uses reflection to process the annotation. Java SE 5 supports a new interface that is defined in the The package org.wikipedia.examples.annotation; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; // This is the annotation to be processed // Default for Target is all Java Elements // Change retention policy to RUNTIME (default is CLASS) @Retention(RetentionPolicy.RUNTIME) public @interface TypeHeader { // Default value specified for developer attribute String developer() default "Unknown"; String lastModified(); String[] teamMembers(); int meaningOfLife(); } // This is the annotation being applied to a class @TypeHeader( developer = "Bob Bee", lastModified = "2013-02-12", teamMembers = { "Ann", "Dan", "Fran" }, meaningOfLife = 42 ) public class SetCustomAnnotation { // Class contents go here } package org.wikipedia.examples; // This is the example code that processes the annotation import java.lang.annotation.Annotation; import java.lang.reflect.AnnotatedElement; public class UseCustomAnnotation { public static void main(String[] args) { Class<SetCustomAnnotation> classObject = SetCustomAnnotation.class; readAnnotation(classObject); } static void readAnnotation(AnnotatedElement element) { try { System.out.println("Annotation element values: %n"); if (element.isAnnotationPresent(TypeHeader.class)) { // getAnnotation returns Annotation type Annotation singleAnnotation = element.getAnnotation(TypeHeader.class); TypeHeader header = (TypeHeader) singleAnnotation; System.out.printf("Developer: %s%n", header.developer()); System.out.printf("Last Modified: %s%n", header.lastModified()); // teamMembers returned as String[] System.out.print("Team members: "); for (String member : header.teamMembers()) { System.out.printf("%s, ", member); } System.out.println(); System.out.println("Meaning of Life: %s%n", header.meaningOfLife()); } } catch (Exception e) { e.printStackTrace(); } } } Libraries such as JUnit use annotation processing to generate unit tests. See also
References
External links
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| You are visitor 01402503 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |