Applets
Servlets und JSP
Apache Tomcat
Zusammenfassung und Ausblick
kleine eigenständige Anwendung
kann in Web-Browsern mit JVM ausgeführt werden
Programmteile werden übers Netzgeladen
Nutzung der Vorteile der Java Programmiersprache
Nutzung aller APIs von Java soweit aus Sicherheitsgründen erlaubt
Sandkasten Prinzip
insbesondere sind TCP/IP Verbindungen mit eigener Verschlüsselung möglich
Applet Klasse ist von einer AWT Klasse Component abgeleitet
AWT definiert Zeichenfunktionen, Buttons, etc.
Applet definiert zusätzlich Ausführungslogik: init(), start(), stop(), destroy()
package java.applet; import java.awt.*; import java.awt.image.ColorModel; import java.net.URL; import java.net.MalformedURLException; import java.util.Hashtable; import java.util.Locale; public class Applet extends Panel { public boolean isActive() public URL getDocumentBase() public URL getCodeBase() public String getParameter(String name) public AppletContext getAppletContext() public void resize(int width, int height) public void resize(Dimension d) public void showStatus(String msg) public Image getImage(URL url) public Image getImage(URL url, String name) public final static AudioClip newAudioClip(URL url) public AudioClip getAudioClip(URL url) public AudioClip getAudioClip(URL url, String name) public String getAppletInfo() public Locale getLocale() public String[][] getParameterInfo() public void play(URL url) public void play(URL url, String name) public void init() public void start() public void stop() public void destroy() }
public class Panel extends Container ... public class Container extends Component public class Component extends Object implements ... { public void paint(Graphics g) { } ... }
Übergabe des Parameters 'nachricht' und Zeichnung des Textes in 'paint'.
import java.awt.*; import java.applet.*; public class HelloWorldApplet extends Applet { String msg = ""; public void init () { msg = getParameter("nachricht"); } public void paint(Graphics g) { g.drawString("Hello World ...",10,50); g.drawString(msg,10,75); g.drawString("... vom Applet.",10,100); } }
Einbettung in HTML mit dem Applet-Element.
<applet code="HelloWorldApplet.class" width="150" height="150"> <param name="nachricht" value="mit Parameter"> </applet>
Erweiterung der Web-Server Funktionalität
kann CGI ersetzen, bzw. ergänzen
Einbindung via Server-API oder Standalone
Nutzung der Vorteile der Java Programmiersprache
Nutzung aller APIs von Java
Apache: JServ, Jacarta Projekt
Integration in Java-Web-Server: Jigsaw
Websphere von IBM, JRun von Live Software, etc
Kombination mit Java Server Pages (JSP)
z.Z. Version 2.2., vom 17. Dez. 1999
Web-Application Konzept
Basis Funktionalität: Kontextverwaltung, Sende- und Empfangs-Objekte, Service-Methode
und eine an CGI angelehnte Schnittstelle: Http, Cookies, Sitzungsverwaltung
Basis Interfaces: Servlet
,
ServletConfig
, ServletContext
,
ServletRequest
, ServletResponse
Abstrakte Klassen: GenericServlet
,
ServletInputStream
, ServletOutputStream
HTTP Interfaces:
HttpServletRequest
, HttpServletResponse
,
HttpSession
, HttpSessionContext
(Abstrakte) Klassen: HttpServlet
, Cookie
Es wird im Web-Server nur ein Servlet-Objekt erzeugt, nicht für jede Anfrage ein neues
Beachte Multithreading: service
, doGet
können parallel aufgerufen werden
package javax.servlet; public interface Servlet { public void init(ServletConfig config) throws ServletException; public ServletConfig getServletConfig(); public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException; public String getServletInfo(); public void destroy(); }
public interface ServletConfig { } public interface ServletRequest { public int getContentLength(); public ServletInputStream getInputStream() throws IOException; .... } public interface ServletResponse { public ServletOutputStream getOutputStream() throws IOException; public void setContentType(String type); ... }
public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable { public void init(ServletConfig config) throws ServletException public abstract void service(ServletRequest req, ServletResponse res) throws ServletException, IOException; ... }
import java.io.*; import java.text.*; import java.util.*; import javax.servlet.*; public class SimpleHelloWorld extends GenericServlet { private int aufrufe; public void init(ServletConfig config) throws ServletException { super.init(config); aufrufe=0; } public void service(ServletRequest request, ServletResponse response) throws IOException, ServletException { response.setContentType("text/html"); ServletOutputStream out = response.getOutputStream(); out.println("<html>"); out.println("<head>"); String title = "Hello World"; aufrufe++; out.println("<title>" + title + "</title>"); out.println("</head>"); out.println("<body bgcolor=\"white\">"); out.println("<h1>" + title + "</h1>"); out.println("<h2>" + aufrufe + " Aufrufe</h2>"); out.println("</body>"); out.println("</html>"); } }
package javax.servlet.http; public abstract class HttpServlet extends GenericServlet implements java.io.Serializable { public HttpServlet() protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException protected long getLastModified(HttpServletRequest req) private void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException ... }
import java.io.*; import java.text.*; import java.util.*; import javax.servlet.*; import javax.servlet.http.*; public class HelloWorldExample extends HttpServlet { ResourceBundle rb = ResourceBundle.getBundle("LocalStrings"); public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<head>"); String title = rb.getString("helloworld.title"); out.println("<title>" + title + "</title>"); out.println("</head>"); out.println("<body bgcolor=\"white\">"); out.println("<h1>" + title + "</h1>"); out.println("</body>"); out.println("</html>"); } }
Einbettung von Java in HTML
wie PHP oder ASP
Kennzeichnung durch <% Java Code %>
aus dem Java Code wird beim ersten Aufruf ein Servlet
generiert und dieses dann compiliert (javac
)
die Ausführung des Byte-Code ist dann wesentlich schneller
der Web-Server wird konfiguriert,
dass Dateien mit bestimmter Endung (*.jsp
)
von dem JspServlet
behandelt werden
Import von Java Klassen mit
<%@ import "java.util.Date" %>
Einfügen von anderen Dateien
<%@ include file="dateiname" %>
Zugriff auf Variablen der
service
-Methode von Servlet
Einfügen von Variablen und Ausdrücken in HTML mit '='
<%= var.name; %>
Zugriff auf JSP-Teile im XML Stil
<jsp:expr> request.getQueryString() </jsp:expr>
Deklarationen mit '!'
<%! int xyz = 1; %>
Definition eigener Tags
<%@ taglib="URL" prefix="my" %>
Verwendung von Java Beans möglich
<jsp:usebean id="." class="xyz" >
<html> <head> <title>Hello World JSP</title> </head> <body bgcolor="white"> <hr> <% out.println("<h2>Hallo Welt! von JSP</h2>"); %> <hr> </body> </html>
Apache Jakarta
Apache plus diverse Java Aktivitäten
Apache Jakarta Tomcat
Java Servlet und JSP Teil
wird offiziell von Sun unterstützt
Referenzimplementierung
Servlet API 2.2, demnächst 2.3 (Februar 2001)
Java Server Pages 1.1 (Februar 2001)
Standalone
Tomcat stellt einen Web-Server und den Servlet/JSP Server
als Teil von Apache httpd
der httpd führt via mod_jserv
die JVM plus Tomcat-Klassen als Subprozess aus
getrennt von Apache httpd
Tomcat stellt einen separaten Prozess für Servlets und JSP
der httpd kommuniziert via mod_jserv
und einem TCP/IP basierten Protokoll (AJP V12) mit Tomcat
Standalone ist gut zum Entwickeln und Testen
ist relativ einfach zu konfigurieren
getrennte Ausführung ist performanter für produktiven Einsatz
ist schwer zu Konfigurieren: Teile des Web-Baums werden von Apache
selbst behandelt, während nur die Servlet/JSP Teile an Tomcat deligiert werden
Apache (mod_jserv
) kann mit vielen Servlet/JSP Servern
gleichzeitig umgehen
Tomcat kann so auch unabhängig von Apache zusammen mit anderen Web-Servern verwendet werden
es gibt ein tomcat
Script (BAT-Datei) zum Starten und Stoppen
dieses Script muss nur das java
Programm (und Tomcat-Home) finden
Das Apache Modul mod_jserv
muss installiert sein
in der Apache Konfiguration (httpd.conf
)
muss mod_jserv
konfiguriert werden
LoadModule jserv_module /usr/lib/apache/mod_jserv.so ApJServManual Off ApJServProperties /etc/httpd/jserv/jserv.properties
LoadModule
aktiviert den Java Server Teil
ApJServManual Off
, d.h. automatisches starten der JVM
ApJServProperties
definiert die Konfigurationsdatei
von Tomcat selbst
Definition der JVM und des CLASSPATH für die Tomcat und Servlet Klassen
AddType text/jsp .jsp AddHandler jserv-servlet .jspwird der Java Server Pages Handler definiert
Das Apache Modul mod_jserv
muss installiert sein
in der Apache Konfiguration (httpd.conf
)
muss mod_jserv
konfiguriert werden
LoadModule jserv_module /usr/lib/apache/mod_jserv.so ApJServManual On ApJServMount /servlet ajpv12://localhost:8007/servletzone
LoadModule
aktiviert den Java Server Teil
ApJServManual On
, d.h. manuelles starten der JVM von Tomcat
ApJServMount
definiert die URLs (/servlet
),
die an Tomcat weitergereicht werden
ajpv12://localhost:8007/servletzone
ajpv12:
definiert das Kommunikationsprotokoll zu Tomcat
localhost:8007
definiert den Host und den Port an
dem Tomcat 'sitzt'
servletzone
definiert den Tomcat Bereich (Zone), der
die Servlets ausführen soll
daneben werden mit den normalen Apache Direktiven die Verzeichnisse definiert, die Seiten (HTML, PHP, etc) enthalten, die Apache selbst ausliefert
AddType text/jsp .jsp AddHandler jserv-servlet .jspwird der Java Server Pages Handler definiert
server.xml
definiert die Tomcat Basiskonfiguration
web.xml
definiert die Tomcat Grundkonfiguration für
Web-Applikationen zusammen mit
web.xml
Dateien für jede Web-Applikation
für spezifischen Konfiguration der Applikation
Beispiel:
<?xml version="1.0" encoding="ISO-8859-1"?> <Server> <Logger name="tc_log" ... /> <ContextManager debug="0" workDir="work" > <ContextInterceptor className="org.apache.tomcat.context.AutoSetup" /> ... <RequestInterceptor className="org.apache.tomcat.request.SimpleMapper" debug="0" /> ... <Connector className="org.apache.tomcat.service.SimpleTcpConnector"> <Parameter name="handler" value="org.apache.tomcat.service.http.HttpConnectionHandler"/> <Parameter name="port" value="8080"/> </Connector> <Connector className="org.apache.tomcat.service.SimpleTcpConnector"> <Parameter name="handler" value="org.apache.tomcat.service.connector.Ajp12ConnectionHandler"/> <Parameter name="port" value="8007"/> </Connector> <Context path="/examples" docBase="webapps/examples" debug="0" reloadable="true" > </Context> <Context path="/test" docBase="webapps/test" debug="0" reloadable="true" > </Context> </ContextManager> </Server>
das Element Server
definiert
einen eignen Tomcat Server
das Element Logger
definiert
diverse Protokollierungsoptionen
das Element ContextManager
definiert
eine Gruppe von zusammen gehörigen 'Interceptoren', 'Connectoren' und 'Contexten'
die Elemente ContextInterceptor
definieren
die Klassen, die sich mit dem Laden, Starten und Stoppen von Servlets
befassen
die Elemente RequestInterceptor
definieren
die Klassen, die sich mit dem Abarbeiten der verschiedenen Anfragen
an Servlets befassen
die Elemente Connector
definieren
Ports und Klassen für die verschiedenen TCP/IP Verbindungen
die Elemente Context
definieren
die Zuordnung zwischen URLs (Zonen, path
)
und Datei-Pfaden (docBase
),
sowie deren Optionen (debug
, reloadable
)
bin
Scripte (BAT-Dateien)
conf
Konfigurationsdateien (server.xml, web.xml)
doc
Dokumentation der APIs etc.
lib
Jar-Dateien mit diversen Tomcat Klassen,
werden in CLASSPATH von Tomcat aufgenommen
logs
Protokolldateien
src
Java Code der APIs, soweit benötigt
webapps
die eigentlichen Web-Applikationen:
Servlets, HTML-Dateien, JSP-Dateien, War-Dateien
work
Servlets, die zu den JSP Dateien automatisch
generiert werden
classes
zusätzliche Java Klassen und Jar-Dateien,
werden auch alle in CLASSPATH von Tomcat aufgenommen
befinden sich in einem Unterverzeichnis von webapps
in diesem Verzeichnis (und ggf. Unterverzeichnissen) befinden sich alle HTML, JSP, etc Dateien der Web-Applikation
in der Datei WEB-INF/web.xml
befindet sich die Konfiguration der Web-Applikation
Parameter, Sicherheitsoptionen, etc.
der sogenannte 'Web Application Deployment Descriptor'
in dem Unterverzeichnis WEB-INF/classes
befinden sich die Servlet Klassen
in dem Unterverzeichnis WEB-INF/lib
befinden sich weitere JAR Dateien der Web-Applikation
das Verzeichnis kann mit dem Tool ant
verwaltet werden
das Verzeichnis kann in eine sogenannte War-Datei (Web Application Archive) gepackt werden, die sich leicht auf andere Rechner übertragen lässt
Beispiel mit globalen Definitionen:
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd"> <web-app> <servlet> <servlet-name>default</servlet-name> <servlet-class>org.apache.tomcat.servlets.DefaultServlet </servlet-class> </servlet> <servlet> <servlet-name>invoker</servlet-name> <servlet-class>org.apache.tomcat.servlets.InvokerServlet </servlet-class> </servlet> <servlet> <servlet-name>jsp</servlet-name> <servlet-class>org.apache.jasper.runtime.JspServlet </servlet-class> </servlet> ... <servlet-mapping> <servlet-name>invoker</servlet-name> <url-pattern>/servlet/*</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>jsp</servlet-name> <url-pattern>*.jsp</url-pattern> </servlet-mapping> ... <mime-mapping> <extension>txt</extension> <mime-type>text/plain</mime-type> </mime-mapping> ... </web-app>
das Element web-app
definiert
die Konfiguration der Applikation
die Elemente servlet
definieren
die Zuordnung von Servlet Namen zu Servlet Klassen
die Elemente servlet-mapping
definieren
die Zuordnung von Servlet Namen zu URL Mustern
die Elemente mime-mapping
definieren
die Zuordnung von Datei-Endungen zu Mime-Types
Beispiel mit applikationsspezifischen Definitionen:
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd"> <web-app> <servlet> <servlet-name>hallo</servlet-name> <servlet-class>HelloWorld</servlet-class> <init-param> <param-name>von</param-name> <param-value>Karl Dall</param-value> </init-param> </servlet> <security-constraint> ... </security-constraint> <login-config> ... </login-config> </web-app>
die Bedeutung der Elemente ist wie in der
globalen web.xml
Datei
ideale Programmiersprache und Entwicklungsumgebung fürs Web
Applets erweitern die Möglichkeiten der Browser (UAs)
Servlets erweitern die Möglichkeiten der Web-Server
Java Beans, Enterprise Java Beans
JDBC, RMI, CORBA
Java Web-Applications
Cocoon
SOAP
© Universität Mannheim, Rechenzentrum, 1998-2002.
Heinz Kredel Last modified: Mon Feb 10 22:34:53 CET 2003