Java Annotations Annotations o o o Annotations are

Java Annotations

Annotations o o o Annotations are metadata or data about data. An annotation indicates that the declared element should be processed in some special way by a compiler, development tool, deployment tool, or during runtime. Annotation-based development is certainly one of the latest Java development trends Annotations can be applied to several Java Elements like, n package declarations, n class, n constructors, n methods, n fields, n Variables and etc.

The Basics o Example to Define an Annotation (Annotation type) public @interface My. Annotation { String do. Something(); } o Example to Annotate Your Code (Annotation) My. Annotation (do. Something="What to do") public void mymethod() {. . . . }

Structure of Java Compiler Source File Type Checker Parser Class File class C { @Non. Null Object field; C(@Non. Null Object p) { field = p; } @Non. Null Object get() { return field; } Class File Writer Comments } Error

Structure of Java 5 Compiler Source File Type Annotation Class File Checker Writer Parser Class File class C { @Non. Null Object field; C(@Non. Null Object p) { field = p; } @Non. Null Object get() { return field; } } Program with annotations Error Annotation Checker Plugins

Annotation Types o o o Marker Single-Element Full-value or multi-value

Marker annotations take no parameters. They are used to mark a Java element to be processed in a particular way. o o Example: public @interface My. Annotation { } Usage: @My. Annotation public void mymethod() {. . }

Single-Element o o Single-element, or single-value type, annotations provide a single piece of data only. This can be represented with a data=value pair or, simply with the value (a shortcut syntax) only, within parenthesis. Example: public @interface My. Annotation { String do. Something(); } o Usage: @My. Annotation ("What to do") public void mymethod() {. . }

Full-value or multi-value o Full-value type annotations have multiple data members. o Example: public @interface My. Annotation { String do. Something(); int count; String date(); } o Usage: @My. Annotation (do. Something= "What to do", count=1, date="09 -09 -2005") public void mymethod() {. . }

The Built-In Annotations o o Java defines seven built-in annotations. Four are imported from java. lang. annotation o o o @Retention, @Documented, @Target, and @Inherited. Three are included in java. lang. n n n @Override, @Deprecated, and @Suppress. Warnings.

Simple Annotations (or) Standard Annotations o There are three types of simple annotations provided by JDK 5. They are: n n n Override Deprecated Suppresswarnings

Override o o Override is a Marker Annotation type that can be applied to a method to indicate to the Compiler that the method overrides a method in a Superclass. This Annotation type guards the programmer against making a mistake when overriding a method. For eg The syntax ---@Override Example Program: class Parent { public float calculate (float a, float b) { return a * b; } } Whenever you want to override a method, declare the Override annotation t ype before the method: public class Child extends Parent { @Override public int calculate (int a, int b) { return (a + 1) * b; } }

The Deprecated annotation o o o This annotation indicates that when a deprecated program element is used, the compiler should warn you about it. Example 2 shows you the deprecated annotation. The syntax --- @Deprecated Example : public class Deprecated. Test { @Deprecated public void serve() { } } If you use or override a deprecated method, you will get a warning at compile time. public class Deprecated. Test 2 { public static void main(String[] args) { Deprecated. Test test = new Deprecated. Test(); test. serve(); } }

The Suppresswarnings annotation o o o Suppress. Warnings is used to suppress compiler warnings. You can apply @Suppress. Warnings to types, constructors, methods, fields, parameters, and local variables. The syntax --- @Suppress. Warnings Eg: import java. util. Date; public class Main { @Suppress. Warnings(value={"deprecation"}) public static void main(String[] args) { Date date = new Date(2009, 9, 30); } } System. out. println("date = " + date);

Documentation o public class Generation 3 List extends { // // Author: John Doe Date: 3/17/2002 Current revision: 6 Last modified: 4/12/2004 By: Jane Doe Reviewers: Alice, Bill, Cindy class code goes here } o Using Java Annotation n } n ) @Documented @interface Class. Preamble { String author(); String date(); int current. Revision() default 1; String last. Modified() default "N/A"; String last. Modified. By() default "N/A"; String[] reviewers(); @Class. Preamble ( author = "John Doe", date = "3/17/2002", current. Revision = 6, last. Modified = "4/12/2004", last. Modified. By = "Jane Doe", reviewers = {"Alice", "Bob", "Cindy"}

The Target annotation o o o o @Target(Element. Type. TYPE)—can be applied to any element of a class @Target(Element. Type. FIELD)—can be applied to a field or property @Target(Element. Type. METHOD)—can be applied to a method level annotation @Target(Element. Type. PARAMETER)—can be applied to the parameters of a method @Target(Element. Type. CONSTRUCTOR)—can be applied to constructors @Target(Element. Type. LOCAL_VARIABLE)—can be applied to local variables @Target(Element. Type. ANNOTATION_TYPE)—indicates that the declared type itself is an

Java Annotation in Struts 2 o Two mechanisms for declaring your architecture n n XML Java annotations

Design

Struts 2 Feature o "zero configuration" n n Convention over configuration: this means that if you follow some standard naming conventions and place your Struts 2 actions in the "correct" location, then Struts will take care of finding them and configuring your application for you — meaning that you will have far less manual configuration. Java Annotations

web. xml o <? xml version="1. 0" encoding="UTF-8"? > <web-app xmlns: xsi="http: //www. w 3. org/2001/XMLSchema-instance" xmlns="http: //java. sun. com/xml/ns/javaee" xmlns: web="http: //java. sun. com/xml/ns/javaee/web-app_2_5. xsd" xsi: schema. Location="http: //java. sun. com/xml/ns/javaee/web-app_2_5. xsd" id="Web. App_ID" version="2. 5"> <display-name>Hello. Struts 2 <!-- Define our Struts 2 Servlet Filter --> <filter-name>struts 2</filter-name> <filter-class>org. apache. struts 2. dispatcher. Filter. Dispatcher</filter-class> <init-param> <param-name>action. Packages</param-name> <param-value>com. geekcap. struts 2</param-value> </init-param> </filter> <!-- Map all requests to the Struts 2 servlet --> <filter-mapping> <filter-name>struts 2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <welcome-file-list> <welcome-file>index. html</welcome-file> </welcome-file-list> </web-app>

How it works o For Eg: n We are going to have a package name as com. greekcap. struts 2 n And the Sub-Package name as action o o o Place the class files inside the Action Package http: //localhost: 8080/Hello. Struts 2/action/<actionname>. action The next step is to define the action name. Action classes can be defined in two ways: n Configuration: implement the Action interface n Convention: name your class so that it ends with the word Action

How Filter. Dispatcher will Identify the Class o the Action interface, or o o extends the Action. Support class, and provide an execute() method that returns a String, then the Filter. Dispatcher will identify your class On the other hand, you are not required to implement the Action interface if your class name ends in Action and it provides an execute() method that returns a String.

When the Filter. Dispatcher finds such a class, it defines the action name as follows: o o Remove the word "Action" from the end of the class name Convert the first character in the class name to lower case n n http: //localhost: 8080/Hello. Struts 2/actio n/<action-name>. action http: //localhost: 8080/Hello. Struts 2/actio n/hello. action

Hello. Action. java o package com. geekcap. struts 2. action; import org. apache. struts 2. config. Result; @Result(name="success", value="/hello. jsp") public class Hello. Action { private String name; public String execute() { return "success"; } } public String get. Name() { return name; } public void set. Name(String name) { this. name = name; }

1. hello. Form. jsp <html><body> <s: form action="hello"> <s: textfield name="name“ label="Your name"/> <s: submit/> </s: form> </body></html> 2. hello. jsp <html> <body> <h 4>Hello, <s: property value="name"/> !</h 4> </body> </html>

Struts 2 Validation Using Java Annotation o package net. roseindia; import com. opensymphony. xwork 2. Action. Support; mport com. opensymphony. xwork 2. validator. annotations. *; @Validation public class Annotation. Action extends Action. Support { private String username = null; private String password = null; o o @Required. String. Validator(message="Supply name") public String get. Username() { return username; } public void set. Username(String value) { username = value; } @Required. String. Validator(message="Supply password") public String get. Password() { return password; } o o public void set. Password(String value) { password = value; } public String execute() throws Exception { System. out. println("Validating login"); if(!get. Username(). equals("Admin") || !get. Password(). equals("Admin")){ add. Action. Error("Invalid user name or password! Please try again!"); return ERROR; } else{ return SUCCESS; } }}

Thank You