Erste Schritte zu einer Webanwendung mit Tomcat, Eclipse und dem Sysdeo Eclipse Tomcat Plug-in

+ andere TechDocs
+ Webanwendungen
+ Web Services
+ Apache Tomcat
+ Eclipse.org
+


Es werden kleine Hello-World-Beispiele zu einer Webanwendung mit Eclipse, Apache Tomcat und dem Sysdeo Eclipse Tomcat Plug-in erläutert.

Die Erläuterungen beziehen sich auf Eclipse 3.1. Ab Eclipse 3.3 wird das Sysdeo Eclipse Tomcat Plug-in nicht mehr benötigt. Eine Beschreibung für Eclipse 3.3 finden Sie in jee-tomcat-eclipse.htm.

Eine Einführung in Eclipse finden Sie unter java-eclipse.htm.



Inhalt

  1. Tomcat-Installation
  2. Erstes Servlet
  3. Erste JSP (Java Server Pages)
  4. JSP mit JavaBeans
  5. SOAP Web Services mit Axis
  6. JSP als Web-Service-Client
  7. Deployment per Web Application Archive (.war-Datei)
  8. Remote Debugging
  9. Links auf weiterführende Informationen


Tomcat-Installation

  1. Installieren Sie Java und Eclipse wie beschrieben unter: java-eclipse.htm.
  2. Installieren Sie Apache Tomcat (z.B. Version 5.5.9, Datei 'jakarta-tomcat-5.5.9.zip') zum Beispiel nach 'D:\Tools\Tomcat', so wie beschrieben unter jsp-install.htm#InstallationUnterWindows.
    Für eine Entwicklungsumgebung sollten Sie vorzugsweise nicht von der Tomcat-.exe-Datei sondern besser von der Tomcat-.zip-Datei installieren.
  3. Einige Anwendungen erwarten korrekt gesetzte Umgebungsvariablen (Environment-Variablen). Sie ändern die Umgebungsvariablen unter Windows XP unter 'Start' | rechter Mausklick auf 'Arbeitsplatz' | 'Eigenschaften' | 'Erweitert' | 'Umgebungsvariablen' (unter Linux siehe linux.htm#Umgebungsvariablen).
    Benutzervariablen setzen:
    JAVA_HOMEC:\Program Files\Java\jdk1.6
    CATALINA_HOMED:\Tools\Tomcat
    Systemvariablen erweitern um:
    Path<vorherigerPath>;C:\Program Files\Java\jdk1.6\bin
    Passen Sie die Pfadangaben an Ihre Java-SDK- und '<tomcat-root>'-Verzeichnisse an.
  4. Nach dem Start des Tomcat-Servers über '<tomcat-root>/bin/startup.bat' erhalten Sie unter http://localhost:8080 (oder bei geändertem HTTP-Port unter http://localhost) die Tomcat-Begrüßungsseite.
    Stoppen Sie Tomcat mit '<tomcat-root>/bin/shutdown.bat'.
  5. Unter Eclipse ist zur Erstellung von Tomcat-WAR-Projekten das 'Sysdeo Eclipse Tomcat Plug-in' eine gute Hilfe, siehe http://www.eclipsetotale.com/tomcatPlugin.html. Downloaden Sie 'tomcatPluginV31.zip' und kopieren Sie das darin enthaltene Verzeichnis 'com.sysdeo.eclipse.tomcat_3.1.0' ins Eclipse-'plugins'-Verzeichnis (z.B. 'D:\Tools\eclipse\plugins').
  6. Setzen Sie in Eclipse alle Pfade und Einstellungen auf korrekte Werte, z.B.:
     'Window' | 'Customize Perspective...' | 'Commands' | 'Available command groups'  | Häkchen vor:  Tomcat
     'Window' | 'Preferences' | 'Tomcat'  | 'Tomcat Version':  Version 5.x
     'Window' | 'Preferences' | 'Tomcat'  | 'Tomcat Home':  D:\Tools\Tomcat
    Falls Sie auch ein JRE ohne SDK installiert haben, stellen Sie sicher, dass das SDK registriert ist:
     'Window' | 'Preferences' | '[+] Java' | 'Installed JREs'  | 'Add...' und Häkchen:  C:\Program Files\Java\jdk1.6
     'Window' | 'Preferences' | '[+] Tomcat' | 'JVM Einstellungen'  | 'JRE':  C Java jdk
  7. Jetzt können Sie den Tomcat-Server in Eclipse über den Menüpunkt 'Tomcat' (bzw. über die drei Katzensymbole) starten und beenden.
  8. Wenn Sie das 'Sysdeo Eclipse Tomcat Plug-in' installiert haben, wählen Sie in Eclipse für ein Tomcat-Projekt: 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project'.
  9. Eventuell benötigen Sie weitere Bibliotheken, die downgeloaded und hinzugefügt werden müssen, zum Beispiel nach '<tomcat-root>/common/lib' oder in das '<tomcat-root>/webapps/<MeinWebProjekt>/WEB-INF/lib'-Projektverzeichnis.
  10. Dokumentation finden Sie auf Ihrer Festplatte
    zu Tomcat unter <tomcat-root>\webapps\tomcat-docs\index.html,
    zu Servlet/JSP unter <tomcat-root>\webapps\tomcat-docs\servletapi\index.html
    und im Web unter den unten genannten Javadoc-Links.


Erstes Servlet

  1. Installieren Sie Tomcat und das Sysdeo Eclipse Tomcat Plug-in wie oben beschrieben.
    Starten Sie Tomcat in Eclipse über 'Tomcat' | 'Tomcat starten', stellen Sie sicher, dass http://localhost:8080 eine korrekte Webseite anzeigt und stoppen Sie Tomcat über 'Tomcat' | 'Tomcat beenden'.
  2. Wählen Sie 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project' | 'Next' | 'Project name = MyFirstServlet' | 'Finish'.
  3. Schalten Sie das linke View-Fenster um mit 'Window' | 'Show View' | 'Package Explorer'.
    Klicken Sie auf '[+]' vor 'MyFirstServlet'.
  4. Klicken Sie mit der rechten Maustaste auf 'WEB-INF/src' (nicht verwechseln mit 'WEB-INF') und wählen Sie 'New' | 'Class' | 'Name = HelloServlet', setzen Sie den Radiobutton auf 'public', schalten Sie alle Checkboxen aus und wählen Sie 'Finish'.
  5. Im Editorfenster erscheint die Datei 'HelloServlet.java'.
    Ersetzen Sie den Inhalt durch folgenden (und speichern Sie mit 'Ctrl+S'):
    import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;
    
    public class HelloServlet extends HttpServlet
    {
      public void doGet( HttpServletRequest requ, HttpServletResponse resp )
      throws ServletException, IOException
      {
        resp.setContentType( "text/html" );
        PrintWriter out = resp.getWriter();
        out.println( "<html>" );
        out.println( "Hallo, mein erstes Servlet meldet sich." );
        out.println( "</html>" );
        out.close();
      }
    }
    
  6. Klicken Sie im 'Package Explorer' mit der rechten Maustaste diesmal auf 'WEB-INF' (also nicht 'WEB-INF/src') und wählen Sie 'New' | 'File' | 'File name = web.xml' | 'Finish'.
  7. Falls sich ein Internet-Explorer-Fenster öffnet: Klicken Sie es weg.
    Zum Öffnen der Datei 'web.xml' klicken Sie im 'Package Explorer': '[+]' vor 'WEB-INF' | rechte Maustaste auf 'web.xml' | 'Open with' | 'Text Editor'. Im Editorfenster erscheint die Datei 'web.xml'.
    Fügen Sie folgenden Inhalt ein (und speichern Sie mit 'Ctrl+S'):
    <!DOCTYPE web-app PUBLIC
      '-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN'
      'http://java.sun.com/dtd/web-app_2_3.dtd'>
    <web-app>
      <display-name>Mein erstes Servlet</display-name>
      <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
      </servlet-mapping>
    </web-app>
    
    (Statt dieser 'web.xml'-Änderung könnten Sie auch das Tomcat-Invoker-Servlet bemühen.)
  8. Starten Sie Tomcat (über Eclipse). Unter http://localhost:8080/MyFirstServlet/hello erscheint die vom Servlet generierte HTML-Seite.


Erste JSP (Java Server Pages)

  1. Installieren Sie Tomcat und das Sysdeo Eclipse Tomcat Plug-in wie oben beschrieben.
    Starten Sie Tomcat in Eclipse über 'Tomcat' | 'Tomcat starten', stellen Sie sicher, dass http://localhost:8080 eine korrekte Webseite anzeigt und stoppen Sie Tomcat über 'Tomcat' | 'Tomcat beenden'.
  2. Wählen Sie 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project' | 'Next' | 'Project name = MyFirstJSP' | 'Finish'.
  3. Schalten Sie das linke View-Fenster um mit 'Window' | 'Show View' | 'Package Explorer'.
    Klicken Sie auf das '[+]' vor 'MyFirstJSP'.
  4. Klicken Sie mit der rechten Maustaste auf 'MyFirstJSP' und wählen Sie 'New' | 'File' | 'File name = HelloJSP.jsp' | 'Finish'.
  5. Im Editorfenster erscheint die Datei 'HelloJSP.jsp'.
    Fügen Sie folgenden Inhalt ein (und speichern Sie mit 'Ctrl+S'):
    <%@ page import="java.text.*" %>
    <%@ page import="java.util.*" %>
    
    <html>
    Hallo, meine erste JSP-Seite meldet sich.<br>
    <%= request.getRemoteHost() %>,
    <%= (new SimpleDateFormat("yyyy-MM-dd, HH:mm:ss")).format(new Date()) + " h" %>
    </html>
    
  6. Fahren Sie Tomcat herunter und starten Sie Tomcat neu (über Eclipse). Unter http://localhost:8080/MyFirstJSP/HelloJSP.jsp erscheint die von der JSP generierte HTML-Seite. Der erste Aufruf dauert etwas, da compiliert werden muss. Die folgenden Aufrufe kommen schneller.
  7. Ändern Sie die JSP-Source etwas (und speichern Sie die JSP-Datei). Sie brauchen Tomcat nicht neu zu starten. Beim nächsten Aufruf der JSP-Seite im Webbrowser sehen Sie sofort die Änderung (aktualisieren Sie die Ansicht im Webbrowser, z.B. per 'Reload', 'Strg+R' oder 'F5').
  8. Sehen Sie sich interessehalber mal das Verzeichnis '<Eclipse-workspace>\MyFirstJSP\work\org\apache\jsp' an: dort finden Sie die in ein Servlet umgewandelte JSP-Datei 'HelloJSP_jsp.java' und deren compilierte '.class'-Datei. Damit Eclipse diese Verzeichnisse und Dateien anzeigt, müssen Sie eventuell die Package-Explorer-Ansicht mit der 'F5'-Taste aktualisieren.
  9. Sie können die Datei 'HelloJSP_jsp.java' in Eclipse laden und dann darin Breakpoints setzen. Wenn Sie jetzt die JSP-Seite im Webbrowser aufrufen, wird beim Breakpoint angehalten und Sie können im Servlet debuggen.
  10. Weiteres zu JSP finden Sie unter: JSP.


JSP mit JavaBeans

  1. Installieren Sie Tomcat und das Sysdeo Eclipse Tomcat Plug-in wie oben beschrieben.
  2. Wählen Sie 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project' | 'Next' | 'Project name = MyJSPwithJavaBean' | 'Finish'.
  3. Schalten Sie das linke View-Fenster um mit 'Window' | 'Show View' | 'Package Explorer'.
    Klicken Sie auf das '[+]' vor 'MyJSPwithJavaBean'.
  4. Klicken Sie mit der rechten Maustaste auf 'MyJSPwithJavaBean' und wählen Sie 'New' | 'File' | 'File name = HelloJavaBean.jsp' | 'Finish'.
  5. Im Editorfenster erscheint die Datei 'HelloJavaBean.jsp'.
    Fügen Sie folgenden Inhalt ein (und speichern Sie mit 'Ctrl+S'):
    <html>
    Hallo, meine JSP-Seite mit JavaBean meldet sich.<br>
    <%= request.getRemoteHost() %><br>
    <%
      meinpackage.MeineJavaBean jb = new meinpackage.MeineJavaBean();
      out.println( jb.getDateString() );
    %>
    </html>
    
  6. Klicken Sie im 'Package Explorer' mit der rechten Maustaste auf 'WEB_INF/src' und wählen Sie 'New' | 'Package' | 'Name = meinpackage' | 'Finish'.
  7. Klicken Sie im 'Package Explorer' mit der rechten Maustaste auf 'meinpackage' und wählen Sie 'New' | 'Class' | 'Name = MeineJavaBean' | 'Finish'.
  8. Im Editorfenster erscheint die Datei 'MeineJavaBean.java'.
    Ersetzen Sie den Inhalt durch (und speichern Sie mit 'Ctrl+S'):
    package meinpackage;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class MeineJavaBean
    {
      public String getDateString()
      {
        return (new SimpleDateFormat("yyyy-MM-dd, HH:mm:ss")).format(new Date()) + " h";
      }
    }
    
  9. Fahren Sie Tomcat herunter und starten Sie Tomcat neu (über Eclipse). Unter http://localhost:8080/MyJSPwithJavaBean/HelloJavaBean.jsp erscheint die von der JSP generierte HTML-Seite.
  10. Sie können sowohl die JSP-Datei als auch die JavaBean-Datei ändern (und speichern). Beide Änderungen bemerkt Tomcat und beim nächsten Aufruf der JSP-Seite im Webbrowser sehen Sie sofort die Änderung, ohne dass Tomcat neu gestartet werden müsste (aktualisieren Sie die Ansicht im Webbrowser, z.B. per 'Reload', 'Strg+R' oder 'F5').
  11. Die zum Servlet umgewandelte JSP-Datei 'HelloJavaBean_jsp.java' und deren compilierte '.class'-Datei werden erzeugt im Verzeichnis '<Eclipse-workspace>\MyJSPwithJavaBean\work\org\apache\jsp'.
    Die '.class'-Datei der compilierten JavaBean wird erzeugt im Verzeichnis '<Eclipse-workspace>\MyJSPwithJavaBean\WEB-INF\classes\meinpackage' (eventuell in Eclipse die Package-Explorer-Ansicht mit der 'F5'-Taste aktualisieren) (falls 'MeineJavaBean.class' fehlt: mit rechter Maustaste klicken auf 'MyJSPwithJavaBean' | 'Properties' | 'Java Build Path' | 'Default output folder' bearbeiten).
  12. Sie können sowohl in der zum Servlet umgewandelten JSP-Datei 'HelloJavaBean_jsp.java' als auch in der JavaBean-Datei 'MeineJavaBean.java' Breakpoints setzen. Wenn Sie dann die JSP-Seite im Webbrowser aufrufen, wird beim Breakpoint angehalten und Sie können debuggen.
  13. Zum schnelleren Verständnis wurde hier im Beispiel in der JSP-Datei mit 'new' ein Objekt der JavaBean erzeugt, worüber Sie dann benutzt werden kann. Allerdings ist unsere 'MeineJavaBean.java'-Datei auch keine echte JavaBean, da sie keine Getter- und Setter-Methoden hat.
    Echte JavaBeans sollten mit '<jsp:useBean ...>' eingebunden werden, also z.B.:

    <jsp:useBean id="MeineBean" class="meinpackage.MeineJavaBean" />

    Dann kann einfach mit '<jsp:getProperty ...>' und '<jsp:setProperty ...>' auf die Bean-Getter und -Setter zugegriffen werden und es ergeben sich weitere Möglichkeiten zur Nutzung, z.B. die einfache Parameterübergabe aus HTML-Formularen in JavaBeans.
  14. Wieso müssen die JSP- und .class-Dateien nicht im Tomcat-Verzeichnisbaum sein, sondern können im Eclipse-workspace-Verzeichnis sein? Weil entweder eine Datei 'MyJSPwithJavaBean.xml' im Tomcat-webapps-Verzeichnis mit folgendem Inhalt existiert oder in der Tomcat-'server.xml'-Datei folgendes definiert wurde:

    <Context path="/MyJSPwithJavaBean" reloadable="true"
    docBase="D:\MeinWorkspace\MyJSPwithJavaBean"
    workDir="D:\MeinWorkspace\MyJSPwithJavaBean\work\org\apache\jsp" />

  15. Weiteres zu JSP finden Sie unter: JSP.


SOAP Web Services mit Axis

Informationen zu SOAP Web Services finden Sie unter soap.htm und java-soap-axis.htm.
Im Folgenden geht es um die Erzeugung eines SOAP Web Services mit Axis in Eclipse.

  1. Installieren Sie Tomcat und das Sysdeo Eclipse Tomcat Plug-in wie oben beschrieben.
  2. Wählen Sie 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project' | 'Next' | 'Project name = MeinWebServiceProjekt' | 'Finish'.
  3. Downloaden Sie das Apache-Axis-Archiv (z.B. 'axis-bin-1_2.zip') von 'http://ws.apache.org/axis/' in ein temporäres Verzeichnis und entpacken Sie es. Kopieren Sie aus dem Apache-Axis-Archiv alle .jar-Libs aus dem 'axis-1_2/webapps/axis/WEB-INF/lib'-Verzeichnis in das 'MeinWebServiceProjekt/WEB-INF/lib'-Verzeichnis in Ihrem Eclipse-Workspace und die Datei 'web.xml' aus dem Apache-Axis-Archiv-Verzeichnis 'axis-1_2/webapps/axis/WEB-INF' in das 'MeinWebServiceProjekt/WEB-INF'-Verzeichnis in Ihrem Eclipse-Workspace. Zum Beispiel so:

    xcopy \Temp\axis-bin-1_2\axis-1_2\webapps\axis\WEB-INF\lib\*.jar \MeinWorkspace\MeinWebServiceProjekt\WEB-INF\lib

    xcopy \Temp\axis-bin-1_2\axis-1_2\webapps\axis\WEB-INF\web.xml \MeinWorkspace\MeinWebServiceProjekt\WEB-INF

  4. Drei zusätzliche '.jar'-Libs werden benötigt:

    'activation.jar' aus dem 'JavaBeans Activation Framework' (z.B. 'jaf-1_0_2-upd2.zip') von 'http://java.sun.com/products/javabeans/glasgow/jaf.html',

    'mail.jar' aus 'JavaMail' (z.B. 'javamail-1_3_2-upd.zip') von 'http://www.oracle.com/technetwork/java/javamail' und

    die 'XML Security'-Lib (z.B. 'xmlsec-1.2.1.jar') von 'http://xml.apache.org/security/' (oder 'http://xml.apache.org/security/dist/java-library/').

    Kopieren Sie alle drei .jar-Libs nach '<MeinWorkspace>\MeinWebServiceProjekt\WEB-INF\lib'.

  5. Umbenennen Sie die .jar-Libs im Eclipse-Workspace-Verzeichnis '<MeinWorkspace>\MeinWebServiceProjekt\WEB-INF\lib' so, dass sie keine Versionsnummern mehr enthalten (z.B. 'commons-discovery.jar' statt 'commons-discovery-0.2.jar').

  6. Schalten Sie in Eclipse das linke View-Fenster um mit 'Window' | 'Show View' | 'Package Explorer'.
    Klicken Sie auf das '[+]' vor 'MeinWebServiceProjekt' und betätigen Sie die 'F5'-Taste.
  7. Klicken Sie mit der rechten Maustaste auf 'WEB_INF/src' (nicht verwechseln mit 'WEB_INF') und wählen Sie 'New' | 'Package' | 'Name = meinpackage' | 'Finish'.
  8. Klicken Sie im 'Package Explorer' mit der rechten Maustaste auf 'meinpackage' und wählen Sie 'New' | 'Class' | 'Name = MeineWebServiceKlasse' | 'Finish'.

    Im Editorfenster erscheint die Datei 'MeineWebServiceKlasse.java'.
    Ersetzen Sie den Inhalt durch (und speichern Sie mit 'Ctrl+S'):

    package meinpackage;
    
    public class MeineWebServiceKlasse
    {
      public double meineWebServiceMethode( String job, double x )
      {
        if( "Quadrat".equalsIgnoreCase( job ) )
          return x * x;
        if( "Wurzel".equalsIgnoreCase( job ) )
          return Math.sqrt( x );
        return 0.;
      }
    }
    
  9. Klicken Sie mit der rechten Maustaste diesmal auf 'WEB_INF' (nicht verwechseln mit 'WEB_INF/src') und wählen Sie 'New' | 'File' | 'File name = deployMeinWebService.wsdd' | 'Finish'.

    Speichern Sie im sich öffnenden Editorfenster folgenden Web Service Deployment Descriptor:

    <deployment xmlns="http://xml.apache.org/axis/wsdd/"
                xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
      <service name="MeinWebServiceName" provider="java:RPC" style="wrapped" use="literal">
        <parameter name="className" value="meinpackage.MeineWebServiceKlasse" />
        <parameter name="allowedMethods" value="*" />
        <parameter name="scope" value="Request" />
      </service>
    </deployment>
    

    Verfahren Sie entsprechend für folgenden Undeployment Descriptor 'undeployMeinWebService.wsdd':

    <undeployment xmlns="http://xml.apache.org/axis/wsdd/">
      <service name="MeinWebServiceName" />
    </undeployment>
    
  10. Starten Sie Tomcat über das Katzen-Icon in Eclipse.

    Öffnen Sie ein Kommandozeilenfenster ('Start' | 'Alle Programme' | 'Zubehör' | 'Eingabeaufforderung') und geben Sie bei aktivem Tomcat folgende Befehle ein (unter Windows XP können Sie den Kommandotext im Webbrowser mit gedrückter Maustaste markieren, mit 'Strg+C' zwischenspeichern und irgendwo im Kommandozeilenfenster mit rechter Maustaste, 'Einfügen' und 'Return' ausführen):

    cd \MeinWorkspace\MeinWebServiceProjekt\WEB-INF

    set CLASSPATH=.;lib/activation.jar;lib/axis.jar;lib/axis-ant.jar;lib/commons-discovery.jar;lib/commons-logging.jar;lib/jaxrpc.jar;lib/log4j.jar;lib/mail.jar;lib/saaj.jar;lib/wsdl4j.jar

    javac -d classes src/meinpackage/MeineWebServiceKlasse.java

    java org.apache.axis.client.AdminClient -s /MeinWebServiceProjekt/services/AdminService deployMeinWebService.wsdd

    Testen Sie folgende Aufrufe:

    http://localhost:8080/MeinWebServiceProjekt/services/MeinWebServiceName

    http://localhost:8080/MeinWebServiceProjekt/services/MeinWebServiceName?wsdl

    http://localhost:8080/MeinWebServiceProjekt/services/MeinWebServiceName?method=meineWebServiceMethode&job=Quadrat&val=12.7

    http://localhost:8080/MeinWebServiceProjekt/services/MeinWebServiceName?method=meineWebServiceMethode&job=Wurzel&val=64

  11. Falls Sie den Web Service wieder deaktivieren wollen, geben Sie im Kommandozeilenfenster ein:

    java org.apache.axis.client.AdminClient -s /MeinWebServiceProjekt/services/AdminService undeployMeinWebService.wsdd

    Die Aktivierung und Deaktivierung können Sie auch anhand des Eintrags '<service name="MeinWebServiceName" ...' in der Datei 'server-config.wsdd' verfolgen.

  12. Im Web Service Deployment Descriptor 'deployMeinWebService.wsdd' sorgt die Zeile

    <service name="MeinWebServiceName" provider="java:RPC" style="wrapped" use="literal">

    dafür, dass der Binding-Style und -Use des Web Services auf 'Document / literal' eingestellt wird. Diese Einstellung ist notwendig für WS-I Basic Profile compliance und Kompatibilität mit Microsofts .NET.

    Verwenden Sie mit der Axis-Version 1.2 nicht 'style="document" use="literal"' statt 'style="wrapped" use="literal"', da es damit in der WSDL-Beschreibung zu Fehlern bei Methoden mit mehreren Parametern kommt, die, statt zu einem 'complexType' kombiniert zu werden, im 'message'-Body als mehrere 'part'-Elemente eingetragen werden, was bei 'Document / literal' anders als bei 'RPC / encoded' nicht erlaubt ist.

    Wenn Sie statt 'Document / literal' lieber 'RPC / encoded' verwenden wollen, ändern Sie 'style="wrapped" use="literal"' zu 'style="rpc" use="encoded"' (oder lassen beide Parameter weg, da dies bei Axis 1.2 der Default ist). Undeployen Sie und deployen erneut. Sehen Sie sich die Unterschiede in der WSDL-Beschreibung an.



JSP als Web-Service-Client

Falls Sie den gerade generierten Web Service mit einem JSP-Client testen wollen, können Sie das folgendermaßen:

  1. Installieren Sie Tomcat und das Sysdeo Eclipse Tomcat Plug-in wie oben beschrieben.
  2. Wählen Sie 'File' | 'New' | 'Project...' | '[+]' vor 'Java' | 'Tomcat Project' | 'Next' | 'Project name = MeinWebServiceClient' | 'Finish'.
  3. Downloaden Sie die Apache Jakarta IO Taglib (z.B. 'jakarta-taglibs-io-20050627.zip') von http://www.apache.org/dist/jakarta/taglibs/io/jakarta-taglibs-io-current.zip (oder http://cvs.apache.org/builds/jakarta-taglibs/nightly/projects/io/jakarta-taglibs-io-...zip).

    Entpacken Sie das Archive und kopieren Sie daraus die 'taglibs-io.tld'-Datei in Ihr
    '<MeinWorkspace>/MeinWebServiceClient/WEB-INF'-Verzeichnis und die 'taglibs-io.jar'-Datei in Ihr
    '<MeinWorkspace>/MeinWebServiceClient/WEB-INF/lib'-Verzeichnis.

  4. Schalten Sie in Eclipse das linke View-Fenster um mit 'Window' | 'Show View' | 'Package Explorer'.
    Klicken Sie auf das '[+]' vor 'MeinWebServiceClient' und betätigen Sie 'F5'.
  5. Klicken Sie mit der rechten Maustaste auf 'MeinWebServiceClient' und wählen Sie 'New' | 'File' | 'File name = WsClient.jsp' | 'Finish'.
  6. Im Editorfenster erscheint die Datei 'WsClient.jsp'.
    Fügen Sie folgenden Inhalt ein (und speichern Sie mit 'Ctrl+S'):

    <!doctype html public "-//w3c//dtd html 4.0 transitional//en">
    <%@ taglib uri="/WEB-INF/taglibs-io.tld" prefix="io" %>
    
    <%
      final String urlLocalhost =
        "http://localhost:8080/MeinWebServiceProjekt/services/MeinWebServiceName";
      String url = request.getParameter( "url" );
      String job = request.getParameter( "job" );
      String val = request.getParameter( "val" );
      url = ( null != url ) ? url.trim() : urlLocalhost;
      job = ( null != job ) ? job.trim() : "Wurzel";
      val = ( null != val ) ? val.trim() : "64";
    %>
    
    <html>
    <head> <title>Mein Web Service Client</title> </head>
    <body>
    <h2>Mein Web Service Client</h2>
    
    <form method="post"><pre>
    Enpoint-URL        : <input type="text" name="url" value='<%= url %>' size=80>
    Quadrat oder Wurzel: <input type="text" name="job" value='<%= job %>' size=20>
    Wert               : <input type="text" name="val" value='<%= val %>' size=20>
                         <input type="submit" name="submit" value="Rechnen">
    </pre></form>
    
    <h3><hr>meineWebServiceMethode( "<%= job %>", <%= val %> ) --&gt;
    <% out.flush(); %>
    <io:soap url="<%= url %>" SOAPAction="">
      <io:body>
        <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
          <SOAP-ENV:Body>
            <m:meineWebServiceMethode xmlns:m="http://meinpackage">
              <in0><%= job %></in0>
              <in1><%= val %></in1>
            </m:meineWebServiceMethode>
          </SOAP-ENV:Body>
        </SOAP-ENV:Envelope>
      </io:body>
    </io:soap>
    <hr></h3>
    
    </body>
    </html>
    
  7. Starten Sie Tomcat und rufen Sie auf: http://localhost:8080/MeinWebServiceClient/WsClient.jsp.
  8. Weitere Infos finden Sie unter jsp-taglibs.htm und http://jakarta.apache.org/taglibs/doc/io-doc/#soap.


Deployment per Web Application Archive (.war-Datei)

.war-Datei

Zur Distribution und zum Deployment von Java-EE-Webanwendungen werden die JSP-, Servlet-, JavaBean-Dateien, .jar-Libs und weitere benötigten Dateien in eine .war-Datei zusammengepackt (Web-Archiv).

Ant build.xml

Das Erstellen der .war-Datei erfolgt normalerweise mit 'Ant' und zum Beispiel folgendem 'Ant'-Skript 'build.xml':

<project name="MeinWebAppProjekt" default="all">
  <property name="distname"    value="MeineWebApp" />
  <property name="distpath"    value="dist" />
  <property name="servlet.jar" value="/Tools/Tomcat/common/lib/servlet-api.jar" />
  <path id="compile.classpath">
    <fileset dir="WEB-INF/lib" />
    <pathelement path="${servlet.jar}" />
    <pathelement path="WEB-INF/classes" />
    <pathelement path="${classpath}" />
  </path>
  <target name="clean">
    <delete dir="WEB-INF/classes" />
    <mkdir  dir="WEB-INF/classes" />
  </target>
  <target name="compile">
    <javac srcdir="WEB-INF/src" destdir="WEB-INF/classes">
      <classpath refid="compile.classpath" />
    </javac>
  </target>
  <target name="dist">
    <mkdir dir="${distpath}" />
    <war destfile="${distpath}/${distname}.war" webxml="WEB-INF/web.xml">
      <classes dir="WEB-INF/classes" />
      <fileset dir="." includes="WEB-INF/*.*, WEB-INF/lib/*.*"
                       excludes="**/WEB-INF/web.xml" />
    </war>
  </target>
  <target name="all" depends="clean,compile,dist" />
</project>

Wenn Sie im Verzeichnis der 'build.xml'-Datei 'Ant' aufrufen, wird die .war-Datei im 'distpath'-Verzeichnis generiert.

Sysdeo Eclipse Tomcat Plug-in

Wenn Sie nicht so genau steuern wollen, welche Dateien in der .war-Datei enthalten sein sollen, können Sie alternativ mit Eclipse das oben bereits erwähnte Sysdeo Eclipse Tomcat Plug-in zur Erstellung der .war-Datei verwenden:

  1. Im 'Package Explorer' mit rechter Maustaste auf das Projekt klicken | 'Properties' | 'Tomcat' | Reiter 'Einstellungen für den Export in eine war-Datei' | in 'Exportiere war-Datei' Pfad und Dateiname angeben. Dabei den Dateinamen so wählen, wie der Kontextanteil in der URL lauten soll.
  2. Im 'Package Explorer' mit rechter Maustaste auf das Projekt klicken | 'Tomcat Project' | 'Exportiere in die in den Projekteinstellungen gewählte war-Datei'.

Lokal deployen

  1. Die erzeugte .war-Datei in das 'webapps'-Verzeichnis (z.B. 'D:\Tools\Tomcat\webapps') des Java EE Application Servers kopieren. Der Java EE Application Server entpackt und installiert sie dann automatisch.

Remote deployen

  1. Falls unter Windows entwickelt wird und die .war-Datei auf einen entfernten Unix- oder Linux-Server über eine SSH-Verbindung (Secure Shell) kopiert werden soll, kann dies zum Beispiel mit 'PuTTY' und 'PSCP' (PuTTY Secure Copy client) über folgende Kommandos erfolgen:

    pscp.exe MeineWebApp.war MeinLoginName@MeineZielDomain.de:/home/MeinLoginName/

    putty.exe MeineZielDomain.de

    cd /home/MeinLoginName

    chmod 755 MeineWebApp.war

    cp MeineWebApp.war /usr/local/Tomcat/webapps

    cd /usr/local/Tomcat/webapps

    ls -l

    Unter 'webapps' muss nach wenigen Sekunden ein neues Verzeichnis mit dem Namen 'MeineWebApp' entstehen. Darunter finden Sie die entpackten Dateien.

  2. Bei Problemen sollten Sie sich als Erstes die Logdateien ansehen:

    cd /usr/local/Tomcat/logs

    less catalina<aktuellesDatum>.log

  3. Ein erster Test der Webapplication kann lokal auf dem Server über PuTTY mit dem Textbrowser 'w3m' erfolgen:

    w3m http://localhost:8080/MeineWebApp

    Wenn Router und Firewalls entsprechend konfiguriert sind, kann die Webanwendung von außen erreicht werden über:

    http://MeineZielDomain.de:8080/MeineWebApp

  4. Falls Sie Probleme mit PuTTY haben: PuTTY Version 0.58 funktioniert unter einigen Windows-XP-Versionen nicht. Sie können stattdessen PuTTY 0.57 nehmen.


Remote Debugging

Mit JPDA / JDWP (z.B. auf Java EE Application Servern) ist Remote Debugging möglich, also das Debuggen auf entfernten Rechnern. Details zu den Verbindungsparametern finden Sie unter Connection and Invocation Details.

  1. Starten Sie Ihre Anwendung auf dem entfernten Host-Rechner unter Angabe passender Debugoptionen, zum Beispiel für Tomcat, JBoss, WebLogic und OC4J mit:

    -agentlib:jdwp=transport=dt_socket,address=<JdwpDebugPort>,server=y,suspend=n

    Damit zum Beispiel Tomcat mit den genannten Debug-Optionen startet, setzen Sie die Umgebungsvariablen 'JPDA_ADDRESS=<JdwpDebugPort>' und 'JPDA_TRANSPORT=dt_socket' und starten Tomcat nicht über 'startup.bat' sondern über 'catalina.bat jpda start' (im '<tomcat-root>/bin'-Verzeichnis).

    Ersetzen Sie jeweils '<JdwpDebugPort>' durch eine Portnummer, zum Beispiel '8787'.

  2. Falls Sie Tomcat remote debuggen wollen und falls Sie ein entsprechendes Tomcat-Plug-in in Eclipse installiert haben, stellen Sie in Eclipse ein:
    'Window' | 'Preferences' | '[+] Tomcat' | 'JVM Einstellungen' | 'Tomcat nicht im Debug-Modus starten': ausschalten.
  3. Öffnen Sie in Eclipse eine Java-Sourcecodedatei und erzeugen Sie mit 'Ctrl+Shift+B' einen Breakpoint.
  4. Wählen Sie in Eclipse 'Run' | 'Debug...'.
  5. Klicken Sie im 'Configurations'-Fenster auf 'Remote Java Application' | 'New'.
  6. Stellen Sie unter 'Connect' | 'Connection Properties' den 'Host'-Namen und den beim Host gewählten '<JdwpDebugPort>' ein (z.B. '8787').
  7. Wählen Sie in Eclipse 'Run' | 'Debug...' | im 'Configurations'-Fenster unter '[+] Remote Java Application' <MeineRemoteDebugKonfiguration> | Button 'Debug'.


Links auf weiterführende Informationen





Weitere Themen: andere TechDocs | JSP | Webanwendungen | Web Services
© 1998-2008 Torsten Horn, Aachen