5/12 Java Server Pages

Java Server Pages
Teil 5/12.2.1 Seite 1
Übersicht
5/12.2
Grundlagen
5/12.2.1
Übersicht
Autor: Helmut Schopf
Java Server Pages wurden von Sun Microsystems entwickelt
und sind wie Active Server Pages serverseitig im Einsatz.
Was sind Java
Server Pages
Mit der JSP-Technologie besteht die Möglichkeit, die Webseitenentwicklung sauber aufzutrennen. Mittels HTML bzw.
XML können die Gestaltungselemente geschaffen werden
und mit JSPs werden die dynamischen Elemente einer Webseite geschaffen.
Zielsetzungen
Die JSP-Technologie ist so ausgelegt, dass eine gute Wiederverwendbarkeit und Plattformunabhängigkeit erreicht wird.
Wiederverwendbare Komponenten
Bei Webdesignern bzw. -entwicklern sollte man umfassende
Programmierkenntnisse nicht als normal voraussetzen. Bei
JSPs wird diesem Umstand Rechnung getragen, und viele
Elemente von JSP basieren auf XML-Tags. Standardmäßig
können über JSP aber auch Java Beans aufgerufen bzw.
Funktionsergebnisse abgerufen werden. Überdies kann der
Anwender auch noch auf Tag-Bibliotheken zugreifen.
Vereinfachen
der Seitenentwicklung mit Tags
JSP basiert auf Java und ist Bestandteil der J2EE Java 2 Enterprise Edition-Architektur von Sun Microsystems. So können JSPs in Java Servlets kompiliert werden und sind voll
einsatzfähig. Java-Technologie wie Bufferfunktionen oder
Fehlerbehandlung sind in JSP voll integriert. Bei JSP wurde
der Grundsatz „Write Once, Run Anywhere“ (einmal geschrieben, überall einsetzbar) weiter verfolgt.
14
Teil 5/12.2.1 Seite 2
Java Server Pages
Übersicht
Applikationsmodelle für Java Server Pages
Eine JSP-Seite wird auf einer JSP-Maschine ausgeführt. Diese muss Bestandteil des Servers, egal ob Web-Server oder
Applikations-Server, sein. Die JSP-Maschine erhält eine Anfrage vom Client auf die JSP-Seite. Nun wird eine Antwort
von der JSP-Seite generiert und dem Client übermittelt.
JSPs werden in Java Servlets kompiliert. Wird eine JSP-Seite
aufgerufen, wird sie zuerst in ein Java Servlet kompiliert und
im Server gespeichert. JSPs können in verschiedenen Anwendungsarchitekturen und Modellen arbeiten.
Beispiele
Die einfachste Anwendung ist die direkte Kommunikation
zwischen Browser, Client und JSP-Page. Die JSP ruft beispielsweise eine Datenbankabfrage auf, generiert das Ergebnis und erzeugt eine Webseite.
Abbildung 5/12.2.1-1: Die direkte Kommunikation ist nur
eingeschränkt einsetzbar
In diesem Beispiel wird das konventionelle CGI-Konzept mit
einem JSP durchgeführt. Diese Methode ist leicht realisierbar.
Der Autor kann auch schnell mit dynamischem Inhalt umgehen. Diese Vorgehensweise arbeitet bei vielen Applikationen
fehlerfrei. Will man aber beispielsweise viele Datenbankzugriffe realisieren, ist diese Lösung ungeeignet.
Flexible Lösung mit
einem Java Servlet
Die zweite Möglichkeit ist, mit einem Servlet zu arbeiten.
Der Client übergibt seine Anfrage sofort an das Servlet. Dieses geniert das dynamische Anfrageergebnis, wird an das JSP
übergeben und dort für den Client generiert. Hier können
über eine solche Konfiguration z.B. verschiedene Datenbankabfragen laufen.
Java Server Pages
Teil 5/12.2.1 Seite 3
Übersicht
Abbildung 5/12.2.1-2: Aufgaben verteilen und in Verbindung mit Java Beans arbeiten
Der Inhalt wird bei dieser Lösung nur über Java realisiert und
das Ergebnis in HTML dargestellt. Dies hat den Vorteil, dass
sich hier der Datenbankentwickler voll und ganz auf seinen
Bereich konzentrieren und der Webdesigner sich nicht um die
Datenbankproblematik kümmern muss.
Skalierbare Prozesse mit Enterprise JavaBeanTechnologie
Ein typischer Anwendungsfall ist das Aufteilen einer komplexen Aufgabenstellung, die oft auch eine umfangreichere
Lösung erfordert.
JSP vermittelt sozusagen zwischen den Back-End Ressourcen
über die Java Bean-Komponenten. Auf diese Art kann eine
sehr hohe Zahl von Anwendern bedient werden – eine
Grundvoraussetzung für E-Commerce. Dafür ist diese Art der
Lösung vorrangig gedacht.
Abbildung 5/12.2.1-3: Der Ansatz für komplexe Aufgaben
14
Teil 5/12.2.1 Seite 4
Java Server Pages
Übersicht
XML Technologie in JSP-Seiten
JSP-Seiten können HTML-, aber auch XML-Seiten erzeugen.
Für einfache Anwendungen können einfache statische XMLTags bzw. Templates eingesetzt werden. Für dynamisches
XML müssen Server-Based-Beans bzw. spezielle Tags verwendet werden.
JSPs sind zu den XML-Werkzeugen kompatibel. Die JSPSpezifikation von SunMicrosystems ist so ausgelegt, dass
JSP-Seiten schnell in XML-Seiten konvertiert werden können. Für die Umwandlung muss der JSP-Seite ein JSP RootElement hinzugefügt werden.
Fazit
JSP ist offen konzipiert und soll den Webdesigner bei der Erstellung dynamischer Webseiten unterstützen. JSP kann auf
unterschiedlichen Servern laufen, und auch die Anwendungsbereiche beginnen bei einfachen Lösungen. JSP ist aber
auch für komplexe Aufgabenstellungen wie E-CommerceLösungen geeignet.
JSP ist Bestandteil der J2EE und somit voll in Java integrierbar. Sie können einfach in Java Servlets kompiliert und in
XML-Dateien konvertiert werden.
Java Server Pages
Teil 5/12.2.2 Seite 1
Einführung
5/12.2.2
Einführung
Bevor wir mit den Details zu JSP beginnen, die sehr komplex
und umfangreich sind, hier ein erstes Beispiel, mit dem Sie
sofort loslegen können. Anhand dieses Beispiels wollen wir
Ihnen einige Aspekte von JSP erläutern.
<html>
<body>
<h1>Beispiel: Scripting Elemente</h1>
Beispiel 1.jsp
<%-- eine ’declaration’: Deklaration der
Methode square --%>
<%! int square (int n) { return n*n; } %>
<%-- ein Scriptlet: for Schleife --%>
<% for (int i = 1; i <= 10; i++) { %>
<%-- ein Ausruck (expression) --%>
<%=i %> times <%=i %> equals <%=square(i)
%>
<br>
<% } %>
</body>
</html>
Wie Sie sehen, kann man in JSP HTML-Tags mit Javacode
mischen. Das ist aber nur eine der Möglichkeiten, die JSP
bietet. Diese Möglichkeiten erlauben die Trennung von dynamischem und statischem Inhalt einer Seite. Neben dieser Mischung, die Sie oben sehen, gibt es in JSP noch die Möglichkeit, von JSP auf eine existierende Java-Klasse zuzugreifen,
also den Code nicht in die HTML-Seite zu schreiben, sondern in eine ganz normale Java-Klasse, die dann von JSP eingebunden wird. Wie dies genau geschieht, sehen Sie später.
14
HTML- und
Java-Mischung
Teil 5/12.2.2 Seite 2
Java Server Pages
Einführung
JSP und Servlets
Unterschiede und
Gemeinsamkeiten
Wenn Sie sich bereits mit Java Servlets befasst haben, werden Sie sicher die Frage stellen, welche Vorteile Java Server
Pages gegenüber Servlets haben. Sie können interaktive, dynamische Webseiten mit Servlets erstellen, wozu also Java
Server Pages? Ist die JSP-Technologie also einfacher,
schneller oder hat Sun Microsystems nur einen neuen „Hype“
geschaffen?
Auch wenn JSP den Einstieg in die Servlet-Programmierung
beschleunigen kann, gibt es dennoch mehrere wirklich interessante Gründe, sich mit der JSP-Technologie auseinanderzusetzen.
JSP setzen
auf Servlets auf
JSP setzen auf Servlets auf. Es ist somit eine Erweiterung der
Servlet-Technologie. JSP-Seiten werden dynamisch in Servlets kompiliert und vereinfachen somit die Verwendung von
statischen und dynamischen Daten. Damit haben Sie alle Vorteile von Servlets und können die Java APIs verwenden.
Natürlich können Sie mit Servlets interaktive, dynamische
Seiten erstellen, mit JSP wird dieser Prozess aber noch einmal vereinfacht. Sie können z.B. statische Templates in XML
oder HTML mit dynamischem Code kombinieren, so dass
Ihre Seite sowohl statische als auch dynamische Aspekte enthält. JSP-Seiten werden bei Bedarf dynamisch in Servlets
kompiliert. Es ist aber auch möglich, JSP-Seiten vorab in
Servlets zu kompilieren. Damit stehen Ihnen mehr Welten
offen als bei der Verwendung von Servlets.
Es gibt JSP-Schlüsselwörter, die JavaBeans verwalten und so
den Designer vor der Komplexität der Anwendung schützen.
Trennung
Denkbar ist hier z.B. eine Trennung von HTML/Web-Designer und Software-Entwickler. Die Struktur von JSP war außerdem vorausschauend, so dass die darunter liegende Struktur durchaus dafür gedacht ist, JSP-Seiten von Authoring
Tools (Autorenwerkzeugen) zu erzeugen, was die Entwicklung von JSP-Seiten enorm beschleunigt.
Java Server Pages
Teil 5/12.2.2 Seite 3
Einführung
Entwicklung anstelle von Seitenerstellung
Viele sehen in JSP eine Art „Servlets für Dummies“. Doch
das ist falsch. Es resultiert daraus, dass die Seitenerstellung
einfacher wird und eine komponentenbasierte Entwicklung
stattfinden kann. Entwickler können sich auf die Entwicklung
von Applikationslogik konzentrieren, anstelle sich mit dem
Entwerfen und Verwalten immer wieder neuer, individueller
Seiten zu befassen.
Entwickler
entwickeln,
Designer designen
Durch die Aufspaltung beim Erzeugen des Inhalts von Seiten
und dem Seitenlayout und Entwerfen von Designs erlauben
JSP die Entwicklung einer Multi-Tier-Applikation, basierend
auf dem WWW. Die größte Problematik besteht in der Erstellung von Seiten im Zusammenspiel von Grafik-Designern
und Entwicklern. JSP vereinfacht diese Schnittstelle.
• Entwickler können angepasste Schlüsselwortbibliotheken
(sog. Tag-Libraries) entwickeln, die die Autoren der Seite
dann wie z.B. XML-Syntax verwenden können. Da der
JSP-Container für die Kompilierung der Seiten verantwortlich ist, kann der Autor der Seiten Updates ganz einfach
einspielen.
• JSP-Seiten können ebenso JavaBeans als auch Enterprise
JavaBeans ansprechen, womit dann die komplizierte Geschäftslogik und Zugriff auf Host-Systeme oder andere
Backends gewährleistet wird. Diese Komponenten sind
dann natürlich auch anderweitig wiederverwendbar, was
die Entwicklungszeit verkürzt, und sie sind portabel, da sie
in Java geschrieben wurden. Es ist auch denkbar, dass es
einen Markt für solche Komponenten geben wird, was den
Entwickler mehr zu einem Bausteine-Entwickler als CodeProgrammierer werden lässt.
• Seitenautoren können die vorgegebenen Template-Teile
ändern und editieren, und das, sooft sie wollen. Damit verändert sich nicht die Applikationslogik. Andersherum können Entwickler die Logik ändern, ohne dass sich die Seiten
ändern müssen.
14
Vorteile von JSP
Teil 5/12.2.2 Seite 4
Java Server Pages
Einführung
Verbindung mit vorhandenen Servlets
JSP wird in
Servlets kompiliert
Die JSP-Technologie ist eine Erweiterung der Servlet-Technologie. Eine wurde bereits erwähnt, nämlich dass JSP-Seiten
in Servlets kompiliert werden.
Eine andere Möglichkeit ist das Einbinden von Servlets in
JSP-Seiten und umgekehrt sowie das Delegieren von Anfragen an Servlets und von Servlets an JSP. Wenn Sie also schon
Servlets haben, müssen Sie nicht alles wieder verwerfen,
wenn Sie auf JSP umstellen möchten. Im Gegenteil, Sie können diese verwenden und via JSP eventuell noch einfacher
und besser verteilen, besser warten und, wie oben beschrieben, Änderungen im Design oder in der Logik vornehmen,
ohne den anderen Teil in Mitleidenschaft zu ziehen.
Java Server Pages
Teil 5/12.3.1 Seite 1
Marktübersicht
5/12.3
JSP-Engines
Es gibt einige Anbieter von Servlet/JSP-Engines. Diese sind
nötig, damit man mit Servlets und JSP überhaupt arbeiten
kann. Einige davon möchte wir hier kurz vorstellen und vergleichen. Eine Empfehlung wird aber nicht ausgesprochen,
da die Engines sehr unterschiedlich und die Ansprüche an
eine Engine problembezogen sind.
5/12.3.1
•
•
•
•
•
•
•
•
•
•
•
•
14
Marktübersicht
Apache: JServ/GNU-JSP
LiveSoftware/Allaire: JRun
NewAtlanta: ServletExec (wird von Gemstone verwendet)
Netscape: Enterprise Server 4.0 mit eingebauter ServletEngine
Lotus: Domino Server mit GWAPI (OS390)
Caucho: Resin 1.0
Sun: Java Web-Server JWSDK 1.0
PolyJsp
SJSP
IBM: WebSphere Application Server
Orion Web-Server
und andere…
Teil 5/12.3.1 Seite 2
Marktübersicht
Java Server Pages
Java Server Pages
Teil 5/12.3.2 Seite 1
Testumgebung
5/12.3.2
Testumgebung
Die Testkonfiguration geht von realen Fällen aus, also nicht
einfach ein paar JSP-Seiten und Servlets, sondern mit Anbindung an Brokat Twister, das als Middleware fungiert. Daher
wurden hier Brokat-spezifische Klassen für die Middleware
verwendet. Diese sollten Sie aber nicht abschrecken, denn
Sie werden mit Ihren Servlets und JSP-Seiten auch auf andere Objekte zugreifen, in diesem Fall sind es eben die von
Brokat.
Reale Fälle
Des Weiteren wurde die „Punk“-Applikation verwendet. Diese verbindet sich mit einer URL, und man kann mit der Option -t die Anzahl der Threads angeben und mit der Option -c
die Anzahl der Schleifen. Auch Cookies können damit verwaltet werden, um sich die Performance von Sessions anzusehen.
PunkTestapplikation
Der Aufruf sieht folgendermaßen aus:
$java punk
Usage: java punk -h http://localhost/date.jsp -t 10 -c 10
-h <target>
destination host and url
-t <threads> n parallel sessions
-c <cycles>
repeat n times each session
-x <csvfile> append statistics to specified file
-s
silent mode
-?
show this help
Wie Sie sehen, wurde eine JSP-Seite date.jp verwendet. Diese greift auf eine Bean zu. Beide Dateien wurden angegeben,
damit Sie sehen, welcher Code unseren Tests zu Grunde lag.
Außerdem wurde noch eine andere Applikation, PerfTest,
geschrieben, die wiederum eine JSP-Seite und eine Bean enthält. Diese greift außerdem auf die Brokat Twister Middleware zu.
14
Teil 5/12.3.2 Seite 2
Java Server Pages
Testumgebung
date.jsp
<html>
<USEBEAN name="date" type="beans.BeanDate" lifespan="page">
</USEBEAN>
<body>
<h1> Server Time</h1>
<ul>
<li>Month
: <DISPLAY property=date:Month>
<li>Year
: <DISPLAY property=date:Year>
<li>Day
: <DISPLAY property=date:Day>
<li>Time
: <DISPLAY property=date:Time>
<li>Date
: <DISPLAY property=date:Date>
<li>Day Of Year : <DISPLAY property=date:DayOfYear>
<li>Week Of Year: <DISPLAY property=date:WeekOfYear>
<li>Day of month: <DISPLAY property=date:DayOfMonth>
<li>Era
: <DISPLAY property=date:Era>
<li>DST Offset : <DISPLAY property=date:DSTOffset>
<li>Zone Offset : <DISPLAY property=date:ZoneOffset>
<li>Time zone
: <DISPLAY property=date:TimeZone>
</ul>
</body>
</html>
BeanDate.java
package beans;
import java.text.DateFormat;
import java.util.*;
public class BeanDate
{
Calendar calendar = null;
public BeanDate()
{
calendar = Calendar.getInstance();
Date trialTime = new Date();
calendar.setTime(trialTime);
}
Java Server Pages
Teil 5/12.3.2 Seite 3
Testumgebung
public int getYear()
{
return calendar.get(Calendar.YEAR);
}
public String getMonth()
{
int m = getMonthInt();
String[] months = new String [] {
"January", "February", "March",
"April", "May", "June",
"July", "August", "September",
"October", "November", "December" };
if (m > 12)
{
return "Unknown to Man";
}
return months[m - 1];
}
public String getDay()
{
int x = getDayOfWeek();
String[] days = new String[] {"Sunday", "Monday", "Tuesday",
"Wednesday",
"Thursday", "Friday", "Saturday"};
if (x > 7)
{
return "Unknown to Man";
}
return days[x - 1];
}
public int getMonthInt()
{
return 1 + calendar.get(Calendar.MONTH);
}
public String getDate()
{
return getMonthInt() + "/" + getDayOfMonth() + "/" +
getYear();
}
14
Teil 5/12.3.2 Seite 4
Java Server Pages
Testumgebung
public String getTime()
{
return getHour() + ":" + getMinute() + ":" + getSecond();
}
public int getDayOfMonth()
{
return calendar.get (Calendar.DAY_OF_MONTH);
}
public int getDayOfYear()
{
return calendar.get (Calendar.DAY_OF_YEAR);
}
public int getWeekOfYear()
{
return calendar.get (Calendar.WEEK_OF_YEAR);
}
public int getWeekOfMonth()
{
return calendar.get (Calendar.WEEK_OF_MONTH);
}
public int getDayOfWeek()
{
return calendar.get (Calendar.DAY_OF_WEEK);
}
public int getHour()
{
return calendar.get (Calendar.HOUR_OF_DAY);
}
public int getMinute()
{
return calendar.get(Calendar.MINUTE);
}
public int getSecond()
{
return calendar.get(Calendar.SECOND);
Java Server Pages
Teil 5/12.3.2 Seite 5
Testumgebung
}
public static void main(String args[])
{
BeanDate db = new BeanDate();
p("DayOfMonth: " + db.getDayOfMonth());
p("Year: " + db.getYear());
p("Month: " + db.getMonth());
p("Time: " + db.getTime());
p("Date: " + db.getDate());
p("Day: " + db.getDay());
p("DayOfYear: " + db.getDayOfYear());
p("WeekOfYear: " + db.getWeekOfYear());
p("Era: " + db.getEra());
p("AMPM: " + db.getAMPM());
p("DSTOffset: " + db.getDSTOffset());
p("ZONEOffset: " + db.getZoneOffset());
p("TimeZone: " + db.getTimeZone());
}
public int getEra()
{
return calendar.get(Calendar.ERA);
}
public String getTimeZone()
{
String aZones[] = new String[12];
aZones[0] = "Hawaii"
;
aZones[1] = "Alaskan"
;
aZones[2] = "Pacific"
;
aZones[3] = "Mountain"
;
aZones[4] = "Central"
;
aZones[5] = "Eastern"
;
aZones[6] = "Greenland"
;
aZones[7] = "Iceland"
;
aZones[8] = "Atlantic"
;
aZones[9] = "Central Europe"
;
aZones[10] = "Eastern Europe" ;
aZones[11] = "Western Russia" ;
return aZones[4 + getZoneOffset()];
}
14
Teil 5/12.3.2 Seite 6
Java Server Pages
Testumgebung
public int getZoneOffset()
{
return calendar.get (Calendar.ZONE_OFFSET)/(60*60*1000);
}
public int getDSTOffset()
{
return calendar.get (Calendar.DST_OFFSET)/(60*60*1000);
}
public int getAMPM()
{
return calendar.get(Calendar.AM_PM);
}
private static void p(String x)
{
System.out.println(x);
}
}
PerfTest.jsp
<html>
<!-PerfTest.jsp
-->
<USEBEAN name="twobject1" class="beans.PerfTest"
type="beans.PerfTest" lifespan="session">
</USEBEAN>
<meta http-equiv="refresh" content="0; URL=PerfTest.jsp">
<head>
<title>PerfTest JSP</title>
<%@ language="java" %>
<%@ import="java.util.Date" %>
<%@ import="java.util.Enumeration" %>
<%@ import="javax.servlet.*" %>
<%@ import="javax.servlet.http.*" %>
Java Server Pages
Teil 5/12.3.2 Seite 7
Testumgebung
</head>
<body>
<h2>PerfTest</h2>
<hr>
<%
try
{
twobject1.execute();
}
catch (Throwable e)
{
out.print("<h1>Error: "+e+"</h1>\n");
}
%>
<h4>Requests per second:
<%= twobject1.getReqPerSec() %>
</h4>
<h4>Request Duration
<%= twobject1.getDuration() %>
ms</h4>
<h4>PerfTest Bean Counter (1 - 100):
<%= twobject1.getCount() %>
</h4>
<h4>PerfTest RDO Counter:
<%= twobject1.getRDOCount() %>
</h4>
<hr>
<pre>
HTTPSession
----------<%
HttpSession session = request.getSession (true);
String aStr[] = session.getValueNames();
int ic=0;
for (; ic<aStr.length; ic++)
{
out.print("Session value name: "+aStr[ic]+" =
"+session.getValue (aStr[ic])+"<br>");
}
Integer ival = (Integer) session.getValue ("counter");
14
Teil 5/12.3.2 Seite 8
Java Server Pages
Testumgebung
if (ival == null)
{
ival = new Integer (1);
}
else
{
ival = new Integer (ival.intValue () + 1);
}
session.putValue ("counter", ival);
out.print("Session creation time
: "+ new
Date(session.getCreationTime())+"<br>");
out.print("Session last access time: "+ new Date (session.
GetLastAccessedTime ())+"<br>");
out.print("Session id
: "+ session.getId()+"<br>");
%>
HTTPRequest Header
-----------------<% java.util.Enumeration e = request. getHeaderNames();
while (e.hasMoreElements())
{
String s = (String) e.nextElement();
out.println(" "+s+" = "+request.getHeader(s));
}
%>
HTTPRequest-Information
----------------------<% javax.servlet.http.Cookie c[] = request. getCookies();
for (int i=0; i<c.length; i++)
out.print(" Cookie["+i+"] = "+c[i].getName()+" =
"+c[i].getValue());
%>
AuthType = <%= request.getAuthType() %>
Method = <%= request.getMethod() %>
PathInfo = <%= request.getPathInfo() %>
PathTranslated = <%= request. getPathTranslated() %>
QueryString = <%= request.getQueryString() %>
RemoteUser = <%= request.getRemoteUser() %>
RequestedSessionId = <%= request.getRequestedSessionId() %>
RequestURI = <%= request.getRequestURI() %>
Java Server Pages
Teil 5/12.3.2 Seite 9
Testumgebung
ServletPath = <%= request.getServletPath() %>
</pre>
</font>
</body>
</html>
PerfTest.java
package beans;
import com.brokat.twister.*;
import java.io.*;
public class PerfTest
{
private String target = "demo.PerfTest";
private String result = "";
private long lTimeStart = System.currentTimeMillis();
private long duration = 0;
private long counter = 1;
private int iRDOCounter = -1;
private int iReqPerSec = 0;
private BSession session1 = null;
private BObject object = null;
static boolean bIsInit = false;
public BAnythingPool apool = new BAnythingPool();
public BAnythingPool rpool = null;
private synchronized void init()
{
if (!bIsInit)
{
BStdLib.init ("PerfTest");
BStdLib.setLogTCP ("pc-kschulz", 10010);
BStdLib.log ("PerfTest initialization finished");
bIsInit = true;
}
}
public PerfTest()
14
Teil 5/12.3.2 Seite 10
Java Server Pages
Testumgebung
{
}
public void execute() throws IOException
{
long t1 = System.currentTimeMillis();
long t2 = -1;
this.init ();
if (session1==null)
session1 = BSession.newSession();
rpool = new BAnythingPool();
if (session1.process(target, apool, rpool) ==
BError.failed())
throw new IOException("Request failed for session1: " +
target);
t2 = System.currentTimeMillis();
duration = t2 - t1;
counter++;
iRDOCounter = rpool.getLong ("OUT_COUNTER");
iReqPerSec = (int) ((counter*1000)/(t2-lTimeStart));
if (counter % 100 == 0)
{
counter = 1;
lTimeStart = System. currentTimeMillis();
}
}
public long getDuration ()
{
return duration;
}
public int getReqPerSec ()
{
return(iReqPerSec);
}
public long getCount ()
{
return counter;
Java Server Pages
Teil 5/12.3.2 Seite 11
Testumgebung
}
public int getRDOCount ()
{
return iRDOCounter;
}
public static void main ( String args[] ) throws Exception
{
PerfTest perftest = new PerfTest();
perftest.execute();
System.exit(1);
}
}
14
Teil 5/12.3.2 Seite 12
Testumgebung
Java Server Pages
Java Server Pages
Teil 5/12.3.3 Seite 1
Apache 1.3.6/JServ1.05b/Gnu-JSP 0.92
5/12.3.3
Apache 1.3.6/JServ1.05b/
Gnu-JSP 0.92
Komponente
Beschreibung
Hardware
Sun Sparc Ultra2 mit Solaris 2.5.1.
Limit: 100 Prozesse/Anwender!
Performance
Dreimal langsamer als Netscape Enterprise Server 4.0.
Skalierbarkeit
Mit steigender Zahl von parallelen Anfragen steigt die Laufzeit
für eine einzelne Anfrage unproportional hoch. Das kann am
Limit liegen, konnte aber nicht verifiziert werden.
Stabilität
JServ erzeugt häufig einen ClassFormatError.
JDK-1.1.7 auf Solaris hat einen Memory Leak, d.h. die VM
wächst unendlich
Verfügbarkeit
Unix und NT. Auf NT war es eine Betaversion!
Sonstiges
Für Stronghold, der kommerziellen Version von Apache, sollten die Ergebnisse dieselben sein.
14
Teil 5/12.3.3 Seite 2
Apache 1.3.6/JServ1.05b/Gnu-JSP 0.92
Java Server Pages
Java Server Pages
Teil 5/12.3.4 Seite 1
ServletExec-2.2
5/12.3.4
ServletExec-2.2
Komponente
Beschreibung
Hardware
Sun Solaris 2.5.1 E450, 4 CPUs
Performance
date.jsp : Peak 40 Anfragen/Sekunde
PerfTest.jsp: Peak 31 Anfragen/Sekunde
Skalierbarkeit
Die Performance lag zwischen 24 - 31 Anfragen/Sekunde (r/s):
•
•
•
•
•
•
punk –c 10 –t 10 von einem PC: 24 r/s
punk –c 20 –t 20 von einem PC: 24 r/s
punk –c 50 –t 50 von einem PC: 27 r/s
punk –c 150 –t 150 von einem PC: 31 r/s
punk –c 50 –t 50 von einem PC: 24 r/s
punk –c 150 –t 150 von einem PC: 28 r/s
Stabilität
keine Probleme
Verfügbarkeit
Apache 1.3, Microsoft IIS 4.x, Netscape 3.x und 4.0 und MacOS
Server
Sonstiges
Die Administration ist sehr einfach und erfolgt Web-basiert.
14
Teil 5/12.3.4 Seite 2
ServletExec-2.2
Java Server Pages
Java Server Pages
Teil 5/12.3.5 Seite 1
Netscape 4.0 auf Solaris
5/12.3.5
Netscape 4.0 auf Solaris
Komponente
Beschreibung
Hardware
Sun Solaris E450, 4 CPUs
Performance
date.jsp :
Peak 69 r/s
PerfTest.jsp: Peak 31 r/s
Skalierbarkeit
Die Performance war stabil und lag um die 25 r/s:
• punk –c 800 –t 25 von einem PC
• punk –c 100 –t 25 von drei PCs
• punk –c 200 –t 25 von drei PCs
Stabilität
14
punk –c 200 –t 25 von drei PCs:
Plötzlich starb der Web-Server und musste neu gestartet werden. Gründe konnte nicht identifiziert werden.
Teil 5/12.3.5 Seite 2
Netscape 4.0 auf Solaris
Java Server Pages
Java Server Pages
Teil 5/12.3.6 Seite 1
Netscape 4.0 auf NT
5/12.3.6
Netscape 4.0 auf NT
Komponente
Beschreibung
Hardware
Pentium II/233, 128 MB Speicher
Performance
date.jsp :
Peak 25 r/s.
PerfTest.jsp: Peak 18 r/s
Skalierbarkeit
punk –c 800 –t 25 von lokalem PC: N/A.
Kam einem Denial Of Service nahe.
punk –c 100 –t 100 von lokalem PC: 21 r/s.
punk –c 200 –t 25 von lokalem PC: 19 r/s.
Für hohe Last ist diese Kombination nicht zu empfehlen.
Stabilität
punk –c 800 –t 25 schoss den Web-Server ab.
Denial of Service!
Nachdem die obigen Tests vorgenommen wurden, haben wir
uns für ServletExec und Netscape 4.0 Web-Server entschieden und weitere Tests durchgeführt. Die Ergebnisse waren
wie nachfolgend beschrieben.
Für die Tests wurde folgende Konfiguration verwendet:
• SUN Enterprise 450 (4 x 400 MHz, 1 GByte RAM, Solaris
2.6)
• Netscape Enterprise Server 4.0
• JDK 1.1.8
• ServletExec 2.2
• Client-Rechner: bis zu vier NT-Rechner, mit P2- bzw. P3Prozessoren.
• Client-Applikation: "Punk"
• Server-Applikation: PerfTest10.jsp, date10.jsp
Anzahl Request
Parallel
PC-1
PC-2
5000
50
90r/s
60r/s
5000
100
97r/s
74r/s
14
Beschreibung
der Testumgebung
Teil 5/12.3.6 Seite 2
Netscape 4.0 auf NT
Java Server Pages