KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > Afterburners


1 import java.lang.reflect.*;
2 import java.util.*;
3 import java.io.*;
4 import org.apache.log4j.Category;
5
6 /**
7  * Utitility to invoke several webman afterburner classes in order
8  * and with individual arguments.
9  *
10  * Usage: Write <b>Afterburners</b> as value of webman property <b>AFTERBURNER</b>, then
11  * specify each true afterburner Class<sub>0</sub>, Class<sub>1</sub>,..., Class<sub>n</sub> as follows:
12  * For each Class<sub>k</sub> (0<=k<=n) create a webman property <b>AFTERBURNER_ARG<i>k</i></b>
13  * with value <b>Class<sub>k</sub> arg<sub>k</sub>0 arg<sub>k</sub>1 arg<sub>k</sub>m</b>
14  * where arguments are separated by at least one space and may be delimited by single-
15  * or doublequotes, with the backslash as escape character to embed such delimiters
16  * into an argument's value.
17  * This Afterburners will then load, for k=0 to k=n, Class<sub>k</sub> and call
18  * its (required) static main( String[] args) with String[] built from
19  * arg<sub>k</sub>0,..., arg<sub>k</sub>m.
20  * <p>
21  * Webman example (2 afterburner classes, each with 3 arguments):<br>
22  * <tt>
23  * Property&nbsp;<b>AFTERNBURNER</b>,&nbsp;value&nbsp;<b>Afterburners</b><br>
24  * Property&nbsp;<b>AFTERBURNER_ARG0</b>,&nbsp;value&nbsp;<b>MyAfterburner1&nbsp;"1st&nbsp;argument"&nbsp;2nd_argument&nbsp;'args\'s&nbsp;end'</b><br>
25  * Property&nbsp;<b>AFTERBURNER_ARG1</b>,&nbsp;value&nbsp;<b>MyAfterburner2&nbsp;""&nbsp;'"'&nbsp;"args's&nbsp;end"</b><br>
26  * </tt>
27  *
28  * @author Ulf Goldammer
29  * @version 1.0
30  */
31  
32 // Avoid defining more than 1 class to not disturb the webman class collection
33 // by this small utility.
34
35 public class Afterburners
36 {
37     private static Category cat = Category.getInstance( Afterburners.class);
38     
39     /**
40     * This method is called by webman's afterburner mechanism.
41     * @param args An array of strings, each beginning with a class name
42     * and optionally followed by a list of arguments (for syntax cf. class Afterburners)
43     * for calling that class.
44     */
45     public static void main( String JavaDoc[] args) {
46
47         boolean doNextAfterburner = true;
48
49         for ( int i = 0; (i < args.length) && doNextAfterburner; i++) {
50         
51             if ( args[i] == null) continue;
52             
53             // parse an argument: find class to call and its args
54
55             StreamTokenizer st = new StreamTokenizer( new StringReader( args[i]));
56             st.resetSyntax(); // NECCESSARY whenever using own definitions!
57 st.whitespaceChars(0, ' ');
58             st.wordChars('\u0021', '\u00FF');
59             st.quoteChar('\'');
60             st.quoteChar('"');
61             st.eolIsSignificant(false);
62             Vector argVec = new Vector(); // collects class's args
63 String JavaDoc invokeClass = null; // the class's name
64
65             try {
66                 while( st.nextToken() != StreamTokenizer.TT_EOF) {
67                     switch( st.ttype) {
68                         case '"':
69                         case '\'':
70                         case StreamTokenizer.TT_WORD:
71                             if (invokeClass == null)
72                                 invokeClass = st.sval;
73                             else
74                                 argVec.addElement( st.sval);
75                             break;
76                         default:
77                             cat.error(
78                                 "(internal) token type: " + st.ttype +
79                                 " while parsing afterburner args. Continuing."
80                             );
81                             break;
82                     }
83                 }
84                 
85                 if (( invokeClass == null) || ( invokeClass.trim().length() < 1)) {
86                     cat.error("AFTERBURNER_ARG" + i + ": invalid class name. Ignored.");
87                     continue;
88                 }
89                 cat.info("Afterburners AFTERBURNER_ARG" + i + ":");
90                 try {
91                     // load class
92 Class JavaDoc c = Class.forName( invokeClass);
93                     Method m = c.getMethod( "main", new Class JavaDoc[] { java.lang.String JavaDoc[].class} );
94
95                     // build array of arg strings and also print log message
96 String JavaDoc[] argsArray = new String JavaDoc[ argVec.size()];
97                     Enumeration ae = argVec.elements();
98                     int k = 0;
99                     String JavaDoc comma = " ";
100                     StringBuffer JavaDoc msg = new StringBuffer JavaDoc("try calling " + invokeClass + ".main(");
101                     while ( ae.hasMoreElements() ) {
102                         argsArray[k] = (String JavaDoc) ae.nextElement();
103                         if ( argsArray[k] == null) argsArray[k] = "";
104                         msg.append( comma + '"' + argsArray[k] + '"');
105                         comma = ", ";
106                         k++;
107                     }
108                     cat.info( msg + ")");
109                     
110                     // invoke main() of class
111 m.invoke( null, new Object JavaDoc[] { argsArray});
112                 }
113                 catch( ClassNotFoundException JavaDoc e) {
114                     cat.error("Class '" + invokeClass + "' not found while afterburning. Ignored.");
115                 }
116                 catch( NoSuchMethodException JavaDoc e) {
117                     cat.error("Class '" + invokeClass + "' has no proper 'main'-method. Ignored.");
118                 }
119                 catch( IllegalAccessException JavaDoc e) {
120                     cat.error("Class '" + invokeClass + "' has no accessible 'main'-method. Ignored.");
121                 }
122                 catch( InvocationTargetException e) {
123                     cat.error("Class '" + invokeClass + "': invokation failed. Ignored.");
124                     e.printStackTrace();
125                 }
126             }
127             catch ( IOException e) {
128                 cat.error("IOException while parsing afterburner's arguments.");
129                 cat.error("Afterburning stopped.");
130                 doNextAfterburner = false;
131             }
132
133         }
134     }
135
136 }
137
Popular Tags