package javacodebook.xml.transport.http.get;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

/**
 * Der XMLGetSender erweitert das HttpServlet und implementiert
 * die doGet-Methode.  Für jeden empfangenen Get-Request wird ein
 * http-Parameter namens 'fileName' ausgelesen, der den absoluten
 * Pfad zu einer XML-Datei beschreibt.  Im weiteren Verlauf der
 * doGet-Methode wird diese Datei gelesen und zum Client geschrieben.
 */
public class XMLGetSender
    extends HttpServlet {

  // Dadurch, dass die doGet-Methode überschrieben wird, unterstützt dass Servlet
  // die http-get-Methode.
  public void doGet(HttpServletRequest request, HttpServletResponse response) throws
      ServletException, IOException {

    // Auslesen des Parameters 'fileName'.
    String fileName = request.getParameter("fileName");

    // Es wird ein Printwriter auf Basis eines Writer-Objektes von der HttpResponse
    // instanziiert über den die Antwort zurück zum Client geschrieben wird.
    PrintWriter pw = new PrintWriter(response.getWriter());

    // Die Antwort ist vom Content-Type "text/xml"
    response.setContentType("text/xml");

    try {
      // Es wird die entsprechende Datei im Dateisystem gesucht und ein BufferedReader-
      // Objekt zum lesen der Datei erzeugt.
      FileInputStream fis = new FileInputStream(fileName);
      BufferedReader br = new BufferedReader(new InputStreamReader(fis));

      System.out.println("Folgendes Dokument wird zum Client geschickt:\n");

      String line = null;

      // Nun wird der Inhalt der Datei zum Client und zur Kontrolle auch
      // in die Standardausgabe geschrieben.
      while ( (line = br.readLine()) != null) {
        pw.println(line);
        System.out.println(line);
      }
    }

    // Falls bei der Verarbeitung ein Ausnahmefall auftritt, wird eine
    // XML-Nachricht zum Client zurück geschrieben, wobei in
    // diesem Beispiel der Fehlercode -1 für den Ausnahmefall steht.
    // Innerhalb des message-Elements wird die Fehlermeldung eingefügt.
    catch (Exception e) {
      pw.println("<message code=\"-1\">" + e.toString() + "</message>");
    }
    System.out.println("\nhttp-get-Request bearbeitet\n\n");
  }
}

--- Neue Klasse ---

package javacodebook.xml.transport.http.get;

import java.net.*;
import java.io.*;

/**
 * Die XMLGetter-Klasse benutzt ein URL-Objekt um XML-Dokumente von beliebigen Urls, die z.B.
 * über die Kommandozeile übergebenen werden, abzurufen.  Dabei wird die http-get-Methode verwendet.
 */
public class XMLGetter {
  private static final String USAGE =
      "\nBenutzerhinweis: javacodebook.xml.transport.http.get.XMLGetter " +
      "<url> <dateiName> [<dateiName> ...]\n\nwobei \n\n<url>\n" +
      "die URL ist, von der die XML-Dokumente geholt werden sollen und\n\n<dateiName> [<dateiName> ...]\n" +
      "ein oder mehrere durch Leerzeichen getrennte Namen von XML-Dateien sind, die \n" +
      "per get von der URL geholt werden sollen";

  /**
   * An die main-Methode müssen die Parameter <url> und eine durch Leerzeichen getrennte Folge von
   * Dateinamen <dateiName> [<dateiName> ...] übergeben werden.  Es wird ein Objekt vom Typ XMLGetter instanziiert.
   * Der erste Parameter wird als URL ausgelesen.  Für jeden weiteren Paramter wird versucht, eine entsprechende
   * Datei von der zuvor ausgelesenen URL zu holen.
   */
  public static void main(String args[]) {
    if (args.length < 2) {
      System.out.println(getUsage());
      System.exit(1);
    }
    else {
      String urlString = args[0];
      XMLGetter xMLGetter = new XMLGetter();
      for (int i = 1; i < args.length; i++) {
        String fileName = args[i];
        try {
          String xml = xMLGetter.getXMLFromURL(fileName, urlString);
        }
        catch (Exception e) {
          System.out.println("Probleme bei der Ausführung: " + e);
        }
      }
    }
  }

  private String getXMLFromURL(String fileName, String urlString) throws
      Exception {
    String documentReceived = "";
    try {
      // Instanziierung eines URL-Objektes nach RFC 2396: Uniform Resource Identifiers (URI): 'Generic Syntax'
      // nachgebessert durch RFC 2732: 'Format for Literal IPv6 Addresses in URLs'.
      // Der Datei-Name wird dabei als HTTP-Parameter namens 'fileName' übergeben.
      URL url = new URL(urlString + "?fileName=" + fileName);

      // Durch das Aufrufen, der openStream-Methode auf das URL-Objekt wird der
      // HTTP-Request beim Server abgesetzt und ein InputStream erzeugt, der die
      // Antwort kapselt.
      InputStream is = url.openStream();

      // Nun wird die Antwort ausgelesen
      InputStreamReader isr = new InputStreamReader(is);
      BufferedReader br = new BufferedReader(isr);
      String line = null;
      while ( (line = br.readLine()) != null) {
        documentReceived = documentReceived + line;
      }
      // Auch hier muss der InputStreamReader und somit der InputStream wieder geschlossen werden, da es sonst
      // zu Resourcenverschwendung kommt.  Besonders auf Solaris-Systemen kann das fatale Folgen haben, da für jeden
      // nicht geschlossenen InputStream ein File-Descriptor offen gehalten wird und die Zahl der erlaubten offenen
      // File-Descriptoren oft relativ eingeschränkt ist.
      isr.close();

      // Nun kann das empfangene Dokument verarbeitet werden
      System.out.println(
          "\n\nFolgendes Dokument wurde vom Server empfangen:\n " +
          documentReceived);
    }
    catch (Exception e) {
      throw new Exception("Probleme beim aufrufen der URL '" + urlString +
                          "' mit: " + e);
    }
    return documentReceived;
  }

  public static String getUsage() {
    return USAGE;
  }
}