Java > Open Source Codes > de > webman > template > jsp > JSPTemplate


1 package de.webman.template.jsp;
2
3 import java.util.Enumeration ;
4 import java.io.*;
5 import java.util.Properties ;
6 import javax.servlet.*;
7 import javax.servlet.http.*;
8 import javax.xml.parsers.DocumentBuilder ;
9 import javax.xml.parsers.DocumentBuilderFactory ;
10 import com.teamkonzept.lib.*;
11 import com.teamkonzept.web.TKEvent;
12 import com.teamkonzept.lib.templates.*;
13 import org.apache.jasper.*;
14 import org.w3c.dom.Document ;
15 import org.w3c.dom.Element ;
16 import org.apache.log4j.Category;
17 import org.apache.log4j.Priority;
18 import javax.servlet.jsp.*;
19 import com.teamkonzept.webman.ProcessStarter;
20
21 /**
22  * Implementierung der JSP-Templates.
23  *
24  * @author $Author: uli $
25  * @version $Revision: 1.19 $
26  */
27 public class JSPTemplate
28     implements TemplateBasic,
29                TemplateTypes
30
31 {
32
33     /** JSP Factory */
34     private static final WebManJspFactory JSP_FACTORY = new WebManJspFactory();
35
36     /** Postfix um die erzeugten Klassen möglichst eindeutig zu machen */
37     private static final String POSTFIX = "_webmanTemplate";
38
39     private DOMTemplateData data;
40
41     /** Log4J Category */
42     private static Category cat = Category.getInstance(JSPTemplate.class);
43
44     /** Name des Templates */
45     private String name;
46
47     /** letzte Modifizierung des Templates */
48     private long lastModified;
49
50     /** gecached Template */
51     private HttpJspPage jspPage;
52
53     /** Directory, in dem die .java und .class Dateien liegen */
54     private static final String COMPILE_DIR = "compiled";
55
56     /** erzeugter Text */
57     private String text;
58
59     /** Basisdirectory */
60     private String rootDir;
61
62     /** handelt es sich um ein Template von Webman selber (Oberfläche) ? */
63     private boolean editor;
64
65     /** der Request von Webman, um alle Umgebungsvariablen zu haben */
66     private HttpServletRequest originalRequest;
67
68     /** aktueller Request wird gehalten */
69     private WebManRequest request;
70
71     /**
72      * Creates a new JSP template.
73      *
74      * @param _docRoot the document root.
75      * @param _name the template source name.
76      * @param _editor the template editing mode.
77      * @throws TKTemplateSyntaxException if the specified template source is errornous.
78      */
79     public JSPTemplate (String _docRoot,
80                         String _name,
81                         boolean _editor)
82         throws TKTemplateSyntaxException
83     {
84         try
85         {
86             rootDir = _docRoot;
87             name = _name;
88             editor = _editor;
89             data = new DOMTemplateData();
90         }
91         catch (Exception e)
92         {
93             cat.error("JSPTemplate:constructor " , e);
94         }
95         init();
96     }
97
98     public void setOriginalRequest(HttpServletRequest request)
99     {
100         originalRequest = request;
101     }
102
103     public String getType()
104     {
105         return JSP_TEMPLATE;
106     }
107
108     public HttpServletRequest getRequest()
109     {
110         return request;
111     }
112
113     public DOMTemplateData getDOMData()
114     {
115         return data;
116     }
117
118     protected void resetData()
119     {
120         try
121         {
122             data = new DOMTemplateData();
123             originalRequest = null;
124         }
125         catch (Exception e)
126         {
127             cat.error("Unable to reset Data", e);
128         }
129     }
130
131     /**
132         kompiliert die Klasse vor
133     */
134     void init() throws TKTemplateSyntaxException
135     {
136         try
137         {
138             // einmal compilieren
139 String [] args = new String [8];
140             args[0] = "-uriroot";
141             if (editor)
142                 args[1] = rootDir + TemplateUtils.getWebmanTemplateDirectory() + File.separator;
143             else
144                 args[1] = rootDir + TemplateUtils.getGenerationDirectory();
145
146             /** Logging Category anhand der Log4J Prio bestimmen
147                 umstellen, sobald Tomcat Log4J benutzt
148             */
149             Priority prio = cat.getPriority();
150             if (prio == null)
151                 args[2] = "-v0";
152             else if (prio.equals(Priority.ERROR))
153                 args[2] = "-v2";
154             else if (prio.equals(Priority.WARN))
155                 args[2] = "-v4";
156             else if (prio.equals(Priority.INFO))
157                 args[2] = "-v6";
158             else
159                 args[2] = "-v9";
160             //args[2] = "-v2";
161 args[3] = "-d";
162             args[4] = rootDir + COMPILE_DIR; // Ausgabedirectory
163 args[5] ="-c";
164             String className = name.substring(0, name.indexOf(".")) + POSTFIX;
165             args[6] = className; // Klassenname
166 String fileName = "";
167             if (editor)
168                 fileName = rootDir + TemplateUtils.getWebmanTemplateDirectory() + File.separator + name;
169             else
170                 fileName = rootDir + TemplateUtils.getGenerationDirectory() +name;
171             args[7] = fileName;
172             String pathToClass = rootDir + COMPILE_DIR + File.separator + className + ".class";
173
174             // Datum der Klasse vor dem Compilieren
175 long preCompiled = new File(pathToClass).lastModified();
176             File f = new File(fileName);
177             lastModified = f.lastModified();
178             /*for (int i = 0; i < 8; i++)
179                 System.out.print(args[i] + " ");*/
180             // Classpath ergaenzen
181 Properties props = System.getProperties();
182             String path = props.getProperty("java.class.path");
183             if (path == null)
184                 path = "";
185             String append = ProcessStarter.getWMClasspath(rootDir);
186             props.setProperty("java.class.path", path + ";"+ append);
187             System.setProperties(props);
188
189             ByteArrayOutputStream bout = new ByteArrayOutputStream();
190             PrintStream ps = new PrintStream(bout);
191
192             JspC jspc = new JspC(args, ps);
193             jspc.parseFiles(ps);
194             ps.flush();
195             // Datum der Klasse nach dem Compilieren
196 long postCompiled = new File(pathToClass).lastModified();
197             if (! (postCompiled > preCompiled)) // ooops, hat nicht geklappt !
198 throw new TKTemplateSyntaxException("Unable to compile !" + bout.toString());
199         }
200         catch (TKTemplateSyntaxException e)
201         {
202             throw e;
203         }
204         catch (Throwable t)
205         {
206             cat.error("JSPTemplate:init " , t);
207         }
208     }
209
210     /**
211         setzt Daten in die Root
212     */
213     public void set( TKHashtable aSubst )
214     {
215         data.set(aSubst);
216     }
217
218
219     public void set( String key, Object val )
220     {
221         data.set(key, val);
222     }
223
224     /**
225         initialisiert den Request
226     */
227     public void initRequest()
228     {
229         if (jspPage == null)
230         {
231             try
232             {
233                 initJspPage();
234             }
235             catch (ServletException e)
236             {
237                 cat.error("initRequest: " + e.getMessage(), e);
238             }
239         }
240         request = new WebManRequest(jspPage.getServletConfig().getServletContext());
241     }
242
243     private Class loadClass()
244     {
245         try
246         {
247             JSPClassLoader loader = new JSPClassLoader(rootDir + File.separator + COMPILE_DIR, getClass().getClassLoader());
248             Class c = loader.loadClass(name.substring(0, name.indexOf("."))+ POSTFIX);
249             return c;
250         }
251         catch (ClassNotFoundException e)
252         {
253             cat.error("JSPTemplate:loadClass" , e);
254             return null;
255         }
256     }
257
258     /**
259         checkt, ob das jsp neu compiliert werden muß und macht es auch falls noetig
260     */
261     private boolean isOutdated() throws TKTemplateSyntaxException
262     {
263         String fileName = "";
264         if (editor)
265             fileName = rootDir + TemplateUtils.getWebmanTemplateDirectory() + File.separator + name;
266         else
267             fileName = rootDir + TemplateUtils.getGenerationDirectory() +name;
268         File f = new File(fileName);
269         long l = f.lastModified();
270         // System.out.println("In check : " + l);
271 if ( l > lastModified)
272         {
273             cat.debug("Reload Template " + name);
274             init();
275             jspPage = null;
276             return true;
277         }
278         return false;
279     }
280
281     public synchronized void sendData(Element node, PrintWriter out) //throws TKException
282 {
283         try
284         {
285             if (jspPage == null || isOutdated())
286             {
287                 initJspPage();
288             }
289             if (request == null)
290                 request = new WebManRequest(jspPage.getServletConfig().getServletContext()); // ich verlasse mich auf initRequest !!!!
291 request.setData(node);
292             request.setOriginalRequest(originalRequest);
293             WebManResponse response = new WebManResponse(out);
294             jspPage._jspService(request, response);
295
296             out.flush();
297         }
298         catch (ServletException ee)
299         {
300             Throwable t = ee.getRootCause() ;
301             cat.error("JSPTemplate.sendData: " + t.getMessage() , t);
302         }
303         catch (Exception e)
304         {
305             cat.error("JSPTemplate.sendData: " + e.getMessage() , e);
306         }
307         finally
308         {
309             resetData();
310         }
311     }
312
313     private void initJspPage() throws ServletException
314     {
315         try
316         {
317             Class cl = loadClass();
318             if (cl == null)
319             {
320                 cat.error("Class not found !!!! " + name); // Exception !
321 return;
322             }
323             Object obj = cl.newInstance();
324             jspPage = (HttpJspPage)obj;
325             javax.servlet.jsp.JspFactory.setDefaultFactory(JSP_FACTORY);
326             // Page initialisieren ???
327 WebManServletConfig config = new WebManServletConfig();
328             TKEvent evt = TKEvent.getEventForThread();
329             if (evt != null)
330             {
331                 ((WebManServletContext)config.getServletContext()).setDocRoot(evt.getHttpInterface().getDocumentRoot());
332             }
333             jspPage.init(config);
334             jspPage.jspInit();
335         }
336         catch (IllegalAccessException e)
337         {
338             cat.error("JSPTemplate.initJspPage: " + e.getMessage() , e);
339         }
340         catch (InstantiationException ee)
341         {
342             cat.error("JSPTemplate.initJspPage: " + ee.getMessage() , ee);
343         }
344     }
345     /**
346      * Das substituierte Template wird als String zurueckgegeben.
347      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
348      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
349      * substituiert werden.
350      * @return einen String des substituierten Templates
351      */
352     public String getText()
353     {
354         return text;
355     }
356
357     /**
358      * Das Template wird in den PrintStream geschrieben.
359      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
360      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
361      * substituiert werden.
362      *
363      */
364     public void printTemplate( PrintStream out )
365     {
366         sendData(data.getRoot(), new PrintWriter(out));
367     }
368
369     /**
370      * Das Template wird in den Writer geschrieben.
371      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
372      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
373      * substituiert werden.
374      *
375      */
376     public void printTemplate( Writer writer ) throws IOException
377     {
378         sendData(data.getRoot(), new PrintWriter(writer));
379     }
380
381     /**
382      * Das Template wird auf stdout geschrieben.
383      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
384      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
385      * substituiert werden.
386      *
387      */
388     public void printTemplate()
389     {
390         throw new RuntimeException ("Methode not implemented !");
391     }
392
393     /**
394      * Das substituierte Template wird in ein File geschrieben werden.
395      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
396      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
397      * substituiert werden.
398      *
399      * Bsp. Reihenfolge der Aufrufe:
400      * TKTemplateObject.doTagSubstitution();
401      * TKTemplateObject.doCleanup();
402      * TKTemplateObject.printTemplate(String file)
403      *
404      * @param String file, der Filename des zu speichernden templates
405      */
406     public void printTemplate(String file) throws IOException
407     {
408         FileWriter w = new FileWriter(file);
409         sendData(data.getRoot(), new PrintWriter(w));
410     }
411
412
413     /**
414      * Durch den Aufruf der Methode doMainSubstitution enthaelt die
415      * Instanzvariable "text" das Template mit den substituierten TKTags.
416      * Die nicht vollstaendigen Pfade werden ersetzt.
417      *
418      * Die URL-Base ist gestzt, wenn Images ausserhalb des CGI-Verzeichnisses
419      * abgelegt sind. Fuer diese Bilder muss der vollstaendige Pfad im
420      * Template gesetzt werden.
421      */
422     public void doTagSubstitution() throws TKTemplateSyntaxException
423     {
424         doMainSubstitutions();
425     }
426
427     /**
428      * Die Instanzvariable "text" enthaelt das Template mit den
429      * substituierten TKTags
430      * saemtliche Funktionalitaet in die print Methoden verschoben !
431      */
432     public void doMainSubstitutions() throws TKTemplateSyntaxException
433     {
434         /*
435         StringWriter w = new StringWriter();
436         sendData(root, new PrintWriter(w));
437         text = w.toString();*/
438     }
439
440 }
441

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags