JSP Develop ist die
Internet Plattform für JSP Entwickler. Wir haben uns die Aufgabe gestellt
Informationen für
Software-Entwickler, die sich im Bereich der serverseitigen Java Anwendungs-
entwicklung bewegen,
bereitzustellen. Wir bieten im Rahmen unserer Internet Plattform neben
den
Literaturhinweisen
und der Knowledge Base auch ein Forum für den Bereich JSP-Anwendungs-
entwicklung an.
Wir verstehen uns als Partner für JSP-Entwickler und möchten
der Entwicklergemeinde
mit unserem Wissen
zur Seite stehen.
Viel Spaß beim Newsletter!
Marc & Jörg
Das Beta 2 Release
der J2EE 1.3 steht auf der Internetseite von Sun Microsystems (TM)
zum herunterladen
bereit.
Diese Version der
J2EE beinhaltet eine Reihe von neuen Features und Erweiterungen
der Servlet und
JSP Technologie unter anderem auch bezogen auf den Tomcat 4.0
WEB Container. Der
WEB Container unterstützt jetzt auch XML für die Integration
in Java Server Pages
und die Connector Architektur ermöglicht die Anbindung an
Legacy Systeme.
Der Application Container unterstützt neben den Session und Entity
Beans jetzt auch
Message Driven Beans für die asynchrone Kommunikation einer J2EE
Anwendung. Die Interoperabilität
zwischen EJB Containern wurde ebenso erweitert und
die container-managed
Persistenz in der Version 2.0 wurde integriert.
Weiterführende Informationen erhalten Sie über den Link: java.sun.com/j2ee/j2sdkee-beta
Buch Neuerscheinungen
Für den Bereich
Java Anwendungsentwicklung ist ein neues Buch mit dem Titel
Enterprise Java
with UML (ISBN: 0471386804) erschienen. Das Buch ist im Verlag
Wiley & Sons
aufgelegt worden und handelt vom Design von Java Anwendungen mit
UML. Es enthält
Strategien für die Realisierung von Unternehmensanwendungen
mit Java und verwandten
Technologien - XML, Servlets, Enterprise Java Beans,
Swing Components,
CORBA, RMI und andere. Die Autoren beschreiben wie UML
als Modelierungstechnik
für objekt-orientierte Applikationen angewendet werden kann.
Ein Buch speziell
für JSP-Entwickler mit dem Titel Java Server Pages und J2EE
(ISBN: 3898641120)
wird in Kürze beim dpunkt Verlag erscheinen. Das Buch behandelt
alle Aspekte der
Realisierung von WEB-Anwendungen mit J2EE. Der Fokus liegt dabei
auf Servlets und
Java Server Pages. Es werden verschiedene Architekturen und
Anwendungsszenarien,
Integration von Datenbanken, Frameworks, Sicherheit
von WEB-Anwendungen,
J2EE Application Server sowie Tomcat und die
Anbindung an den
Apache WEB-Server behandelt.
Buch Besprechung
Java Server Pages
Hans
Bergsten
ISBN:
1-56592-746-X
Das Buch von Hans
Bergsten, das im O'REILLY Verlag erschienen ist, behandelt
die wesentlichen
Aspekte rund um das Thema Java Server Pages. Nachfolgend
ein Überblick
über die Kapitel des Buches.
Teil I
Im ersten Kapitel
wird eine Einführung in die JSP-Technologie gegeben. Dieses
Kapitel ist wichtig
für das Verständnis um in späteren Kapiteln weiterführende
JSP-Techniken verstehen
zu können. Die JSP-Technolgie wird dabei nicht isoliert
sondern als Teil
der Java 2 Enterprise Edition gesehen. Das erste Kapitel beschreibt
in kurzen Worten
die Integration der Enterprise Java APIs und zieht ein Vergleich zu
anderen WEB-Technologien
wie ASP, PHP, etc. Im letzten Absatz des Kapitels wird
beschrieben welche
Softwarepakete man zur Entwicklung von JSP-Anwendungen
benötigt.
Das zweite Kapitel
behandelt die Themen HTTP und Servlets. In diesem Kapitel wird
das HTTP Request/Response
Modell vorgestellt und im Detail erläutert. Die Interaktion
zwischen einem WEB-Client
und Server wird anhand von Beispielen anschaulich
dargestellt. Ein
wichtiger Punkt: das State Management in Bezug auf das statuslose
HTTP Protokol, mit
Cookies, Hidden Fields und URL Rewriting wird ebenfalls behandelt.
Der Servlet Teil
bespricht die Vorteile der Servlet Technologie, den Servlet Life Cycle
sowie Servlet Container
und Themen wie den Session Context und Sessions im
allgemeinen.
Das dritte Kapitel
erläutert die Grundlagen der Java Server Page Technologie. Die
Vorteile/Nachteile
der JSP und Servlet Technologie werden herausgearbeitet. Anhand
von Beispielen wird
der Aufbau von JSP-Seiten beschrieben. Im weiteren Verlauf des
Kapitels werden
die JSP Elemente zum Einbinden von Java Beans, setzen/lesen
von Java Beans Eigenschaften
(Properties) sowie Action Elemente besprochen.
Abgeschlossen wird
das Kapitel mit dem Thema JSP Processing, welches zeigt,
wie von einem Servlet
Container aus der JSP-Seite ein Servlet erzeugt wird.
Kapitel vier
handelt von der Installation des Java SDKs und der Servlet Engine
Tomcat.
Teil II
Im fünften
Kapitel wird das Erzeugen von dynamischen WEB-Inhalten
mit der JSP-Technologie
besprochen. Das Kapitel enthält Beispiele
für die Anwendung
von JSP Direktiven und die Kapselung der
Geschäftslogik
(Business Logic) in Java Beans. Das Setzen/Lesen
von Java Beans Eigenschaften
sowie die Gültigkeitsprüfung von
Benutzereingaben
werden ebenfalls in diesem Kapitel behandelt.
Kapitel sechs
gibt einen kurzen Einblick in die Programmiersprache
Java, welche die
Grundlage für die Realisierung von JSP-Anwendungen
ist.
Das siebte Kapitel
erläutert die Behandlung von Fehlern in JSP-Seiten
und das Debugging.
Es werden Tipps für die Behandlung von syntaktischen
und Laufzeitfehlern
gegeben.
Kapitel acht
handelt vom Datenaustausch zwischen JSP-Seiten. Die Scopes
von JSP-Seiten (Page,
Request, Session, Application) werden erläutert
und das Model View
Controller (MVC) Konzept vorgestellt. Interessant ist
der Absatz über
Sessions und Multiple Windows sowie URL Rewriting.
Die Verwendung von
Tag Libraries wird in diesem Kapitel angeschnitten.
Abschliessend wird
in dem Kapitel eine einfache Online Shopping
Seite entwickelt.
Das neunte Kapitel
beschreibt den Zugriff auf Datenbanken mit JSP-Seiten.
Das Lesen und Schreiben
von Datenbankinhalten wird anhand von Beispielen
erklärt. Das
Erzeugen von HTML-Code nach einer Datenbankabfrage aus einem
Result-Set wird
ebenfalls besprochen.
Im zehnten Kapitel
wird die Authentisierung von Benutzern und Personalisierung
von WEB-Seiten besprochen.
Die Kontrolle von WEB Resourcen bzw. wie der
Zugriff auf WEB-Seiten
eingeschränkt werden kann ist Inhalt dieses Kapitels.
Der Unterschied
zwischen der Container und Applikations gesteuerten
Authentisierung
wird ebenfalls behandelt.
im elften Kapitel
wird das Thema Internationalisierung und die entsprechenden
Java Klassen des
JDKs diskutiert.
Kapitel zwölf
handelt von der Einbindung von WEB-Seiten (HTML/JSP)
in JSP-Seiten. Der
weitaus wichtigere Teil des Kapitels erläutert das
Zusammenspiel von
XML und JSP-Seiten. Das Generieren eines XML-
Dokumentes sowie
die Transformation von XML in HTML wird besprochen.
Das Verwenden von
Client-Side und Server-Side Code wird ebenfalls
in diesem Kapitel
angeschnitten.
Teil III
Kapitel dreizehn
erläutert das WEB Application Model von Sun Microsystems (TM).
das WEB Applications
Model wird durch die Java 2 Enterprise Edition (J2EE) abgebildet.
Das Kapitel behandelt
im Überblick die J2EE und die entsprechenden Standard APIs wie
JDBC, JNDI, etc.
Das MVC Konzept sowie die Interaktion von JSP-Seiten, Servlets und
EJBs wird besprochen.
Das vierzehnte
Kapitel erklärt die Kombination von Servlets und JSP-Seiten im
Detail.
Die Vorteile ein
Servlet als Controller einer JSP-Anwendung zu verwenden sowie die
zentrale Verarbeitung
von Requests werden herausgearbeitet. Der Datenaustausch
zwischen Servlets
und JSP-Seiten ist ebenfalls Gegenstand dieses Kapitels.
Im fünfzehnten
Kapitel wird die Entwicklung von Java Beans sowie die Einbindung
derer in JSP-Seiten
besprochen. Anhand von Beispielen werden verschiedene Bean
Typen (Value Beans,
Utility Beans, etc.) diskutiert.
Kapitel sechzehn
handelt von der Entwicklung von Tag Libraries und wie diese im
Kern aufgebaut sind.
Anhand von Beispielen wird anschaulich erklärt wie Tag
Libraries realisiert
und in JSP-Seiten eingebunden werden. Am Ende dieses
Kapitels wird auf
das Deployment einer Tag Library eingegangen.
Das siebzehnte
Kapitel enthält ein ausführliches Beispiel für eine
Komponente
zum Zugriff auf
Datenbanken. Der Teil in dem Connection Pools behandelt werden
ist besonders interessant.
Der Anhang des Buches
enthält in Form von Referenzen die JSP-Elemente, JSP API,
Buchbeispiele, WEB-Anwendungsstrukturen
und Deployment Deskriptoren sowie
Links zu JSP-Resourcen.
Fazit
Das Buch Java Server
Pages von Hans Bergsten ist sowohl für Einsteiger als auch
Fortgeschrittene
JSP-Entwickler geeignet. In dem Buch werden die wesentlichen
Aspekte der JSP-Programmierung
besprochen. Der Inhalt des Buches wird
anschaulich anhand
von Beispielen vermittelt. Das Buch reiht sich in die qualitativ
hochwertigen Bücher
des OREILLY Verlages ein und ist deshalb eine Kaufempfehlung.
Link des Monats
Der Link ist für
das Projektmanagement von J2EE Anwendungen interessant.
Hinter dem Link
verbirgt sich eine Studie von Humphrey Sheil, in der die
zehn kritischen
Aspekte (Pit Falls) für die Realisierung von J2EE Anwendungen
besprochen werden.
www.javaworld.com/javaworld/jw-03-2001/jw-0330-ten_p.html
Neue Beiträge bei JSP Develop
JPEG - Größe und Resize aus JSP
Marc
Einfaches Codebeispiel zur Größenbestimmung und Resizen von JPEGs
Schlagwortsuche
in JSP-Seiten
shark
Für die Suche
von Informationen, in denen ein definiertes Schlagwort vorkommt,
benötigt man
intelligente Agenten.
Über den Link
www.freefind.com
kann man die Search Engine von FreeFind in
seine eigene Software
einbinden. Nach der Registrierung bei FreeFind erhält
man den entsprechenden
HTML-Code per eMail zugesendet. Der HTML-Code
kann sowohl für
die Suche nach Schlagworten im eigenen Internet-Auftritt als auch
für Suchen
im WEB verwendet werden.
XML APIs
shark
XML APIs verwendet
man zur Analyse und Verarbeitung von XML-Dokumenten.
Es gibt eine Reihe
von XML APIs für die Verarbeitung von XML Dokumenten.
Die beiden wichtigsten
APIs werden nachfolgend beschrieben:
Simple API for XML
(SAX) - SAX ist eine Event gesteuerte API. David Megginson
leitet das Projekt
und verwaltet die aktuelle API Dokumentation (www.megginson.com)
Document Object Model
(DOM) - Die DOM API ist eine Schnittstelle die auf dem hierarchischen
Modell basiert.
DOM bildet ein XML-Dokument als hierarchische Struktur im Speicher ab.
Die
DOM API beinhaltet
Methoden zum Bearbeiten der hierarchischen Struktur im Speicher.
DOM wird vom W3C
(www.w3c.org) gefördert und weiterentwickelt.
Zur Verarbeitung
der XML-Dokumente benötigt man einen XML-Parser. XML-Parser zerlegen
XML Dokumente in
Token und analysieren die Struktur eines Dokumentes. Der Open Source
Parser Xerces kann
über den Link: xml.apache.org heruntergeladen
werden.
Der nachfolgende Source Code Auszug zeigt, wie der Xerces Parser (SAX API) verwendet wird:
import org.apache.xerces.parsers.SAXParser;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import java.io.IOException;
public class SaxExample
{
public static
void main(String[] args)
{
if(1 != args.length)
{
System.out.println(Usage: java SaxExample <Datei/URL>");
System.exit(1);
}
// Name der XML-Datei lesen
String strXMLFile = args[0];
try
{
// Instanz des Xerces Parser erzeugen
XMLReader oSAXParser = new SAXParser();
// Content Handler setzen
// --> MyContentHandler ist eine Klasse die SAX-Events bearbeitet
// und deshalb Methoden des DefaultHandler Interfaces
ueberschreibt
oSAXParser.setContentHandler(new MyContentHandler());
// XML-Dokument parsen
oSAXParser.parse(strXMLFile);
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
catch(SAXException saxe)
{
saxe.printStackTrace();
}
}
}
Sollen XML-Dokumente
mit der SAX API bearbeitet werden, sollte man in seinem Programm
für die Bearbeitung
der Events und Speichern der Event Daten (Token des XML-Dokumentes)
sorgen.
DOM Strukturen (Baumstrukturen)
können aus XML Dokumenten erzeugt werden, umgekehrt
kann man auch aus
einer DOM Struktur ein XML-Dokument erstellen. DOM eignet sich besonders,
wenn mehrfach Zugriffe
auf ein XML-Dokument erfolgen. Der Nachteil von DOM ist, dass immer
das komplette XML-Dokument
vor der Verarbeitung in den Speicher geladen wird.
Der nachfolgende Source Code Auszug zeigt wie man eine DOM Struktur erzeugt:
import org.apache.xerces.parsers.DOMParser;
import org.w3c.dom.Dokument;
import java.io.IOException;
public class DOMExample
{
public static
void main(String[] args)
{
if(1 != args.length)
{
System.out.println(Usage: java DOMExample <Datei/URL>");
System.exit(1);
}
// Name der XML-Datei lesen
String strXMLFile = args[0];
try
{
// Instanz des Xerces Parser erzeugen
DOMParser oDOMParser = new DOMParser();
// XML-Dokument parsen und DOM Struktur erzeugen
oDOMParser.parse(strXMLFile);
// Dokument (DOM Struktur) Referenz ermitteln
Document oDocument = oDOMParser.getDocument();
// DOM Struktur bearbeiten ...
}
catch(Exception exc)
{
exc.printStackTrace();
}
}
}
SUN Microsystems
(TM) hat eine XML Parser unabhängige API mit dem Namen JAXP
(Java API for XML
Parsing) entwickelt. JAXP kann über den Link: java.sun.com/xml
heruntegeladen
werden. JAXP ist
eine allgemeine API die unabhängig von XML-Parser Implementierungen
ist.
JAXP ist eine Standardschittstelle
die den Factory Mechanismus zum Erzeugen von Parser Instanzen
verwendet. Das Konzept
ist sehr ähnlich dem Treiberkonzept von JDBC und JNDI realisiert worden.
Das nachfolgende Beispiel zeigt die Verwendung der SAX API anhand von JAXP:
import java.xml.parsers.SAXParserFactory;
import java.xml.parsers.SAXParser;
import java.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import java.io.IOException;
public class SaxExample
{
public static
void main(String[] args)
{
if(1 != args.length)
{
System.out.println(Usage: java SaxExample <Datei/URL>");
System.exit(1);
}
// Name der XML-Datei lesen
String strXMLFile = args[0];
try
{
// Instanz der SAX Parser Factory erzeugen
SAXParserFactory oFactory = SAXParserFactory.newInstance();
// Instanz des Xerces Parser erzeugen
SAXParser oSAXParser = oFactory.newSAXParse();
// Content Handler setzen und XML-Dokument parsen
// --> MyContentHandler ist eine Klasse die SAX-Events bearbeitet
// und deshalb Methoden des DefaultHandler Interfaces
ueberschreibt
oSAXParser.parse(strXMLFile, new MyContentHandler());
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
catch(SAXException saxe)
{
saxe.printStackTrace();
}
catch(ParserConfigurationException eco)
{
eco.printStackTrace();
}
}
}
In dem Beispiel erkennt
man, dass der SAX Parser mit einer Factory erzeugt wird. In dem
nachfolgenden DOM
Beispiel wird ebenfalls eine Factory zum Erzeugen des Parsers benutzt:
import java.xml.parsers.DocumentBuilderFactory;
import java.xml.parsers.DocumentBuilder;
import org.w3c.dom.Dokument;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.NamedNodeMap;
import java.io.IOException;
public class DOMExample
{
public static
void main(String[] args)
{
if(1 != args.length)
{
System.out.println(Usage: java DOMExample <Datei/URL>");
System.exit(1);
}
// Name der XML-Datei lesen
String strXMLFile = args[0];
try
{
// Instanz der DOM Parser Factory erzeugen
DocumentBuilderFactory oFactory = DocumentBuilderFactory.newInstance();
// Document Builder erzeugen
DocumentBuilder oBuilder = oFactory.newDocumentBuilder();
// XML-Dokument parsen
Document oDocument = oBuilder.parse(strXMLFile);
// Wurzel Knoten ermitteln
Node oRootNode = oDocument.getDocumentElement();
oRootNode.normalize();
// DOM Struktur bearbeiten ...
}
catch(Exception exc)
{
exc.printStackTrace();
}
}
}
Vor dem Ausführen
der Beispiele müssen die entsprechenden JAR-Dateien der Parser APIs
in den
Java ClassPath mit
aufgenommen werden. Für JAXP nimmt man nach der Installation der API
das
Archiv jaxp.jar
in den Java ClassPath mit auf.
Anregungen, Vorschlaege an: webmaster@jsp-develop.de.
Wenn Sie unseren Newsletter nicht mehr erhalten möchten, können Sie ihn unter
www.jsp-develop.de/newletter abbestellen.
Newsletter
(c) 2001 by www.jsp-develop.de Alle Rechte vorbehalten.