001: /*
002: * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/web/Attic/TKHttpThread.java,v 1.15 2001/08/21 13:01:33 mischa Exp $
003: *
004: */
005: package com.teamkonzept.web;
006:
007: import java.io.*;
008: import java.util.*;
009: import org.apache.log4j.Category;
010:
011: import com.teamkonzept.lib.*;
012:
013: // jprobe api
014: // import com.sitraka.jprobe.profiler.api.*;
015:
016: /**
017: Die Klasse TKHttpThread ist die Basisklasse für alle HTTP-Server-Erweiterungen.
018: <P>
019: Die Grundidee hinter TKHttpThread ist, daš jedem HTTP-Request ein
020: eindeutiges TKHttpThread-Objekt zugeordnet ist, das diesen Request abarbeitet.
021: <P>
022: Im Konstruktor wird dem TKHttpThread ein Objekt der Klasse TKHttpInterface übergeben.
023: Dieses Objekt stellt eine plattformunabh‰ngige Schnittstelle zum HTTP-Server dar,
024: über das dann die Request-spezifischen Parameter abgefragt und die HTTP-Response erstellt
025: werden kann.
026: <P>
027: Die Klasse erf¸llt das Runnable Interface, damit es auch in Umgebungen eingesetzt werden kann
028: in denen f¸r jeden Request "echte" Threads erzeugt werden. Entsprechend ist die Methode "run"
029: zuständig für die Abarbeitung der Requests.
030: <P>
031: Eine minimale Anwendung für das CGI Interface w‰re:
032: <PRE>
033: // zunächst die plattformunabhängige Thread-Klasse
034: public class helloWorldThread extends TKHttpThread {
035: public helloWorld( TKHttpInterface i ) { super(i); }
036: public boolean handleEvent( String event ) { out.println("Hello World"); return true;}
037: }
038:
039: // jetzt der plattformabhängige Starter.
040: public class helloWorldCGI {
041: public static void main( String[] args ) {
042: TKHttpThread t = new helloWorldThread( new CGIInterface() );
043: t.run();
044: }
045: }
046: </PRE>
047: <P>
048: Die Klasse geht davon aus, daš die Parameter die Namenskonventionen der Klasse
049: com.teamkonzept.lib.TKParams erfüllen.
050:
051: <P>
052: * Die abstrakte Klasse TKHttpThread implementiert das Interface Runnable
053: * und definiert eine run()-Methode fuer die Erzeugung eines Threads.
054: * Da diese Klasse Abstrakt ist, kann keinr Instanz von Ihr erzeugt werden.
055:
056: @see com.teamkonzept.web.TKParams
057: @see com.teamkonzept.web.TKHttpInterface
058: * @author $Author: mischa $
059: * @version $Revision: 1.15 $
060:
061: */
062: public class TKHttpThread implements Runnable {
063:
064: // jprobe api
065: //JPPerformanceAPI perfAPI = JPPerformanceAPI.getInstance();
066:
067: private static final Category CATEGORY = Category
068: .getInstance(TKHttpThread.class);
069:
070: /** Der Thread, der den Request abarbeitet */
071: protected Thread myThread;
072:
073: /** Das Interface zur HTTP-Server */
074: protected TKHttpInterface httpInterface;
075:
076: /** der eigentliche EventHandler */
077: static TKEventHandler handler = com.teamkonzept.webman.mainint.WebManThread
078: .getInstance();
079:
080: public PrintStream log;
081:
082: /**
083: * Konstruktor. Ihm wird ein Objekt vom Typ TKHttpInterface uebergeben.
084: * Damit stehen die Methoden des Interfaces im Thread zur Verfuegung
085: *
086: * @param TKHttpInterface httpInterface
087: */
088: public TKHttpThread(TKHttpInterface httpInterface) {
089: this .httpInterface = httpInterface;
090: /*
091: this.out = new PrintStream( this.outbuf = new ByteArrayOutputStream() );
092: */
093: this .log = new TKByteArrayPrintStream(httpInterface
094: .getLogStream());
095: }
096:
097: /**
098: * Die Klassenmethode currentThread() gibt das aktuelle Thread zurueck.
099: * Danach wird die Methode register() von der klasse TKHttp aufgerufen
100: * und die Klassenvariable httpInterface wird gestzt.
101: *
102: * @param Thread thread, es wird ein Thread-Objekt benoetigt
103: * @param TKHttpInterface Interface , Templateparameter und Enviroment
104: */
105: public void register() {
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: // ÄNDERN !!!
117: //printHeaders();
118:
119: try {
120: log.flush();
121: } catch (Exception e) {
122: CATEGORY.error("deregister: ", e);
123: } finally {
124: TKHttp.deregister(myThread);
125: }
126: }
127:
128: /**
129: * 1. TK-Parameter der URL werden geholt
130: * 2. Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
131: * zum Setzen und Erhalten von TK-Parametern. Eine Applikation, die diesen
132: * Thread erzeugt benutzt die methoden des Objekts param folgendermassen:
133: * params.methodenname()
134: * 3. Ein Obkekt der Klasse TKVector wird erzeugt und ihm wird der Content-type
135: * als Element abgelegt.
136: */
137: public void init() {
138: /*
139: pureParams = httpInterface.getParams();
140: params = new TKParams( pureParams );
141: headers = new TKHashtable();
142: headers.put( "Content-type", "text/html;charset=ISO-8859-1" );
143: */
144: }
145:
146: /**
147: * 1. Das aktuelle Event wird geholt
148: * 2. Der Applikation, die dieses Thread erzeugt (bzw ein Obkekt der Klasse
149: * TKHttpSessionThread, die von dieser Klasse abgeleitet ist) und eine
150: * Methode handleEvent(String event) beinhaltet, kann den jeweiligen Event
151: * abarbeiten.
152: * Die Methode handleEvent() existiert in der Klasse TKHttpThread als
153: * abstrakte Methode und wird in der eigentlichen Applikation implementiert.
154: */
155: public void start() {
156: try {
157: TKEvent event = handler.createEvent(httpInterface);
158: /*
159: TKHashtable evClass = params.getClass( "EV" );
160: Enumeration evEnum = ( evClass != null ? evClass.keys() : null );
161: String event = ( evEnum != null && evEnum.hasMoreElements() ? (String) evEnum.nextElement() : null );
162: */
163: handleEvent(event);
164: event.consume();
165: } catch (Throwable e) {
166: log.println("message: " + e.getMessage());
167: e.printStackTrace(log);
168: }
169: }
170:
171: /**
172: * Definition der run()-Methode
173: * 1. Klassenvariable httpInterface wird gesetzt
174: * 2. Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
175: * zum Setzen und Erhalten von TK-Parametern.
176: * 3. Der Methode handleEvent() wird der jeweilige Event uebergeben.
177: * 4. Klassenvariable httpInterface wird wieder auf null gesetzt.
178: */
179: public void run() {
180: //perfAPI.clear();
181: register();
182: // init();
183: start();
184: deregister();
185: //perfAPI.save("TKHttpThread_run");
186: }
187:
188: /**
189: * Als Parameter wird im template das SELF gesetzt.
190: * Aufruf: TKTemplate einTemplate = prepTemplate( new TKTemplate(TemplateName));
191: *
192: * @return ein vorpraeperiertes Template.
193: */
194: public TKHTMLTemplate prepTemplate(TKHTMLTemplate t) {
195: t.set("SELF", httpInterface.getOwnURL());
196: t.setAppName(httpInterface.getOwnName());
197: return t;
198: }
199:
200: /**
201: * Ein Objekt der Klasse TKForm wird erzeugt.
202: * Aufruf:TKForm eineForm = newForm(Pfad/TemplateName)
203: *
204: * @param ein Template-Objekt
205: */
206: /*
207: public TKForm newForm( TKHTMLTemplate t )
208: {
209: return new TKForm( params, prepTemplate( t ) );
210: }
211: */
212: /**
213: * Der abstrakten Methode handleEvent wird der aktuelle Event als String
214: * uebergeben. Die eigentliche implementierung der methode erfolg in der
215: * zu erstellenden Applikation.
216: *
217: * @param String event, der aktuell abzuarbeitende Event
218: */
219: public void handleEvent(TKEvent event) throws Exception {
220: handler.handleEvent(event);
221: }
222:
223: /**
224: * Parameter eines URL sollen an ein Frame-Template weitergeleitet werden.
225: *
226: * @return result, Parameter des URL's
227: */
228: /*
229: public String getParamsString()
230: {
231: String result = "";
232: if( pureParams == null ) return result;
233:
234: TKUrlConverter encoder = new TKUrlConverter();
235:
236: Enumeration keys = pureParams.keys();
237: while( keys.hasMoreElements() ) {
238: String key = keys.nextElement().toString();
239: Object val = pureParams.get( key );
240: String valStr = ( val == null ? "" : val.toString() );
241: byte[] encoded = new byte[ encoder.minByteSize( key.length() + valStr.length() ) ];
242: if( !key.regionMatches( true, 0, "TK_EV[", 0, 6 ) ) {
243: result += "&" + new String( encoded, 0, 0, encoder.charsToBytes( key.toCharArray(), encoded, 0, key.length(), 0 ) ) + "=";
244: //TKHttp.println( "length of key ("+key+") = "+count+"/"+key.length() );
245: if( valStr.length() > 0 ) {
246: result += new String( encoded, 0, 0, encoder.charsToBytes( valStr.toCharArray(), encoded, 0, valStr.length(), 0 ) );
247: }
248: }
249: }
250: return result;
251: }
252: */
253: }
|