TKHttpThread.java :  » Content-Management-System » webman » com » teamkonzept » web » Java Open Source

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

import java.io.*;
import java.util.*;
import org.apache.log4j.Category;

import com.teamkonzept.lib.*; 
// jprobe api
// import com.sitraka.jprobe.profiler.api.*;


/**
  Die Klasse TKHttpThread ist die Basisklasse für alle HTTP-Server-Erweiterungen.
  <P>
  Die Grundidee hinter TKHttpThread ist, da jedem HTTP-Request ein
  eindeutiges TKHttpThread-Objekt zugeordnet ist, das diesen Request abarbeitet.
  <P>
  Im Konstruktor wird dem TKHttpThread ein Objekt der Klasse TKHttpInterface &uuml;bergeben.
  Dieses Objekt stellt eine plattformunabhngige Schnittstelle zum HTTP-Server dar,
  &uuml;ber das dann die Request-spezifischen Parameter abgefragt und die HTTP-Response erstellt
  werden kann.
  <P>
  Die Klasse erfllt das Runnable Interface, damit es auch in Umgebungen eingesetzt werden kann
  in denen fr jeden Request "echte" Threads erzeugt werden. Entsprechend ist die Methode "run"
  zust&auml;ndig f&uuml;r die Abarbeitung der Requests.
  <P>
  Eine minimale Anwendung f&uuml;r das CGI Interface wre:
  <PRE>
    // zun&auml;chst die plattformunabh&auml;ngige Thread-Klasse
    public class helloWorldThread extends TKHttpThread {
      public helloWorld( TKHttpInterface i ) { super(i); }
      public boolean handleEvent( String event ) { out.println("Hello World"); return true;}
    }

    // jetzt der plattformabh&auml;ngige Starter.
    public class helloWorldCGI {
      public static void main( String[] args ) {
        TKHttpThread t = new helloWorldThread( new CGIInterface() );
        t.run();
      }
    }
  </PRE>
  <P>
  Die Klasse geht davon aus, da die Parameter die Namenskonventionen der Klasse
  com.teamkonzept.lib.TKParams erf&uuml;llen.

  <P>
 * Die abstrakte Klasse TKHttpThread implementiert das Interface Runnable
 * und definiert eine run()-Methode fuer die Erzeugung eines Threads.
 * Da diese Klasse Abstrakt ist, kann keinr Instanz von Ihr erzeugt werden.

  @see com.teamkonzept.web.TKParams
  @see com.teamkonzept.web.TKHttpInterface
 * @author  $Author: mischa $
 * @version $Revision: 1.15 $

 */
public  class TKHttpThread implements Runnable 
{

    // jprobe api
    //JPPerformanceAPI perfAPI = JPPerformanceAPI.getInstance();

  private static final Category CATEGORY = Category.getInstance(TKHttpThread.class);

  /** Der Thread, der den Request abarbeitet */
  protected Thread myThread;

  /** Das Interface zur HTTP-Server */
  protected TKHttpInterface httpInterface;

  /** der eigentliche EventHandler */
  static TKEventHandler handler = com.teamkonzept.webman.mainint.WebManThread.getInstance();

  public PrintStream log;

  /**
   * Konstruktor. Ihm wird ein Objekt vom Typ TKHttpInterface uebergeben.
   * Damit stehen die Methoden des Interfaces im Thread zur Verfuegung
   *
   * @param TKHttpInterface httpInterface
   */
  public TKHttpThread( TKHttpInterface httpInterface )
  {
    this.httpInterface = httpInterface;
    /*
    this.out = new PrintStream( this.outbuf = new ByteArrayOutputStream() );
    */
    this.log = new TKByteArrayPrintStream (httpInterface.getLogStream());
  }

  /**
   * Die Klassenmethode currentThread() gibt das aktuelle Thread zurueck.
   * Danach wird die Methode register() von der klasse TKHttp aufgerufen
   * und die Klassenvariable httpInterface wird gestzt.
   *
   * @param Thread thread, es wird ein Thread-Objekt benoetigt
   * @param TKHttpInterface Interface , Templateparameter und Enviroment
   */
  public void register()
  {
    myThread = Thread.currentThread();
    TKHttp.register( myThread, this, httpInterface );
  }

  /**
   * Die Klassenvariable httpInterface wird auf null gestzt
   *
   * @param Thread myThread, es wird ein Thread-Objekt benoetigt
   */
  public void deregister()
  {
    // NDERN !!!
    //printHeaders();

    try {
      log.flush();
    }
    catch( Exception e ) {
        CATEGORY.error( "deregister: ", e);
      }
      finally
      {
      TKHttp.deregister( myThread );
    }
  }

  /**
   * 1.  TK-Parameter der URL werden geholt
   * 2.   Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
   *    zum Setzen und Erhalten von TK-Parametern. Eine Applikation, die diesen
   *    Thread erzeugt benutzt die methoden des Objekts param folgendermassen:
   *    params.methodenname()
   * 3.   Ein Obkekt der Klasse TKVector wird erzeugt und ihm wird der Content-type
   *    als Element abgelegt.
   */
  public void init()
  {
    /*
    pureParams = httpInterface.getParams();
    params = new TKParams( pureParams );
    headers = new TKHashtable();
    headers.put( "Content-type", "text/html;charset=ISO-8859-1" );
    */
  }



  /**
   * 1.   Das aktuelle Event wird geholt
   * 2.   Der Applikation, die dieses Thread erzeugt (bzw ein Obkekt der Klasse
   *    TKHttpSessionThread, die von dieser Klasse abgeleitet ist) und eine
   *    Methode handleEvent(String event) beinhaltet, kann den jeweiligen Event
   *    abarbeiten.
   *    Die Methode handleEvent() existiert in der Klasse TKHttpThread als
   *     abstrakte Methode und wird in der eigentlichen Applikation implementiert.
   */
  public void start()
  {
    try {
      TKEvent event =  handler.createEvent(httpInterface);
      /*
      TKHashtable evClass = params.getClass( "EV" );
      Enumeration evEnum = ( evClass != null ? evClass.keys() : null );
      String event = ( evEnum != null && evEnum.hasMoreElements() ? (String) evEnum.nextElement() : null );
      */
      handleEvent( event );
      event.consume();
    }
      catch( Throwable e ) {
        log.println( "message: "+e.getMessage() );
        e.printStackTrace( log );
      }
  }

  /**
   * Definition der run()-Methode
   * 1.   Klassenvariable httpInterface wird gesetzt
   * 2.   Das Objekt params der Klasse TKParams wird erzeugt und stellt Methoden
   *    zum Setzen und Erhalten von TK-Parametern.
   * 3.  Der Methode handleEvent() wird der jeweilige Event uebergeben.
   * 4.  Klassenvariable httpInterface wird wieder auf null gesetzt.
   */
  public void run()
  {
            //perfAPI.clear();
    register();
    // init();
    start();
    deregister();
                //perfAPI.save("TKHttpThread_run");
  }

  /**
   *  Als Parameter wird im template das SELF gesetzt.
   *  Aufruf: TKTemplate einTemplate = prepTemplate( new TKTemplate(TemplateName));
   *
   * @return ein vorpraeperiertes Template.
   */
  public TKHTMLTemplate prepTemplate( TKHTMLTemplate t )
  {
    t.set( "SELF", httpInterface.getOwnURL() );
    t.setAppName( httpInterface.getOwnName() );
    return t;
  }

  /**
   * Ein Objekt der Klasse TKForm wird erzeugt.
   * Aufruf:TKForm eineForm = newForm(Pfad/TemplateName)
   *
   * @param ein Template-Objekt
   */
   /*
  public TKForm newForm( TKHTMLTemplate t )
  {
    return new TKForm( params, prepTemplate( t ) );
  }
  */
  /**
   * Der abstrakten Methode handleEvent wird der aktuelle Event als String
   * uebergeben. Die eigentliche implementierung der methode erfolg in der
   * zu erstellenden Applikation.
   *
   *  @param String event, der aktuell abzuarbeitende Event
   */
  public void handleEvent( TKEvent event ) throws Exception
  {
    handler.handleEvent(event);
  }


  /**
   * Parameter eines URL sollen an ein Frame-Template weitergeleitet werden.
   *
   * @return result, Parameter des URL's
   */
   /*
  public String getParamsString()
  {
    String result = "";
    if( pureParams == null ) return result;

    TKUrlConverter encoder = new TKUrlConverter();

    Enumeration keys = pureParams.keys();
    while( keys.hasMoreElements() ) {
      String key = keys.nextElement().toString();
      Object val = pureParams.get( key );
      String valStr = ( val == null ? "" : val.toString() );
      byte[] encoded = new byte[ encoder.minByteSize( key.length() + valStr.length() ) ];
      if( !key.regionMatches( true, 0, "TK_EV[", 0, 6 ) ) {
        result += "&" + new String( encoded, 0, 0, encoder.charsToBytes( key.toCharArray(), encoded, 0, key.length(), 0 ) ) + "=";
        //TKHttp.println( "length of key ("+key+") = "+count+"/"+key.length() );
        if( valStr.length() > 0 ) {
          result += new String( encoded, 0, 0, encoder.charsToBytes( valStr.toCharArray(), encoded, 0, valStr.length(), 0 ) );
        }
      }
    }
    return result;
  }
  */
}