Erzeugung von dynamischem XML-Code

package com.oreilly.forum.domain;

import java.util.Iterator;

/**
 * Informationen über das Nachrichten-Board.
 */
public interface BoardSummary {
  /**
   * @return eine eindeutige ID des Boards.
   */
  long getID( );
  
  /**
   * @return einen Namen für dieses Board.
   */
  String getName( );
  
  /**
   * @return eine Beschreibung dieses Boards.
   */
  String getDescription( );
  
  /**
   * @return einen Iterator von Objekten des Typs <code>MonthYear</code>.
   */
  Iterator getMonthsWithMessages( );
}

package com.oreilly.forum.domain;

import java.util.*;
/**
 * Informationen über eine Nachricht, ausgenommen dem Nachrichtentext.
 */
public interface MessageSummary extends Comparable {
  
  /**
   * @return die ID der Nachricht, auf die geantwortet wurde, oder
   * -1, wenn dies keine Antwort ist.
   */
  long getInReplyTo( );
  
  /**
   * @return die eindeutige ID der Nachricht.
   */
  long getID( );
  
  /**
   * @return wann diese Nachricht erzeugt wurde.
   */
  DayMonthYear getCreateDate( );
  
  /**
   * @return das Board, zu dem diese Nachricht gehört.
   */
  BoardSummary getBoard( );
  
  /**
   * @return der Betreff der Nachricht.
   */
  String getSubject( );
  
  /**
   * @return die E-Mail-Adresse des Autors (max. 80 Zeichen).
   */
  String getAuthorEmail( );
}

package com.oreilly.forum.domain;

/**
 * Repräsentiert eine Nachricht einschließlich des Nachrichtentexts.
 */
public interface Message extends MessageSummary {
  /**
   * @return der Text der Nachricht.
   */
  String getText( );
}

package com.oreilly.forum.domain;

import java.util.*;

/**
 * Arrangiert eine Sammlung von MessageSummary-Objekten in einer Baumstruktur.
 */
public class MessageTree {
  private List topLevelMsgs = new ArrayList( );
  
  // bilde IDs auf MessageSummary-Objekte ab
  private Map idToMsgMap = new HashMap( );
  
  // bilde Antwort-IDs auf Listen von MessageSummary-Objekten ab
  private Map replyIDToMsgListMap = new HashMap( );
  
  /**
   * Erzeuge einen neuen Nachrichtenbaum aus einem Iterator von MessageSummary-
   * Objekten.
   */
  public MessageTree(Iterator messages) {
    while (messages.hasNext( )) {
      // Speichere Nachrichten in einer Map, für einen schnellen ID-Zugriff
      MessageSummary curMsg = (MessageSummary) messages.next( );
      this.idToMsgMap.put(new Long(curMsg.getID( )), curMsg);
      
      // erzeuge eine invertierte Map, die Antwort-IDs auf
      // Listen von Nachrichten abbildet
      Long curReplyID = new Long(curMsg.getInReplyTo( ));
      List replyToList =
          (List) this.replyIDToMsgListMap.get(curReplyID);
      if (replyToList == null) {
        replyToList = new ArrayList( );
        this.replyIDToMsgListMap.put(curReplyID, replyToList);
      }
      replyToList.add(curMsg);
    }
  
    // Erzeuge die Liste von Top-Level-Nachrichten, die
    // eine der folgenden Kriterien erfüllen müssen:
    // - ihre Antwort-ID ist -1
    // - ihre Antwort-ID wurde nicht in der Liste von Nachrichten gefunden. Das
    // ist der Fall, wenn es sich um eine Antwort auf eine Nachricht des
    // Vormonats handelt
    Iterator iter = this.replyIDToMsgListMap.keySet().iterator( );
    while (iter.hasNext( )) {
      Long curReplyToID = (Long) iter.next( );
      if (curReplyToID.longValue( ) == -1
        || !this.idToMsgMap.containsKey(curReplyToID)) {
      List msgsToAdd =
        (List) this.replyIDToMsgListMap.get(curReplyToID);
      this.topLevelMsgs.addAll(msgsToAdd);
      }
    }
    Collections.sort(this.topLevelMsgs);
  }

  public Iterator getTopLevelMessages( ) {
    return this.topLevelMsgs.iterator( );
  }

  /**
   * @return einen Iterator von MessageSummary-Objekten der Antworten auf
   * die übergebene Nachricht.
   */
  public Iterator getReplies(MessageSummary msg) {
    List replies = (List) this.replyIDToMsgListMap.get(
      new Long(msg.getID( )));
    if (replies != null) {
      Collections.sort(replies);
      return replies.iterator( );
    } else {
      return Collections.EMPTY_LIST.iterator( );
    }
  }
}

public interface MessageSummary extends Comparable {
   ...
   long getInReplyTo( );
   ...
 }

private List topLevelMsgs = new ArrayList( );
private Map idToMsgMap = new HashMap( );
private Map replyIDToMsgListMap = new HashMap( );

package com.oreilly.forum;

/**
 * Definiert Konfigurationsinformationen der Anwendung. Das Servlet
 * muß die Methode setValues( ) aufrufen, bevor eine der get-
 * Methoden dieser Klasse verwendet werden kann.
 */
public class ForumConfig {
  // Maximalgrößen verschiedener Felder in der Datenbank
  public static final int MAX_BOARD_NAME_LEN = 80;
  public static final int MAX_BOARD_DESC_LEN = 255;
  public static final int MAX_MSG_SUBJECT_LEN = 80;
  public static final int MAX_EMAIL_LEN = 80;
  
  private static String jdbcDriverClassName;
  private static String databaseURL;
  private static String adapterClassName;
  
  public static void setValues( 
    String jdbcDriverClassName,
    String databaseURL,
    String adapterClassName) {
    ForumConfig.jdbcDriverClassName = jdbcDriverClassName;
    ForumConfig.databaseURL = databaseURL;
    ForumConfig.adapterClassName = adapterClassName;
  }
  
  /**
   * @return der Klassenname des JDBC-Treibers.
   */
  public static String getJDBCDriverClassName( ) {
    return ForumConfig.jdbcDriverClassName;
  }
  
  /**
   * @return die URL der JDBC-Datenbank.
   */
  public static String getDatabaseURL( ) {
    return ForumConfig.databaseURL;
  }
  
  /**
   * @return den Klassennamen der Datenabstraktionsimplementierung.
   */
  public static String getAdapterClassName( ) {
    return ForumConfig.adapterClassName;
  }
  
  private ForumConfig( ) {
  }
}

package com.oreilly.forum.adapter;

import com.oreilly.forum.*;
import com.oreilly.forum.domain.*;
import java.util.*;

/**
 * Definiert die Schnittstelle zur Datenquelle.
 */
public abstract class DataAdapter {
  private static DataAdapter instance;
  
  /**
   * @return die einzige Instanz dieser Klasse.
   */
  public static synchronized DataAdapter getInstance( )
      throws DataException {
    if (instance == null) {
      String adapterClassName = ForumConfig.getAdapterClassName( );
      try {
        Class adapterClass = Class.forName(adapterClassName);
        instance = (DataAdapter) adapterClass.newInstance( );
      } catch (Exception ex) {
        throw new DataException("Kann nicht instantiieren: "
            + adapterClassName);
      }
    }
    return instance;
  }

  /**
   * @param msgID muß eine gültige Nachrichten-ID sein.
   * @return die Nachricht mit der spezifizierten ID.
   * @throws DataException, falls die msgID nicht existiert oder ein Fehler
   * in der Datenbank auftritt.
   */
  public abstract Message getMessage(long msgID) throws DataException;

  /**
   * Füge eine Antwort auf eine bestehende Nachricht ein.
   *
   * @throws DataException, wenn ein Fehler in der Datenbank auftritt oder
   * ein Parameter ungültig ist.
   */
  public abstract Message replyToMessage(long origMsgID, String msgSubject,
    String authorEmail, String msgText) throws DataException;

  /**
   * Versende eine neue Nachricht.
   *
   * @return die neu erzeugte Nachricht.
   * @throws DataException, wenn ein Fehler in der Datenbank auftritt oder
   * ein Parameter ungültig ist.
   */
  public abstract Message postNewMessage(long boardID, String msgSubject,
    String authorEmail, String msgText) throws DataException;

  /**
   * Liefere einen leeren Iterator, wenn für das angegebene Board
   * und den Monat keine Nachricht existiert.
   * @return einen Iterator von <code>MessageSummary</code>-Objekten.
   * @throws DataException, wenn die boardID ungültig ist oder ein Fehler in
   * der Datenbank auftritt.
   */
  public abstract Iterator getAllMessages(long boardID, MonthYear month)
    throws DataException;

  /**
   * @return einen Iterator über alle <code>BoardSummary</code>-Objekte.
   */
  public abstract Iterator getAllBoards( ) throws DataException;

  /**
   * @return eine Zusammenfassung des Boards mit der angegebenen ID.
   * @throws DataException, wenn die boardID ungültig ist oder ein Fehler in
   * der Datenbank auftritt.
   */
  public abstract BoardSummary getBoardSummary(long boardID)
    throws DataException;
}

String adapterClassName = ForumConfig.getAdapterClassName( );
try {
  Class adapterClass = Class.forName(adapterClassName);
  instance = (DataAdapter) adapterClass.newInstance( );
} catch (Exception ex) {
  throw new DataException("Kann nicht instantiieren: "
    + adapterClassName);
}

public abstract Message getMessage(long msgID) throws DataException;

SELECT subject
FROM Message
WHERE createMonth=3 AND createYear=2001

# MySQL dump 8.8
#
# Host: localhost Database: forum
#--------------------------------------------------------
# Server version3.23.23-beta

#
# Struktur der Tabelle 'board'
#

CREATE TABLE board (
  id bigint(20) DEFAULT '0' NOT NULL,
  name char(80) DEFAULT '' NOT NULL,
  description char(255) DEFAULT '' NOT NULL,
  PRIMARY KEY (id)
);

#
# Füllen der Tabelle 'board'
#

INSERT INTO board VALUES (0,'XSLT Grundlagen','XSLT-Stylesheets und -Prozessoren');
INSERT INTO board VALUES (1,'JAXP: Programmiertechniken','JAXP 1.1 verwenden');

#
# Struktur der Tabelle 'message'
#

CREATE TABLE message (
  id bigint(20) DEFAULT '0' NOT NULL,
  inReplyToID bigint(20) DEFAULT '0' NOT NULL,
  createMonth int(11) DEFAULT '0' NOT NULL,
  createDay int(11) DEFAULT '0' NOT NULL,
  createYear int(11) DEFAULT '0' NOT NULL,
  boardID bigint(20) DEFAULT '0' NOT NULL,
  subject varchar(80) DEFAULT '' NOT NULL,
  authorEmail varchar(80) DEFAULT '' NOT NULL,
  msgText text DEFAULT '' NOT NULL,
  PRIMARY KEY (id),
  KEY inReplyToID (inReplyToID),
  KEY createMonth (createMonth),
  KEY createDay (createDay),
  KEY boardID (boardID)
);

package com.oreilly.forum.jdbcimpl;

import java.io.*;
import java.sql.*;
import java.util.*;

/**
 * Hilfsmethoden für den Zugriff auf eine relationale Datenbank mit JDBC.
 */
public class DBUtil {
  
  // Eine Abbildung von Tabellennamen auf maximale ID-Nummern
  private static Map tableToMaxIDMap = new HashMap( );
  
  /**
   * Beende eine Anweisung und Verbindung.
   */
  public static void close(Statement stmt, Connection con) {
    if (stmt != null) {
      try {
        stmt.close( );
      } catch (Exception ignored1) {
      }
    }
    if (con != null) {
      try {
        con.close( );
      } catch (Exception ignored2) {
      }
    }
  }
  
  /**
   * @return eine neue Verbindung zur Datenbank.
   */
  public static Connection getConnection(String dbURL)
      throws SQLException {
    // Vorschlag: die Implementierung eines Verbindungs-Pools wäre eine
    // sinnvolle Erweiterung
    return DriverManager.getConnection(dbURL);
  }
  
  /**
   * Beende alle offenen Verbindungen. Das Servlet ruft
   * diese Methode aus seiner Methode destroy( ) auf.
   */
  public static void closeAllConnections( ) {
    // sollte einmal ein Verbindungs-Pool implementiert werden, müssen
    // die Verbindungen hier beendet werden.
  }
  
  /**
   * Speichere einen langen Text in der Datenbank. Der Text einer Nachricht
   * ist z.B. zu lang, um mit der Methode setString() von JDBC
   * gespeichert zu werden.
   */
  public static void setLongString(PreparedStatement stmt,
      int columnIndex, String data) throws SQLException {
    if (data.length( ) > 0) {
      stmt.setAsciiStream(columnIndex,
        new ByteArrayInputStream(data.getBytes( )),
        data.length( ));
    } else {
      // Dieser 'else'-Zweig wurde eingeführt, weil der Code von
      // 'setAsciiStream' bei MS Access dazu führt, daß ein
      // "function sequence error" auftritt, wenn die String-Länge
      // null ist.
      stmt.setString(columnIndex, "");
    }
  }
  /**
   * @return ein langes Textfeld aus der Datenbank.
   */
  public static String getLongString(ResultSet rs, int columnIndex)
      throws SQLException {
    try {
      InputStream in = rs.getAsciiStream(columnIndex);
      if (in == null) {
        return "";
      }
        
      byte[] arr = new byte[250];
      StringBuffer buf = new StringBuffer( );
      int numRead = in.read(arr);
      while (numRead != -1) {
        buf.append(new String(arr, 0, numRead));
        numRead = in.read(arr);
      }
      return buf.toString( );
    } catch (IOException ioe) {
      ioe.printStackTrace( );
      throw new SQLException(ioe.getMessage( ));
    }
  }
  /**
   * Berechne eine neue eindeutige ID. Es wird angenommen, daß in der
   * spezifizierten Tabelle die Spalte 'id' vom Typ 'long' existiert.
   * Jeder Programmteil muß diese Methode verwenden, um neue IDs zu erzeugen.
   * @return die nächste verfügbare eindeutige ID für die Tabelle
   */
  public static synchronized long getNextID(String tableName,
      Connection con) throws SQLException {
    Statement stmt = null;
        
    try {
      // wenn das Maximum bereits aus der Tabelle ausgelesen wurde,
      // berechne die nächste ID, ohne in der Datenbank nachzuschauen
      if (tableToMaxIDMap.containsKey(tableName)) {
        Long curMax = (Long) tableToMaxIDMap.get(tableName);
        Long newMax = new Long(curMax.longValue( ) + 1L);
        tableToMaxIDMap.put(tableName, newMax);
        return newMax.longValue( );
      }
      stmt = con.createStatement( );
      ResultSet rs = stmt.executeQuery(
        "SELECT MAX(id) FROM " + tableName);
      long max = 0;
      if (rs.next( )) {
        max = rs.getLong(1);
      }
      max++;
      tableToMaxIDMap.put(tableName, new Long(max));
      return max;
    } finally {
      // beende die Anweisung
      close(stmt, null);
    }
  }
}

Connection con = null;
Statement stmt = null;
try {
    // Code zum Aufbau der Verbindung und der Anweisung
    ...
    // Zugriff auf die Datenbank
    ...
} finally {
    DBUtil.close(stmt, con);
}

public static Connection getConnection(String dbURL)

package com.oreilly.forum.jdbcimpl;

import com.oreilly.forum.*;
import com.oreilly.forum.adapter.*;
import com.oreilly.forum.domain.*;
import java.sql.*;
import java.util.*;

/**
 * Eine Implementierung von DataAdapter für JDBC.
 */
public class JdbcDataAdapter extends DataAdapter {
  
  private static String dbURL = ForumConfig.getDatabaseURL( );
  /**
   * Konstruiere den Datenadapter und lade den JDBC-Treiber.
   */
  public JdbcDataAdapter( ) throws DataException {
    try {
      Class.forName(ForumConfig.getJDBCDriverClassName( ));
    } catch (Exception ex) {
      ex.printStackTrace( );
      throw new DataException("Der JDBC-Treiber kann nicht geladen werden: "
        + ForumConfig.getJDBCDriverClassName( ));
    }
  }
  
  /**
   * @param msgID muß eine gültige Nachrichten-ID sein.
   * @return die Nachricht mit der angegebenen ID.
   * @throws DataException, wenn die msgID nicht existiert oder ein
   * Datenbankfehler auftritt.
   */
  public Message getMessage(long msgID) throws DataException {
    Connection con = null;
    Statement stmt = null;
    try {
      con = DBUtil.getConnection(dbURL);
      stmt = con.createStatement( );
      ResultSet rs = stmt.executeQuery(
        "SELECT inReplyToID, createDay, createMonth, createYear, "
        + "boardID, subject, authorEmail, msgText "
        + "FROM Message WHERE id="
        + msgID);
      if (rs.next( )) {
        long inReplyToID = rs.getLong(1);
        int createDay = rs.getInt(2);
        int createMonth = rs.getInt(3);
        int createYear = rs.getInt(4);
        long boardID = rs.getLong(5);
        String subject = rs.getString(6);
        String authorEmail = rs.getString(7);
        String msgText = DBUtil.getLongString(rs, 8);
        
        BoardSummary boardSummary = this.getBoardSummary(boardID, stmt);
        
        return new MessageImpl(msgID,
          new DayMonthYear(createDay, createMonth, createYear),
          boardSummary, subject, authorEmail, msgText,
          inReplyToID);
      } else {
        throw new DataException("Ungültige msgID");
      }
      } catch (SQLException sqe) {
        sqe.printStackTrace( );
        throw new DataException(sqe.getMessage( ));
      } finally {
        DBUtil.close(stmt, con);
      }
    }
    /**
     * Füge eine Antwort auf eine bestehende Nachricht ein.
     * @throws DataException, wenn ein Datenbankfehler auftritt oder
     * ein Parameter ungültig ist.
     */
    public Message replyToMessage(long origMsgID,
        String msgSubject, String authorEmail, String msgText)
        throws DataException {
      Message inReplyToMsg = this.getMessage(origMsgID);
      return insertMessage(inReplyToMsg.getBoard( ), origMsgID,
        msgSubject, authorEmail, msgText);
          
    }
    /**
     * Versende eine neue Nachricht.
     *
     * @return die neue Nachricht.
     * @throws DataException, wenn ein Datenbankfehler auftritt oder
     * ein Parameter ungültig ist.
     */
  
    public Message postNewMessage(long boardID, String msgSubject,
        String authorEmail, String msgText) throws DataException {
        
      BoardSummary board = this.getBoardSummary(boardID);
      return insertMessage(board, -1, msgSubject, authorEmail, msgText);
    }
  
    /**
     * Liefere einen leeren Iterator zurück, wenn für das Board und den Monat
     * keine Nachricht existiert
     * @return einen Iterator von Objekten des Typs <code>MessageSummary</code>.
     * @throws DataException, wenn die Board-ID ungültig ist oder ein
     * Datenbankfehler auftritt.
     */
    public Iterator getAllMessages(long boardID, MonthYear month)
        throws DataException {
      List allMsgs = new ArrayList( );
          
      Connection con = null;
      Statement stmt = null;
      try {
        con = DBUtil.getConnection(dbURL);
        stmt = con.createStatement( );
        
        BoardSummary boardSum = this.getBoardSummary(boardID, stmt);
        
        ResultSet rs = stmt.executeQuery(
          "SELECT id, inReplyToID, createDay, "
          + "subject, authorEmail "
          + "FROM Message WHERE createMonth="
          + month.getMonth( )
          + " AND createYear="
          + month.getYear( )
          + " AND boardID="
          + boardID);
        
       while (rs.next( )) {
         long msgID = rs.getLong(1);
         long inReplyTo = rs.getLong(2);
         int createDay = rs.getInt(3);
         String subject = rs.getString(4);
         String authorEmail = rs.getString(5);
         
         DayMonthYear createDMY = new DayMonthYear(
           createDay, month.getMonth(), month.getYear( ));
         
         allMsgs.add(new MessageSummaryImpl(msgID, createDMY,
           boardSum,
           subject, authorEmail, inReplyTo));
       }
       return allMsgs.iterator( );
     } catch (SQLException sqe) {
       sqe.printStackTrace( );
       throw new DataException(sqe);
     } finally {
       DBUtil.close(stmt, con);
     }
   }
  
  /**
   * @return einen Iterator aller Objekte des Typs <code>BoardSummary</code>.
   */
  public Iterator getAllBoards( ) throws DataException {
    List allBoards = new ArrayList( );
    
    Connection con = null;
    Statement stmt = null;
    Statement stmt2 = null;
    try {
      con = DBUtil.getConnection(dbURL);
      stmt = con.createStatement( );
      stmt2 = con.createStatement( );
      ResultSet rs = stmt.executeQuery(
        "SELECT id, name, description FROM Board "
        + "ORDER BY name");
      
      while (rs.next( )) {
        long id = rs.getLong(1);
        String name = rs.getString(2);
        String description = rs.getString(3);
        
        // Hole die Monate mit Nachrichten. Es wird ein anderes
        // Objekt für die Anweisung benutzt, weil das Ergebnis-Set
        // der ersten Anweisung bearbeitet wird.
        // List monthsWithMessages =
          this.getMonthsWithMessages(id, stmt2);
        
        allBoards.add(new BoardSummaryImpl(id, name, description,
          monthsWithMessages));
      }
      return allBoards.iterator( );
    } catch (SQLException sqe) {
      sqe.printStackTrace( );
      throw new DataException(sqe);
    } finally {
      if (stmt2 != null) {
        try {
          
          stmt2.close( );
        } catch (SQLException ignored) {
        }
      }
      DBUtil.close(stmt, con);
    }
  }
  
  /**
   * @return eine Zusammenfassung des Boards mit der übergebenen ID.
   * @throws DataException, wenn die boardID ungültig ist oder
   * ein Datenbankfehler auftritt.
   */
  public BoardSummary getBoardSummary(long boardID)
      throws DataException {
    Connection con = null;
    Statement stmt = null;
    try {
      con = DBUtil.getConnection(dbURL);
      stmt = con.createStatement( );
      return getBoardSummary(boardID, stmt);
    } catch (SQLException sqe) {
      sqe.printStackTrace( );
      throw new DataException(sqe);
    } finally {
      DBUtil.close(stmt, con);
    }
  }
  
  private BoardSummary getBoardSummary(long boardID, Statement stmt)
      throws DataException, SQLException {
    ResultSet rs = stmt.executeQuery(
      "SELECT name, description FROM Board WHERE id=" + boardID);
        
    if (rs.next( )) {
      String name = rs.getString(1);
      String description = rs.getString(2);
      
      List monthsWithMessages = getMonthsWithMessages(boardID, stmt);
      
      return new BoardSummaryImpl(boardID, name, description,
        monthsWithMessages);
    } else {
      throw new DataException("Unbekannte boardID");
    }
  }
  
  /**
   * @return eine Liste von Objekten des Typs MonthYear
   */
  private List getMonthsWithMessages(long boardID, Statement stmt)
      throws SQLException {
        
    List monthsWithMessages = new ArrayList( );
    ResultSet rs = stmt.executeQuery(
      "SELECT DISTINCT createMonth, createYear "
      + "FROM Message "
      + "WHERE boardID=" + boardID);
    while (rs.next( )) {
      monthsWithMessages.add(new MonthYear(
        rs.getInt(1), rs.getInt(2)));
    }
    return monthsWithMessages;
  }
  
  private Message insertMessage(BoardSummary board, long inReplyToID,
      String msgSubject, String authorEmail,
      String msgText) throws DataException {
    // verhindere einen Überlauf der maximalen Spaltenbreite der Datenbank
    if (msgSubject.length( ) > ForumConfig.MAX_MSG_SUBJECT_LEN) {
      msgSubject = msgSubject.substring(0,
        ForumConfig.MAX_MSG_SUBJECT_LEN);
    }
    if (authorEmail.length( ) > ForumConfig.MAX_EMAIL_LEN) {
      authorEmail = authorEmail.substring(0,
        ForumConfig.MAX_EMAIL_LEN);
    }

    DayMonthYear createDate = new DayMonthYear( );

    Connection con = null;
    PreparedStatement stmt = null;
    try {
      con = DBUtil.getConnection(dbURL);
      long newMsgID = DBUtil.getNextID("Message", con);
      stmt = con.prepareStatement("INSERT INTO Message "
        + "(id, inReplyToID, createMonth, createDay, createYear, "
        + "boardID, subject, authorEmail, msgText) "
        + "VALUES (?,?,?,?,?,?,?,?,?)");
      stmt.setString(1, Long.toString(newMsgID));
      stmt.setString(2, Long.toString(inReplyToID));
      stmt.setInt(3, createDate.getMonth( ));
      stmt.setInt(4, createDate.getDay( ));
      stmt.setInt(5, createDate.getYear( ));
      stmt.setString(6, Long.toString(board.getID( )));
      stmt.setString(7, msgSubject);
      stmt.setString(8, authorEmail);
      DBUtil.setLongString(stmt, 9, msgText);
      stmt.executeUpdate( );
      
      return new MessageImpl(newMsgID, createDate,
        board, msgSubject, authorEmail,
        msgText, inReplyToID);
      
    } catch (SQLException sqe) {
      sqe.printStackTrace( );
      throw new DataException(sqe);
    } finally {
      DBUtil.close(stmt, con);
    }
  }
}

private static String dbURL = ForumConfig.getDatabaseURL( );
/**
* Erzeuge den Datenadapter und lade den JDBC-Treiber.
*/
public JdbcDataAdapter( ) throws DataException {
  try {
    Class.forName(ForumConfig.getJDBCDriverClassName( ));
  } catch (Exception ex) {
    ex.printStackTrace( );
    throw new DataException("JDBC-Treiber kann nicht geladen werden: "
        + ForumConfig.getJDBCDriverClassName( ));
  }
}

Connection con = null;
try {
    con = DBUtil.getConnection(dbURL);

} finally {
   DBUtil.close(stmt, con);
}

package com.oreilly.forum.xml;

import com.oreilly.forum.domain.*;
import java.util.*;
import org.jdom.*;

/**
 * Erzeuge die JDOM-Daten für die Homepage.
 */
public class HomeJDOM {
  
  /**
   * @param boards ein Iterator von <code>BoardSummary</code>-Objekten.
   */
  public static Element produceElement(Iterator boards) {
    Element homeElem = new Element("home");
    while (boards.hasNext( )) {
      BoardSummary curBoard = (BoardSummary) boards.next( );
      homeElem.addContent(BoardSummaryJDOM.produceElement(curBoard));
    }
    
    return homeElem;
  }
  
  private HomeJDOM( ) {
  }
}

Iterator boards = ...
Element homeElem = new HomeElement(boards);

BoardSummary board = ...
Element elem = board.convertToJDOM( );

package com.oreilly.forum.xml;

import java.util.*;
import com.oreilly.forum.*;
import com.oreilly.forum.adapter.*;
import com.oreilly.forum.domain.*;
import org.jdom.*;

/**
 * Erzeugt JDOM für die Monatsübersicht des Boards.
 */
public class ViewMonthJDOM {
  
  /**
   * @param board das Nachrichten-Board, für das JDOM erzeugt werden soll.
   * @param month der Monat und das Jahr, die angezeigt werden sollen.
   */
  public static Element produceElement(BoardSummary board,
      MonthYear month) throws DataException {
    Element viewMonthElem = new Element("viewMonth");
    viewMonthElem.addAttribute("month",
      Integer.toString(month.getMonth( )));
    viewMonthElem.addAttribute("year",
      Integer.toString(month.getYear( )));
        
    // erzeuge das Element <board> ...
    Element boardElem = BoardSummaryJDOM.produceNameIDElement(board);
    viewMonthElem.addContent(boardElem);
        
    DataAdapter adapter = DataAdapter.getInstance( );
        
    MessageTree msgTree = new MessageTree(adapter.getAllMessages(
      board.getID( ), month));
        
    // hole einen Iterator für die MessageSummary-Objekte
    Iterator msgs = msgTree.getTopLevelMessages( );
        
    while (msgs.hasNext( )) {
      MessageSummary curMsg = (MessageSummary) msgs.next( );
      Element elem = produceMessageElement(curMsg, msgTree);
      viewMonthElem.addContent(elem);
     }
        
     return viewMonthElem;
   }
  
   /**
    * Erzeuge ein XML-Fragment für eine bestimmte Nachricht. Das
    * ist eine rekursive Funktion.
    */
   private static Element produceMessageElement(MessageSummary msg,
       MessageTree msgTree) {
     Element msgElem = new Element("message");
     msgElem.addAttribute("id", Long.toString(msg.getID( )));
     msgElem.addAttribute("day",
       Integer.toString(msg.getCreateDate().getDay( )));
     msgElem.addContent(new Element("subject")
       .setText(msg.getSubject( )));
     msgElem.addContent(new Element("authorEmail")
       .setText(msg.getAuthorEmail( )));
         
     Iterator iter = msgTree.getReplies(msg);
     while (iter.hasNext( )) {
       MessageSummary curReply = (MessageSummary) iter.next( );
       
       // Erzeuge den XML-Code rekursiv für alle Antworten
       msgElem.addContent(produceMessageElement(curReply, msgTree));
     }
     return msgElem;
   }
  
   private ViewMonthJDOM( ) {
   }
}

package com.oreilly.forum.xml;

import com.oreilly.forum.domain.*;
import java.util.Date;
import org.jdom.*;
import org.jdom.output.*;

/**
 * Erzeuge JDOM-Daten für die Nachrichtenansicht.
 */
public class ViewMessageJDOM {
  
  /**
   * @param message die Nachricht, die angezeigt werden soll.
   * @param inResponseTo die Nachricht, auf die mit dieser geantwortet wurde,
   * bzw. null, wenn es sich um eine Top-Level-Nachricht handelt.
   */
  public static Element produceElement(Message message,
    MessageSummary inResponseTo) {
    Element messageElem = new Element("message");
    messageElem.addAttribute("id", Long.toString(message.getID( )));
    DayMonthYear d = message.getCreateDate( );
    messageElem.addAttribute("month", Integer.toString(d.getMonth( )));
    messageElem.addAttribute("day", Integer.toString(d.getDay( )));
    messageElem.addAttribute("year", Integer.toString(d.getYear( )));
      
    Element boardElem = BoardSummaryJDOM.produceNameIDElement(
      message.getBoard( ));
    messageElem.addContent(boardElem);
      
    if (inResponseTo != null) {
      Element inRespToElem = new Element("inResponseTo")
        .addAttribute("id", Long.toString(inResponseTo.getID( )));
      inRespToElem.addContent(new Element("subject")
        .setText(inResponseTo.getSubject( )));
      messageElem.addContent(inRespToElem);
    }
      
    messageElem.addContent(new Element("subject").setText(message.getSubject( )));
    messageElem.addContent(new Element("authorEmail").setText(message.getAuthorEmail( )));
    messageElem.addContent(new Element("text").setText(message.getText( )));
    return messageElem;
  }
  
  private ViewMessageJDOM( ) {
  }
}

package com.oreilly.forum.xml;

import com.oreilly.forum.domain.*;
import java.util.*;
import org.jdom.*;

/**
 * Erzeugt JDOM für ein BoardSummary-Objekt.
 */
public class BoardSummaryJDOM {
  public static Element produceNameIDElement(BoardSummary board) {
    // erzeuge das Folgende:
    // <board id="123">
    // <name>der Board-Name</name>
    // <description>eine Board-Beschreibung</description>
    // </board>
    Element boardElem = new Element("board");
    boardElem.addAttribute("id", Long.toString(board.getID( )));
    boardElem.addContent(new Element("name").setText(board.getName( )));
    boardElem.addContent(new Element("description")
      .setText(board.getDescription( )));
    return boardElem;
  }
  
  public static Element produceElement(BoardSummary board) {
    Element boardElem = produceNameIDElement(board);
    
    // füge die Liste von Nachrichten hinzu
    Iterator iter = board.getMonthsWithMessages( );
    while (iter.hasNext( )) {
      MonthYear curMonth = (MonthYear) iter.next( );
      Element elem = new Element("messages");
      elem.addAttribute("month", Integer.toString(curMonth.getMonth( )));
      elem.addAttribute("year", Integer.toString(curMonth.getYear( )));
      boardElem.addContent(elem);
    }
    
    return boardElem;
  }
  
  private BoardSummaryJDOM( ) {
  }
}

package com.oreilly.forum.xml;

import com.oreilly.forum.domain.*;
import org.jdom.*;

/**
 * Erzeuge JDOM für die Seite "Nachricht senden".
 */
public class PostMessageJDOM {
  
  public static Element produceElement(
      BoardSummary board,
      MessageSummary inResponseToMsg,
      boolean showError,
      String subject,
      String authorEmail,
      String msgText) {
    Element messageElem = new Element("postMsg");
        
    // benutze die Klasse BoardSummaryJDOM, um ein
    // XML-Fragment zu erzeugen
    messageElem.addContent(BoardSummaryJDOM.produceNameIDElement(board));
        
    if (inResponseToMsg != null) {
      Element inRespTo = new Element("inResponseTo")
        .addAttribute("id", Long.toString(inResponseToMsg.getID( )));
      inRespTo.addContent(new Element("subject")
        .setText(inResponseToMsg.getSubject( )));
      messageElem.addContent(inRespTo);
    }
        
    if (showError) {
      messageElem.addContent(new Element("error")
        .addAttribute("code", "ALL_FIELDS_REQUIRED"));
    }
        
    Element prefill = new Element("prefill");
    prefill.addContent(new Element("subject").setText(subject));
    prefill.addContent(new Element("authorEmail").setText(authorEmail));
    prefill.addContent(new Element("message").setText(msgText));
    messageElem.addContent(prefill);
        
    return messageElem;
  }
  
  private PostMessageJDOM( ) {
  }
}