Before tackling how to generate code or other dependent files such as deployment descriptor, we should clarify a couple of aspects presented in the code snippet above. The StrutsAction annotation type defines many elements but only a few of them were actually declared in the real annotation. This is perfectly valid because the elements that don't have a value declared will take the default value defined in the annotation type. In this case most of the values defaulted to an empty string but the scope element has a default value of session. So if the developer doesn't explicitly specify the value, the default value will be used. In the StrutsAction annotation type, we also have the return type for the forward element as an array of StrutsActionForward elements. So annotation is done by separating the values by a comma wrapped in braces.

    forward = {@StrutsActionForward( ... ),
    @StrutsActionForward( ... ) },

In this code snippet two action forward element are specified and both of them are enclosed by a brace separated by a comma. Now that we've talked about annotation types and annotation, the core concepts of annotation have been pretty much covered.

Generating Code/Supporting Files
The final steps in the process are the procedures for generating code or support files like deployment descriptor. This could be the hardest part depending on the complexity of what we are trying to do. If we are generating source code based on annotation information then we need to have some kind of parser generator to generate the code. JavaCC hosted at www.java.net is an excellent parser generator implementation. Since we are generating an XML file, we used JDOM API to generate the deployment descriptor for struts.

There are two ways to do the code generation. The first is to write a driver code that uses the reflection API and the annotation API to figure out what annotations are present and then operate on them appropriately. The other is to use the annotation processing tool bundled with the JDK to process the annotation.

In the section above we explained how the annotation processing tool works. The annotation processor that's returned by the factory does the actual work of generating code. In the core processing we loop through the annotation types and have a visitor based on the Gang of Four's visitor design pattern do the work. This visitor processes the annotation on the class declaration, method declaration, package declarations etc. and does the file generation.

The code snippet for the factory, annotation processor and a simple visitor is as follows:

public class StrutsConfigGenerator implements
	AnnotationProcessorFactory{
    private static final Collection<String>
	supportedAnnotations
    = unmodifiableCollection(Arrays.asList("*"));
    private static final Collection<String>
     supportedOptions = emptySet();
    public StrutsConfigGenerator() {}
    
    public Collection<String> supported
	 AnnotationTypes() {
	 return supportedAnnotations;
    }

    public Collection<String> supported
	 Options() {
	    return supportedOptions;
    }
    
    public AnnotationProcessor get
     ProcessorFor(
                     Set<AnnotationType
                      Declaration> atds,
                   AnnotationProcessor
                    Environment env) {
        return (AnnotationProcessor)new 
         WebGeneratedAp(env);
    }

    private static class WebGeneratedAp
	 implements
	 AnnotationProcessor {
        private final AnnotationProcessor
         Environment env;
        WebGeneratedAp(AnnotationProcessor
         Environment env) {}
        
        public void process() {
            for (TypeDeclaration typeDecl :
                   env.getSpecifiedType
                    Declarations()){
                // GoF visitor Design Pattern 
                   applied here!
                typeDecl.accept(get
                 DeclarationScanner(
                    new WebGeneratorClass
                     Visitor(), NO_OP));
            }
         }
        private class WebGeneratorClassVisitor
         xtends 
		 SimpleDeclarationVisitor {
           public WebGeneratorClassVisitor(){ }
           
           public void visitClassDeclaration(
            ClassDeclaration d)
           {
        	/ /Do some meaningful work here!!!
           }

	      // You could have more specific declarations here
        }
    }    
}

An important thing that we need to take note of is the getProcessorFor method in the factory. This method returns the annotation processor and, in our case, is an instance of the WebGeneratedAp class. This class extends AnnotationProcessor and implements the no args process method. Here we loop through all the type declarations and then have the type declaration accept our visitor. Our visitor is WebGeneratorClassVisitor and has methods to handle the areas where annotations occur like class declaration, method declaration and package declaration. It's here that we read the annotation, find out what the value is and operate on it accordingly. The complete working copy of the source is provided along with this article.

The final step in the process is to invoke the Annotation Processing Tool. This is typically done through the command line as follows:

apt -cp [Classpath] -nocompile 
-factory com.jdj.article.gen.StrutsConfigGenerator 
-Astruts-config=F:\Article\Dev\Annotation\
 generated\struts-config.xml <path>\
 ExampleAction.java

• Figure 1
• Table 1
• Table 2
• Source Code