Use Annotation or not in java

Use Annotation or not in java

Pros and Cons:

Pros:

1, reduce configuration xml files

2, readable by self-documenting

Cons:

1, it adds deployment context to classes, which should be generic enough.

2, interfere with design principles such as IOC and dependency injection, because you need to introduce imports

Usage (annotation works only when handled by related annotation processor):

• Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
• Compiler-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
• Runtime processing — Some annotations are available to be examined at runtime.

  1  import  java.io.IOException;
  2  import  java.io.PrintStream;
  3  import  java.lang.reflect.AnnotatedElement;
  4  import  java.lang.annotation.Annotation;
  5 
  6  import  java.util.Date;
  7  import  java.lang.annotation.Documented;
  8  import  java.lang.annotation.Inherited;
  9  import  java.lang.annotation.Retention;
 10  import  java.lang.annotation.RetentionPolicy;
 11 
 12  public   class  ReflectionTester {
 13 
 14     public  ReflectionTester() {
 15    }
 16 
 17     public   void  testAnnotationPresent(PrintStream out)  throws  IOException {
 18      Class c  =  Super. class ;
 19       boolean  inProgress  =  c.isAnnotationPresent(InProgress. class );
 20       if  (inProgress) {
 21        out.println( " Super is In Progress " );
 22      }  else  {
 23        out.println( " Super is not In Progress " );
 24      }
 25    }
 26 
 27     public   void  testInheritedAnnotation(PrintStream out)  throws  IOException {
 28      Class c  =  Sub. class ;
 29       boolean  inProgress  =  c.isAnnotationPresent(InProgress. class );
 30       if  (inProgress) {
 31        out.println( " Sub is In Progress " );
 32      }  else  {
 33        out.println( " Sub is not In Progress " );
 34      }
 35    }
 36 
 37     public   void  testGetAnnotation(PrintStream out) 
 38       throws  IOException, NoSuchMethodException {
 39 
 40      Class c  =  AnnotationTester. class ;
 41      AnnotatedElement element  =  c.getMethod( " calculateInterest " , 
 42                                     float . class ,  float . class );
 43 
 44      GroupTODO groupTodo  =  element.getAnnotation(GroupTODO. class );
 45      String assignedTo  =  groupTodo.assignedTo();
 46 
 47      out.println( " TODO Item on Annotation Tester is assigned to: ' "   +  
 48          assignedTo  +   " ' " );
 49    }
 50 
 51     public   void  printAnnotations(AnnotatedElement e, PrintStream out)
 52       throws  IOException {
 53 
 54      out.printf( " Printing annotations for '%s'%n%n " , e.toString());
 55 
 56      Annotation[] annotations  =  e.getAnnotations();
 57       for  (Annotation a : annotations) {
 58        out.printf( "     * Annotation '%s' found%n " , 
 59          a.annotationType().getName());
 60      }
 61    }
 62 
 63     public   static   void  main(String[] args) {
 64       try  {
 65        ReflectionTester tester  =   new  ReflectionTester();
 66 
 67        tester.testAnnotationPresent(System.out);
 68        tester.testInheritedAnnotation(System.out);
 69 
 70        tester.testGetAnnotation(System.out);
 71 
 72        Class c  =  AnnotationTester. class ;
 73        AnnotatedElement element  =  c.getMethod( " calculateInterest " , 
 74                                       float . class ,  float . class );      
 75        tester.printAnnotations(element, System.out);
 76      }  catch  (Exception e) {
 77        e.printStackTrace();
 78      } 
 79    }
 80  }
 81 
 82  class  Sub  extends  Super {
 83 
 84     public   void  print(PrintStream out)  throws  IOException {
 85      out.println( " Sub printing " );
 86    }
 87  }
 88 
 89  @InProgress  class  Super {
 90 
 91     public   void  print(PrintStream out)  throws  IOException {
 92      out.println( " Super printing " );
 93    }
 94  }
 95 
 96  @Documented
 97  @Retention(RetentionPolicy.RUNTIME)
 98  @ interface  GroupTODO {
 99 
100     public   enum  Severity { CRITICAL, IMPORTANT, TRIVIAL, DOCUMENTATION };
101 
102    Severity severity()  default  Severity.IMPORTANT;
103    String item();
104    String assignedTo();
105    String dateAssigned();
106  }
107 
108  /**
109   * Marker annotation to indicate that a method or class
110   *   is still in progress.
111    */
112  @Documented
113  @Inherited
114  @Retention(RetentionPolicy.RUNTIME)
115  @ interface  InProgress { }
116 
117  class  AnnotationTester {
118 
119    @InProgress
120    @GroupTODO(
121      severity = GroupTODO.Severity.CRITICAL,
122      item = " Figure out the amount of interest per month " ,
123      assignedTo = " Brett McLaughlin " ,
124      dateAssigned = " 04-26-2004 "
125    )
126     public   void  calculateInterest( float  amount,  float  rate) {
127       //  Need to finish this method later
128    }
129  }
130