ppt - ITI
Werbung
Java Server Pages 2 und
Benutzerdefinierte Tags
Strahil Yordanov
Überblick
Einleitung
JSP im Kontext von J2EE
JSP2
Benutzerdefinierte Tags
Zusammenfassung
Einleitung
Java Server Pages ist eine Technik für die
Entwicklung dynamischer Web-Seiten.
JSP ermöglicht die schriftliche
Spezifikation von der Erzeugung einer
dynamischen Antwort auf eine Anforderung
JSP unterstützt die Trennung zwischen Sicht
und Geschäftslogik für eine
Webanwendung.
JSP und J2EE
In der Regel, legt J2EE das Modell wobei viele Benutzer
über das Web auf eine Anwendung zugreifen fest.
JSP ist so sehr gut für die Präsentationsschicht der J2EE
geeignet.
JSP entspricht die “View“-Ebene beim MVC Modell:
JSP und J2EE
JSP ist auf eine andere Technologie zur
dynamischen Generierung von Dokumenten
basiert—Java Servlets.
Ein Servlet ist eine Java Klasse die auf einen
Server lauft und Anforderungen von Client
Browsers ausführt.
Das Servlet generiert dynamische Web-Seiten
durch Einbettung von HTML in seinem Java
Code.
JSP und J2EE
JSP Seiten führen dasselbe Funktion wie
Servlets aus. Diesmal aber, sie erreichen das
durch die Einbettung von Java Code (oder
anderem Skript Sprache) in HTML.
Deshalb können sie auch wie „umgestülpte“
Servlets gezeichnet werden.
JSP und J2EE
Bei Übersetzung, JSP Quell-Code ist erst zu
Servlet Code und dann zu ausführbarem
Programm umgewandelt.
Der Lebenszyklus einer JSP-Seite ist wie
folgt:
JSP und J2EE
Hier ist ein Beispiel der Übersetzung. Das
ist ein Teil der JSP Seite:
<HTML>
<BODY>
<%! String name = new String("BOB"); %>
<%! public String getName() { return name; } %>
Hello <B><%= getName() %></B>
</BODY>
</HTML>
Und hier ist der entsprechende Teil des
generierten Servlets:
out.write("<HTML>\r\n<BODY>\r\n\r\n");
// end
// begin
out.write("\r\n");
// end
// begin
out.write("\r\n\r\nHello <B>");
// end
// begin [file="D:\\Expressions.jsp";from=(6,12);to=(6,23)]
out.print( getName() );
// end
// begin
out.write("</B>\r\n\r\n</BODY>\r\n</HTML>\r\n");
// end
JSP2
JSP 2.0 ist ein Upgrade von JSP 1.2.
Die folgenden syntaktischen Schwerpunkte
sind in JSP2 von den vorigen Versionen
geerbt:
Skripte
Direktive
Standard Aktionen
Skripte
Skripte versehen JSP mit dynamischer
Verhaltung.
Mit denen kann man Variablen vereinbaren
und lesen, Iteration und Bedingungen
verwenden, usw.
Das Ergebnis von ihren Ausdrücken kann
als Teil vom HTML Code verwandet
werden.
Direktive
Direktive bestimmen globale Bedingungen
für die jeweilige JSP Seite.
Unter anderen sie können:
Die JDK Klassen die in dem Dokument zur
Verfügung sind bestimmen
Eine Datei zur Übersetzungszeit einfügen
Tagbibliotheken vereinbaren
Standard Aktionen
Standard Aktionen liefern Funktionalität die
in JSP Seiten oft nötig ist. Sie haben die
Syntax von XML tags und u. a.
JavaBeans in der Seite integrieren,
Kontrolle anderen Seiten weiterleiten
Ausgaben anderer Seiten zur Anfragezeit
einbetten
Die Syntax wird in wesentlich so gegliedert:
Beispiel
<%@page import="java.util.*" %>
<HTML>
<HEAD> <TITLE>JSP Example</TITLE>
</HEAD>
<BODY BGCOLOR="ffffcc">
<CENTER>
<H2>Date and Time</H2>
<%
java.util.Date today = new java.util.Date();
If (today.getYear() + 1900 < 2004)
{%><jsp:forward page="TooLate.jsp"><%}
else
out.println("Today's date is: "+today);
%>
</CENTER>
</BODY>
</HTML>
Direktive
Skript
Standart Aktion
Expression Language
JSP2 bietet eine einfache Syntax, die Skripte ersetzen soll. Sie heißt
„Expression Language“.
Die folgenden Skripten können mit EL viel einfacher ausgedrückt werden.
<someTags:aTag attribute="<%pageContext.getAttribute("aName") %>">
.
<%= aCustomer.getAddress().getCountry() %>
In EL das sieht so aus:
<someTags:aTag attribute="${aName}">
.
${aCustomer.address.country}
JavaBeans und JSP
Java Beans wird erfolgreich bei der Konstruktion
grafischer Benutzeroberflasche eingesetzt.
Sie speichern die Geschäftslogik in „Code-Behind“
Klassen und können durch die folgenden JSP
Standartaktionen manipuliert werden:
<jsp:useBean..>, <jsp:setProperty..> ,<jsp:getProperty>
JavaBeans und JSP
Die Verwendung dieser Komponenten in JSP bringt die
folgende Vorteile:
Auslagerung von Java-Code und damit eine Bessere
Aufteilung bei der Entwicklung von Anwendungen
Verwendung schon existierender Komponente
Bequemer Zugriff auf Daten aus HTML-Formularen
Temporäre Speicherung von Daten für die Dauer
mehrer Anfragen
Benutzerdefinierte Tags
Benutzerdefinierte Tags kapseln
Funktionalität für Wiederverwendung.
Tags minimieren den Anteil Java-Code in
JSP Seiten
Tags bieten stärkere Abstraktion als JavaCode
Tags sorgen durch Wiederverwendung für
ein konsistentes Aussehen Ihrer Seiten.
Benutzerdefinierte Tags
Tags werden durch Tag-Handlers definiert. TagHandlers sind Java Klassen, die die Funktionalität
der Tags enthalten.
Tag-Handlers werden in Tag-Bibliotheken
gespeichert. Tag-Bibliotheken sind in der Regel in
der Form einer Jar-Datei.
Der Inhalt der Tag-Bibliotheken wird durch eine
XML-Datei beschreibt. Die ist der Tag Library
Descriptor(TLD).
Benutzerdefinierte Tags
Benutzerdefinierte Tags u.a. können:
Attribute einsetzen.
einen Body haben. Den können sie verarbeiten
oder einfach erzeugen.
Ineinander geschachtelt werden
Miteinander kommunizieren
Beispiel: Definierung eines Tages
Der Tag-Handler:
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
public class HelloTag extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
getJspContext().getOut().write("This is my first tag!");
}
}
Der Eintrag im Tag Library Descriptor:
<tag>
<description>Prints this is my first tag</description>
<name>hello</name>
<tag-class>jsp2.examples.simpletag.HelloTag</tag-class>
<body-content>empty</body-content>
</tag>
Die JSP Seite. Die taglib Direktive vereinbart die Tagbibliothek zu
Benutzung. Ihrer Name und die URI vom TLD werden als Attribute eingegeben.
<%@ taglib prefix="mytag" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
<HTML>
<HEAD> <TITLE>Simple Tag Handler</TITLE> </HEAD>
<BODY>
<H2>Simple Tag Handler</H2> <P>
<B>My first tag prints</B>: <mytag:hello/>
</BODY>
</HTML>
Zusammenfassung
JSP2 hat das Ziel JSP Programmierung
einfacher zu machen, und zwar sie ohne
Kenntnisse von JAVA zu ermöglichen.
Eine saubere Trennung zwischen Design
und Programmierung dynamischer WebSeiten wird dafür verwirklicht.
Referenzen:
Volker Turau, Krister Saleck. Java Server Pages und J2EE. dpunkt-Verlag, Heidelberg,
2001
Stefan Wille. Go To Java Server Pages. Addison-Wesley Verlag, München, 2001
http://java.sun.com/webservices/docs/1.3/tutorial/doc/JSPTags.html
http://java.sun.com/webservices/docs/1.3/tutorial/doc/JSPIntro.html
http://java.sun.com/developer/technicalArticles/javaserverpages/JSP20/
