Java Annotation help needed

[aditee sharma]

Hi,
I am trying to learn Java Annotations.
This is an article from Sun website that explains using Annotations to add Validity Constraints to JavaBeans Properties.
The article explains the existing validation techniques available (viz. XML Schema, Property Descriptor etc.) and lists all their respective merits and demerits, eventually making the case for Annotations.
In short, what I expected Annotations to do in this case is to shorten the code and make it far more readable allowing the developer to focus on "what" rather than how.
That was until I tried the very 1st example that tries to constrain the length of a field to a maximum of 20:
Custom Annotation code (MaxLength):

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MaxLength {
int value();
}

and the test class code is :

 
public class Address {
 
    @MaxLength(20)
    public String street;
 
 public static void main(String[] args) {
        Address a = new Address ();
       a.setStreet(args[0]);
       System.out.println(a.getStreet());
     
    }
}
 
 private void setStreet(String street){
    this.street = street;
    }
 public String getStreet(){
 return this.street;
 }

However, when I run this code, it simply does not work.
Meaning when an argument of "dfsfjvdvjfdvjhbvdjhvbdjvbdvjbdfvhjbcdjkvndvjn" (say, string of length more than 20) is supplied at run time, the regular output is obtained even after adding the annotation.
Can anyone help me please?

[Gregg Bolinger]

Annotations don't do anything by themselves. They are markup. Its up to you to find classes and methods marked with your annotation via the Reflection API and do the validation or whatever it is your annotation's purpose might be.

[aditee sharma]

Thanks for the reply.
If we have to write the code for validation, then how are Annotations an advantage over the PropertyDescriptor as explained in the article?
Having to write the code, they actually seem confusing to me, because while the validation code is inside one class, the Annotation itself is defined in another one.So, it seems all we achieved by Annotations is shifting from a xml file to a java file.
Having worked the xml way for years now, can you please give me a good reason to switch to Annotations?
Thanks in anticipation.

[Gregg Bolinger]

Having worked the xml way for years now, can you please give me a good reason to switch to Annotations?

No. But I can tell you that some people prefer it. Others don't. I like annotations when used sparingly. For example, one of my favorite web application frameworks is Stripes. I can do something like this:

@UrlBinding("/user/{$event}/{user.id}")
public class UserAction implements ActionBean {
 
  @ValidateNestedProperties({
      @Validate(field="username", required=true),
      @Validate(field="password", required=true)
  })
  private User user;
 
  // other code goes here
 
}

So by going to this one action class I can see what the url pattern might be and I can see what validation is taking place for the User object. I know that user.username and user.password are both required. Now consider having this information in an XML file. Would it still work? Sure. But I don't care to jump from java to XML just to figure this information out. Now consider something like this:

@ResultClass (Company.class)
  @ConstructorResults({
      @Result(property="id", column="C.COMP_ID"),
      @Result(property="name", column="C.NAME")
      })
  @PropertyResults({
      @Result(property="departments.id", column="D.DEPT_ID"),
      @Result(property="departments.name", column="D.NAME"),
      @Result(property="departments.employee.id", column="E.EMP_ID"),
      @Result(property="departments.employee.firstName", column="E.FIRST_NAME"),
      @Result(property="departments.employee.lastName", column="E.LAST_NAME")
      })
  @Collections ({
      @Collection(type=Department.class, property="departments", groupBy="id"),
      @Collection(type=Employee.class, property="departments.employees", groupBy="departments.id")
      })
  @Select("SELECT #id, #name, " +
          "#departments.id, #departments.name, " +
          "#departments.employees.id, #departments.employees.firstName, " +
          "#departments.employees.lastName " +
          "FROM COMPANY C, DEPARTMENT D, EMPLOYEE E " +
          "WHERE D.DEPT_ID = E.DEPT_ID " +
          "AND C.COMP_ID = D.COMP_ID")
  List<Company> selectAllCompaniesWithJoin();

Taken from here. That is utterly horrid and I'd never want to write something like that in Java code.

My point is annotations, for me, are good when used correctly, bad when used inappropriately. I know this might not really answer all your concerns but its kind of something you have to decide for yourself.

[aditee sharma]

Thanks for taking so much effort to drive the point home.
So, can one generalize that while Annotations may be beneficial for simple purposes , they may not serve for more complex ones ?

[Martijn Verburg]

Well it's up to each individual developer but I agree with Gregg 100%. Annotations should aid the understanding of the code flow, not make it unintelligible