KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > teamkonzept > web > TKHttpThread


1 /*
2  * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/web/Attic/TKHttpThread.java,v 1.15 2001/08/21 13:01:33 mischa Exp $
3  *
4  */

5 package com.teamkonzept.web;
6
7 import java.io.*;
8 import java.util.*;
9 import org.apache.log4j.Category;
10
11 import com.teamkonzept.lib.*;
12 // jprobe api
13
// import com.sitraka.jprobe.profiler.api.*;
14

15
16 /**
17     Die Klasse TKHttpThread ist die Basisklasse für alle HTTP-Server-Erweiterungen.
18     <P>
19     Die Grundidee hinter TKHttpThread ist, daš jedem HTTP-Request ein
20     eindeutiges TKHttpThread-Objekt zugeordnet ist, das diesen Request abarbeitet.
21     <P>
22     Im Konstruktor wird dem TKHttpThread ein Objekt der Klasse TKHttpInterface &uuml;bergeben.
23     Dieses Objekt stellt eine plattformunabh‰ngige Schnittstelle zum HTTP-Server dar,
24     &uuml;ber das dann die Request-spezifischen Parameter abgefragt und die HTTP-Response erstellt
25     werden kann.
26     <P>
27     Die Klasse erf¸llt das Runnable Interface, damit es auch in Umgebungen eingesetzt werden kann
28     in denen f¸r jeden Request "echte" Threads erzeugt werden. Entsprechend ist die Methode "run"
29     zust&auml;ndig f&uuml;r die Abarbeitung der Requests.
30     <P>
31     Eine minimale Anwendung f&uuml;r das CGI Interface w‰re:
32     <PRE>
33         // zun&auml;chst die plattformunabh&auml;ngige Thread-Klasse
34         public class helloWorldThread extends TKHttpThread {
35             public helloWorld( TKHttpInterface i ) { super(i); }
36             public boolean handleEvent( String event ) { out.println("Hello World"); return true;}
37         }
38
39         // jetzt der plattformabh&auml;ngige Starter.
40         public class helloWorldCGI {
41             public static void main( String[] args ) {
42                 TKHttpThread t = new helloWorldThread( new CGIInterface() );
43                 t.run();
44             }
45         }
46     </PRE>
47     <P>
48     Die Klasse geht davon aus, daš die Parameter die Namenskonventionen der Klasse
49     com.teamkonzept.lib.TKParams erf&uuml;llen.
50
51     <P>
52  * Die abstrakte Klasse TKHttpThread implementiert das Interface Runnable
53  * und definiert eine run()-Methode fuer die Erzeugung eines Threads.
54  * Da diese Klasse Abstrakt ist, kann keinr Instanz von Ihr erzeugt werden.
55
56     @see com.teamkonzept.web.TKParams
57     @see com.teamkonzept.web.TKHttpInterface
58  * @author $Author: mischa $
59  * @version $Revision: 1.15 $
60
61  */

62 public class TKHttpThread implements Runnable JavaDoc
63 {
64
65     // jprobe api
66
//JPPerformanceAPI perfAPI = JPPerformanceAPI.getInstance();
67

68     private static final Category CATEGORY = Category.getInstance(TKHttpThread.class);
69
70     /** Der Thread, der den Request abarbeitet */
71     protected Thread JavaDoc myThread;
72
73     /** Das Interface zur HTTP-Server */
74     protected TKHttpInterface httpInterface;
75
76     /** der eigentliche EventHandler */
77     static TKEventHandler handler = com.teamkonzept.webman.mainint.WebManThread.getInstance();
78
79     public PrintStream log;
80
81     /**
82      * Konstruktor. Ihm wird ein Objekt vom Typ TKHttpInterface uebergeben.
83      * Damit stehen die Methoden des Interfaces im Thread zur Verfuegung
84      *
85      * @param TKHttpInterface httpInterface
86      */

87     public TKHttpThread( TKHttpInterface httpInterface )
88     {
89         this.httpInterface = httpInterface;
90         /*
91         this.out = new PrintStream( this.outbuf = new ByteArrayOutputStream() );
92         */

93         this.log = new TKByteArrayPrintStream (httpInterface.getLogStream());
94     }
95
96     /**
97      * Die Klassenmethode currentThread() gibt das aktuelle Thread zurueck.
98      * Danach wird die Methode register() von der klasse TKHttp aufgerufen
99      * und die Klassenvariable httpInterface wird gestzt.
100      *
101      * @param Thread thread, es wird ein Thread-Objekt benoetigt
102      * @param TKHttpInterface Interface , Templateparameter und Enviroment
103      */

104     public void register()
105     {
106         myThread = Thread.currentThread();
107         TKHttp.register( myThread, this, httpInterface );
108     }
109
110     /**
111      * Die Klassenvariable httpInterface wird auf null gestzt
112      *
113      * @param Thread myThread, es wird ein Thread-Objekt benoetigt
114      */

115     public void deregister()
116     {
117         // ÄNDERN !!!
118
//printHeaders();
119

120         try {
121             log.flush();
122         }
123         catch( Exception JavaDoc e ) {
124             CATEGORY.error( "deregister: ", e);
125         }
126         finally
127         {
128             TKHttp.deregister( myThread );
129         }
130     }
131
132     /**
133      * 1. TK-Parameter der URL werden geholt
134      * 2. Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
135      * zum Setzen und Erhalten von TK-Parametern. Eine Applikation, die diesen
136      * Thread erzeugt benutzt die methoden des Objekts param folgendermassen:
137      * params.methodenname()
138      * 3. Ein Obkekt der Klasse TKVector wird erzeugt und ihm wird der Content-type
139      * als Element abgelegt.
140      */

141     public void init()
142     {
143         /*
144         pureParams = httpInterface.getParams();
145         params = new TKParams( pureParams );
146         headers = new TKHashtable();
147         headers.put( "Content-type", "text/html;charset=ISO-8859-1" );
148         */

149     }
150
151
152
153     /**
154      * 1. Das aktuelle Event wird geholt
155      * 2. Der Applikation, die dieses Thread erzeugt (bzw ein Obkekt der Klasse
156      * TKHttpSessionThread, die von dieser Klasse abgeleitet ist) und eine
157      * Methode handleEvent(String event) beinhaltet, kann den jeweiligen Event
158      * abarbeiten.
159      * Die Methode handleEvent() existiert in der Klasse TKHttpThread als
160      * abstrakte Methode und wird in der eigentlichen Applikation implementiert.
161      */

162     public void start()
163     {
164         try {
165             TKEvent event = handler.createEvent(httpInterface);
166             /*
167             TKHashtable evClass = params.getClass( "EV" );
168             Enumeration evEnum = ( evClass != null ? evClass.keys() : null );
169             String event = ( evEnum != null && evEnum.hasMoreElements() ? (String) evEnum.nextElement() : null );
170             */

171             handleEvent( event );
172             event.consume();
173         }
174         catch( Throwable JavaDoc e ) {
175             log.println( "message: "+e.getMessage() );
176             e.printStackTrace( log );
177         }
178     }
179
180     /**
181      * Definition der run()-Methode
182      * 1. Klassenvariable httpInterface wird gesetzt
183      * 2. Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
184      * zum Setzen und Erhalten von TK-Parametern.
185      * 3. Der Methode handleEvent() wird der jeweilige Event uebergeben.
186      * 4. Klassenvariable httpInterface wird wieder auf null gesetzt.
187      */

188     public void run()
189     {
190             //perfAPI.clear();
191
register();
192         // init();
193
start();
194         deregister();
195                 //perfAPI.save("TKHttpThread_run");
196
}
197
198     /**
199      * Als Parameter wird im template das SELF gesetzt.
200      * Aufruf: TKTemplate einTemplate = prepTemplate( new TKTemplate(TemplateName));
201      *
202      * @return ein vorpraeperiertes Template.
203      */

204     public TKHTMLTemplate prepTemplate( TKHTMLTemplate t )
205     {
206         t.set( "SELF", httpInterface.getOwnURL() );
207         t.setAppName( httpInterface.getOwnName() );
208         return t;
209     }
210
211     /**
212      * Ein Objekt der Klasse TKForm wird erzeugt.
213      * Aufruf:TKForm eineForm = newForm(Pfad/TemplateName)
214      *
215      * @param ein Template-Objekt
216      */

217      /*
218     public TKForm newForm( TKHTMLTemplate t )
219     {
220         return new TKForm( params, prepTemplate( t ) );
221     }
222     */

223     /**
224      * Der abstrakten Methode handleEvent wird der aktuelle Event als String
225      * uebergeben. Die eigentliche implementierung der methode erfolg in der
226      * zu erstellenden Applikation.
227      *
228      * @param String event, der aktuell abzuarbeitende Event
229      */

230     public void handleEvent( TKEvent event ) throws Exception JavaDoc
231     {
232         handler.handleEvent(event);
233     }
234
235
236     /**
237      * Parameter eines URL sollen an ein Frame-Template weitergeleitet werden.
238      *
239      * @return result, Parameter des URL's
240      */

241      /*
242     public String getParamsString()
243     {
244         String result = "";
245         if( pureParams == null ) return result;
246
247         TKUrlConverter encoder = new TKUrlConverter();
248
249         Enumeration keys = pureParams.keys();
250         while( keys.hasMoreElements() ) {
251             String key = keys.nextElement().toString();
252             Object val = pureParams.get( key );
253             String valStr = ( val == null ? "" : val.toString() );
254             byte[] encoded = new byte[ encoder.minByteSize( key.length() + valStr.length() ) ];
255             if( !key.regionMatches( true, 0, "TK_EV[", 0, 6 ) ) {
256                 result += "&" + new String( encoded, 0, 0, encoder.charsToBytes( key.toCharArray(), encoded, 0, key.length(), 0 ) ) + "=";
257                 //TKHttp.println( "length of key ("+key+") = "+count+"/"+key.length() );
258                 if( valStr.length() > 0 ) {
259                     result += new String( encoded, 0, 0, encoder.charsToBytes( valStr.toCharArray(), encoded, 0, valStr.length(), 0 ) );
260                 }
261             }
262         }
263         return result;
264     }
265     */

266 }
267
268
Popular Tags