JSP
Inhalt
1 Hypertext
Transfer Protocol 3
1.1 HTTP
Allgemein. 3
1.2 POST
/ GET. 4
1.3 Error-Codes. 4
2 Sessions. 4
2.1 Allgemeines
zu Sessions. 4
2.2 Sessions
in JSP. 5
2.3 Wann
wird eine Session beendet?. 5
3 JSP. 5
3.1 Syntax. 5
3.2 Aufbau. 6
3.2.1 Direktiven. 6
3.2.2 Skriptingelemente. 7
3.2.3 Action-Elemente. 8
3.3 Beispiel 9
4 Servlets. 10
4.1 Syntax. 10
4.2 Aufbau. 10
4.3 Beispiel 11
4.4 Konfiguration
von web.xml 11
5 Beans. 12
5.1 Syntax. 13
5.2 Aufbau. 13
5.3 Beispiel 13
6 JDBC.. 13
6.1 Allgemeines. 13
6.2 Anwendung. 13
6.3 Hilfreiche
Websiten. 13
1
Hypertext Transfer Protocol
1.1
HTTP Allgemein
Das Hypertext Transfer Protocol ist ein
Protokoll zur Übertragung von Daten über ein Netzwerk. Es wird hauptsächlich
eingesetzt, um Webseiten aus dem World Wide Web in einen Webbrowser zu laden.
Die Kommunikation mittels HTTP besteht
immer aus einem Request und einer Response dazu.
(Request = Anfrage an den Server, Response = Antwort vom Server, siehe Bild)
Jede HTTP-Nachricht besteht dabei aus zwei
Teilen, dem Header und dem Body. Der Header enthält Informationen über den Body,
damit dieser vom Empfänger korrekt interpretiert werden kann. Der Body enthält
schließlich die Nutzdaten.
Ein Beispiel eines Headers:
1.2
POST / GET
Zur Übergabe von Parametern via HTTP gibt
es zwei bekannte Methoden: Die GET-Methode und die POST-Methode.
GET-Methode:
Die Parameter werden dabei einfach durch ein
Fragezeichen an die URL angehängt. Welche Parameter mit der GET-Methode
übergeben werden, ist somit für den User sofort ersichtlich.
Beispiel
?search=Katzen&go=Artikel
? à Beginn Parameterübergabe
Parametername=Parameterwert
& à Trennung zwischen Parametern
POST-Methode:
Im Unterschied zum GET-Request werden bei
POST die Parameter nicht an den URL angehängt, sondern im Body des Requests
selbst mitgesendet. D.h. die Parameter folgen, nachdem der Header-Bereich mit
einer Leerzeile abgetrennt wurde. Die Übergabe von Parametern mittels der
POST-Methode ist somit für den User nicht sofort ersichtlich.
Beispiel
Body:
parametername=parameterwert&zweiterparamertname=zweiterparameterwert
1.3
Error-Codes
Nummer
|
Bezeichnung
|
1xx
|
Informationen
|
2xx
|
Erfolgreiche
Operation
|
3xx
|
Umleitung
|
4xx
|
Client-Fehler
|
5xx
|
Server-Fehler
|
Berühmte Errors
·
401 – Unauthorized
·
403 – Forbidden
·
404 - Not Found
·
408 - Request Timeout
·
500 - Internal Server ErrorSessions
1.1
Allgemeines zu Sessions
Wir benötigen einen Zustand, sobald man
mehrere Anfragen tätigt. Bei einem Web Mailer bspw. loggt sich die Nutzerin
einmal ein. Klickt sie im weiteren Verlauf auf eine Mail, um sich diese
anzusehen, so werden ihre Logindaten natürlich nicht mehr abgefragt. Sie werden
aber auch nicht mit dem Formular oder den Links mitgeschickt. D.h. der Server
kann erkennen, dass die Anfrage zu der vorherigen gehört, dass beide Anfragen
(und weitere folgende) eine gemeinsame Nutzungssitzung, die Session, bilden.
Das Session-Konzept sieht zum einen ein Erkennungsmerkmal vor, anhand dessen
der Webserver trotz des statuslosen Protokolls HTTP erkennen kann, dass mehrere
aufeinanderfolgende Requests zu einer Session gehören. Zum anderen ist
integraler Bestandteil dieses Konzepts, dass eine Session einen Speicherbereich
nutzt, auf den alle Anfragen eben dieser Session zugreifen können, von dem aber
Anfragen, die zu anderen Sessions gehören, ausgeschlossen sind. Im Beispiel des
Web Mailers könnten in der Session also bspw. die Verbindungsdaten dieser
Nutzerin zu ihrem Mail-Provider gespeichert werden. Ebenso, welcher Ordner
gerade geöffnet ist, bei mehreren Mailkonten auch, welches dieser Konten gerade
aktuell verwaltet wird usw.
1.2
Sessions in JSP
// setzen einer Session Variable
session.setAttribute("name", lstrName);
// lesen der Session Variablen
String lstrName = (String) session.getAttribute("name");
// löscht die Session (alle Sessionvariablen)
session.invalidate();
1.3
Wann wird eine Session beendet?
Sessions haben nur eine beschränkte
Lebensdauer. Zum Beispiel kann die Session-Zeit durch einen Timer festgelegt
werden. Weiter wird die Session beendet, wenn der Browser geschlossen wird,
Cookies oder Cache gelöscht werden, es einen Stromausfall gibt und dadurch der
Computer ausgeschalten wird, oder wenn man sich auf einer Website abmeldet auf
welcher man sich mittels eines Logins identifiziert hat.
2
JSP
JSP wird für das Produzieren von dynamischen, webbasierten Inhalten
genutzt.
Wenn eine JSP zum ersten Mal aufgerufen wird, wird es zu einem Servlet
umgewandelt. Die JSP wird zuerst in Java Code übersetzt und dann kompiliert.
JSP wird für die grafische Darstellung der Inhalte benötigt.
2.1
Syntax
Die JSP-Tags stehen in einem statischen Code Teil wie HTML oder XML.
Sie stehen immer in ‚<‘ und ‚>‘, es wird kein Semikolon am Ende der Zeile
benötigt.
2.2
Aufbau
Eine JSP kann grob in die folgenden Elemente aufgeteilt werden:
·
Die Direktiven
·
Die Skriptingelemente
·
Die Aktionen
2.2.1
Direktiven
JSP kennt drei verschiedene
Direktiven:
Die page Direktiven,
Die include Direktiven
Die taglib Direktiven
Die Syntax einer
Direktive hat allgemein die folgende Form:
<%@ Direktive {Attribut="Wert"}* %>
2.2.1.1
Die „page“-Direktive
Die erste Direktive
ist die page-Direktive mit welcher man verschiedene Eigenschaften einer
JSP-Seite definieren und ändern kann.
Die Direktive „page“ kennt folgende Attribute:
Attribut
|
Standardwert
|
Beschreibung
|
language
|
java
|
Definiert die verwendete Scripting-Sprache. Es gibt
Servlet-Container, welche nebst Java auch Java-Script erlauben.
|
extends
|
|
Kann verwendet werden für das definieren der Superklasse, welche
verwendet werden soll.
|
import
|
|
Importiert benötigte Packate und / oder Klassen.
|
session
|
true
|
Wenn dieser Wert auf true gesetzt ist, wird das implizite Objekt
session erstellt und die JSP-Seite "nimmt" an einer Session teil.
|
buffer
|
8kb
|
Definiert die verwendete Buffer-Grösse.
|
autoFlush
|
true
|
Definiert, ob der Buffer automatisch gesendet werden soll, wenn
der Buffer voll ist. Wenn dieser Wert false gesetzt wird und der Buffer
überläuft, wird eine Exception geworfen.
|
isThreadSafe
|
true
|
Indiziert das Thread-Modell, welches für die Ausführung der
"JSP-Seite" vom Servlet-Container verwendet wird. Wenn der Wert auf
false gesetzt wird, muss der Servlet-Container alle Anfragen seriell
abarbeiten.
|
info
|
|
Beschreibung der Seite. Kann mit der API-Funktion getServletInfo()
ermittelt werden.
|
isErrorPage
|
false
|
Definiert, ob die aktuelle Seite eine Fehlerseite ist.
|
errorPage
|
|
Mit errorPage kann eine URL definiert werden, welche im Fehlerfall
aufgerufen wird. Die URL muss zur Applikation gehören und wird relativ
angegeben.
|
contentType
|
text/html
|
Definiert den MIME-Typ der Seite.
|
pageEncoding
|
ISO-8859-1
|
Definiert den Zeichensatz.
|
isElIgnored
|
false
|
Definiert, ob die Ausdrücke, welche mittels EL definiert sind,
ausgewertet werden sollen.
|
Die meisten
verwendeten Attribute sind sicherlich import und session.
Beispiel:
<%@ page import="java.util.*" session="false" %>
Wir importieren das
Package java.util und setzen das session-Attribut auf false.
2.2.1.2
Die „include“-Direktive
Mit dieser Direktive
wird es möglich, den kompletten Inhalt anderer Dateien in die aktuelle Seite
einzubinden. Nutzen kann man dies z.B. für stets wieder kehrende HTML-Teile wie
Footer und Header. Die Einbindung der Datei geschieht, bevor die JSP-Seite in ein
Servlet transformiert wird. Die eingebundene Datei Kann selbst wieder
JSP-Elemente beinhalten.
<%@ include file="datei.jsp" %>.
2.2.1.3
Die „taglib“-Direktive
Mit der Direktive
taglib können so genannte tag-libraries eingebunden werden. Z. B. wird die JSP
Standard Tag Library mit dieser Direktive eingebunden. URI der Taglibrary kann
relativ oder absolut angegeben werden.
<%@ taglib uri="/TagLibURI"
prefix="tagPrefix" %>
Beispiel
für eine absolute Angebe des URIs:
<%@ taglib uri="
prefix="c" %>
Beispiel
für eine relative Angabe eines URIs:
<%@ taglib uri="/WEB-INF/c.tld"
prefix="c" %>
2.2.2
Skriptingelemente
Scripting-Elemente
werden verwendet um Objekte zu manipulieren und Berechnungen durchzuführen und
sind "normale" Java-Fragmente. Damit eine JSP-Seite übersichtlich und
wartbar bleibt, sollte auf Java-Code innerhalb einer JSP-Seite völlig
verzichtet werden.
Zu den Skriptingelementen gehören:
·
Deklarationen
·
Scriptlets
·
Ausdrücke
·
Kommentare
2.2.2.1
Deklarationen
JSP erlaubt Variabeln
und Funktionen zu deklarieren. Variabeln werden direkt innerhalb der Klasse
erstellt und werden somit zu Klassenvariabeln. Das heisst, dass die
deklarierten Variabeln nicht exklusive pro Anfrage und Benutzer
verwendetet werden sondern einen globalen Gültigkeitsbereich - innerhalb des
Servlets - haben. Diese Variabeln werden auch als "page-level"
Variabeln bezeichnet. Bei diesen Variabeln muss immer darauf geachtet werden,
dass der Zugriff "Thread-Safe" erfolgt, denn mehrere Threads, können
gleichzeitig das gleiche Servlet - unsere JSP-Seite - ausführen.
Eine Deklaration
erfolgt zwischen den Begrenzungszeichen <%! und
%>.
Beispiel:
<%!
java.util.Date date = java.util.Calendar.getInstance().getTime();
java.util.Date getCurrentDate() {
return date;
}
%>
2.2.2.2
Scriptlets
Scriptlets sind
kleine Kodestücke welche zwischen den Begrenzungszeichen <% und %> stehen. Die Kodestücke können z.B.
für das Prüfen von Bedingungen und Schleifen verwendete werden.
Beispiel:
<body>
<% for( int i = 0; i < 10; i++ ) {%>
<% if( i == 0 ) {%>
Hallo<br><br>
<%}%>
Das ist eine JSP-Seite. <br>
<%}%>
</body>
2.2.2.3
Ausdrücke / Expressions
Ausdrücke sind
Scriptlets sehr ähnlich und sind bestimmt für das Auswerten von regulären
Java-Ausdrücken. Der Syntax ist wie folgt: <%=
ausdruck %>.
Beispiel:
<body>
<% for( int i = 0; i < 10; i++ ) {%>
Zeile <%= i+1%><br>
<%}%>
</body>
2.2.2.4
Kommentare
In den JSP-Seiten können
beliebig mit Kommentar versehen werden. Diese Kommentare werden im Gegensatz zu
HTML-Kommentare nicht in die zu generierende Seite übernommen.
Beispiel:
<%-- Dies ist ein JSP-Kommentar --%>
2.2.3
Action-Elemente
Die folgenden
Aktionen sind verfügbar:
2.2.3.1
jsp:include
Die angegebene JSP wird vom Java-Servlet aufgerufen, dabei werden
der Request und der Response übergeben. Ist die angegebene JSP abgearbeitet,
kommt die Steuerung zur gegenwärtigen JSP zurück. Diese JSP-Aktion bewirkt,
dass der eingebettete JSP-Code von allen einbettenden JSPs gemeinsam genutzt
und nicht kopiert wird.
Beispiel:
<jsp:include page="mycommon.jsp">
<jsp:param name="extraparam" value="myvalue"/>
</jsp:include>
2.2.3.2
jsp:param
Definiert einen Parameter, der zu den Request-Parametern hinzugefügt
wird. Diese Aktion kann innerhalb eines jsp:include- oder jsp:forward-Blocks
verwendet werden. Falls der Parameter schon im Request vorhanden war, wird der
Parameter überschrieben, also der Wert aus dem „Query String“ mit dem
definierten value-Attribut ersetzt.
Beispiel:
<jsp:params>
<jsp:param name="enableDebug" value="true"/>
</jsp:params>
2.2.3.3
jsp:forward
der Request und der Response werden an eine andere JSP oder ein
Servlet übergeben. Die Steuerung kommt nicht zur gegenwärtigen JSP zurück.
Beispiel:
<jsp:forward
page="subpage.jsp">
<jsp:param
name="forwardedFrom" value="this.jsp"/>
</jsp:forward>
2.2.3.4
jsp:plugin
Diese Aktion generiert je nach verwendetem Browser ein Tag zum
Einbinden eines Java-Applets. Dies wird benötigt, da in den älteren Versionen
der Browser von Netscape (Navigator) und Microsoft (Internet Explorer)
verschiedene Tags zum Einbinden eines Applets verwendet werden.
Beispiel:
<jsp:plugin type="applet" height="100%" width="100%"
archive="myjarfile.jar,myotherjar.jar"
codebase="/applets"
code="com.example.foo.MyApplet.class">
</jsp:plugin>
2.2.3.5
jsp:fallback
Definiert den Inhalt, der angezeigt wird, falls der Browser keine
Applets unterstützt.
Beispiel:
<jsp:fallback>
Your browser does not support applets.
</jsp:fallback>
2.2.3.6
jsp:setProperty
Diese Aktion setzt ein Property in der definierten Java-Bean.
Beispiel:
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />
2.2.3.7
jsp:getProperty
Diese Aktion holt sich ein Property von der definierten Java-Bean.
Beispiel:
<jsp:getProperty name="myBean" property="lastChanged" />
2.2.3.8
jsp:useBean
Diese Aktion erstellt oder verwendet eine Java-Bean wieder. Ist eine
Bean vom definierten Typ nicht vorhanden, wird sie also initial neu erstellt.
Das optionale Attribut scope gibt an, wie lange die Bean zur Verfügung
steht, d. h. in welchem Gültigkeitsbereich die Bean hinterlegt wird.
Folgende Werte können definiert werden:
request
Attribute sind nur solange verfügbar, wie der Request existiert.
page
Attribute sind nur für die gegenwärtige JSP verfügbar. (Standard)
session
Attribute sind nur solange verfügbar, wie die Benutzer-Session
existiert.
application
Attribute sind immer verfügbar.
„Verfügbar“ heißt hier, wie lange bzw. von wo der Entwickler auf die
Bean zugreifen kann. Ist die Bean beispielsweise im Request-Scope, so kann der
Entwickler mit dieser Bean sowohl innerhalb der aktuellen JSP als auch in
nachgelagerten (inkludierten) arbeiten. „Page-Scope“ beschränkt den
möglichen Zugriff auf die aktuelle JSP-Seite. „Session“ beschreibt alle
Requests einer Benutzersitzung zu dieser Web-Anwendung. „Application“ sind alle
Requests aller Benutzer der gleichen Web-Anwendung dieses Web-Servers.
Beispiel:
<jsp:useBean id="myBean" class="com.example.foo.MyBean" scope="request">
</jsp:useBean>
2.3
Beispiel
<%--
use the 'taglib' directive to make the JSTL 1.0 core tags available; use
the uri
"
for JSTL 1.1 --%>
<%@ taglib
uri=" prefix="c" %>
<%--
use the 'jsp:useBean' standard action to create the Date object; the object is
set
as an
attribute in page scope
--%>
<jsp:useBean id="date"
class="java.util.Date" />
<html>
<head><title>First JSP</title></head>
<body>
<h2>Here is today's date</h2>
<c:out value="${date}" />
</body>
</html>
3
Servlets
3.1
Syntax
package web;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class Logout extends HttpServlet {
public void doGet(HttpServletRequest
request, HttpServletResponse response)
throws IOException, ServletException
{
…
RequestDispatcher
view = request.getRequestDispatcher("index.jsp");
view.forward(request,
response);
}
}
- Imports
- ServletKlasse die von HttpServlet erbt
- Void Methoden doGet/doPost/service mit
Parameter und Exceptions
- HttpServletRequest, HttpServletResponse
- IOException, ServletException
- Parameter zum Request-Objekt hinzufügen
und an JSP-File weiterleiten
Oder
- Direkt mit Response Objekt antworten
3.2
Aufbau
Das Servlet übernimmt die Steuerung bei
einer Webanfrage. Es nimmt die Anfrage entgegen, ruft die entsprechende Klasse
mit der Geschäftslogik auf und leitet dann das Ergebnis dieser weiter.
Ein Servlet ist mit Java aufgebaut. Man
kann HTML-Code ausgeben, es ist aber schöner, die Ausgabe über JSP-Seiten zu
steuern.
3 wichtige Zeitpunkte
init() : Die
init()-Methode wird vom Container aufgerufen, nachdem die Servlet-Instanz
erzeugt wurde, aber bevor das Servlet auf Anfragen vom Client eingehen kann.
Man kann das Servlet initialisieren bevor darauf zugegriffen wird.
service() :
Wenn die erste Anfrage von einem Client hereinkommt legt der Container einen
neuen Thread an und veranlasst, dass die service()-Methode aufgerufen wird.
Diese Methode sieht sich die Anfrage des Clients an und ermittelt ob es die GET
oder POST Methode ist. Entsprechend ruft es doPost() oder doGet() auf.
doPost/doGet() : Werden je nach HTTP-Methode aufgerufen. Diese Methode ist die,
die für alles verantwortlich ist, was die Anwendung machen soll.
3.3
Beispiel
package web;
//Projektbezogene
Imports
import javax.servlet.*;
import java.io.IOException;
public class MDetail extends HttpServlet {
public void doGet(HttpServletRequest
request, HttpServletResponse response)
throws IOException, ServletException
{
int id = Integer.parseInt(request.getParameter("id"));
Medium
m = CrudMedium.retrieveById(id);
Ausleihe a = CrudAusleihe.retrieveByMedium(m);
if (a == null) {
request.setAttribute("ausgeliehen", false);
} else {
request.setAttribute("ausgeliehen", true);
}
request.setAttribute("medium", m);
RequestDispatcher
view =
request.getRequestDispatcher("mdetail.jsp");
view.forward(request, response);
}
}
3.4
Konfiguration von web.xml
<?xml version="1.0" encoding="UTF-8" ?>
<web-app
xmlns="
xmlns:xsi="
xsi:schemaLocation="
version="2.5">
<servlet>
<servlet-name>Login</servlet-name>
<servlet-class>web.Login</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Login</servlet-name>
<url-pattern>/login.do</url-pattern>
</servlet-mapping>
</web app>
<url-pattern>/login.do</url-pattern>
Login.do ist die Url,
die der Client zum Servlet sieht, er weiss nicht, in welcher Beziehung dieser
Name zu tatsächlichen Verzeichnissen und Dateinamen auf dem Server steht.
<servlet-name>Login</servlet-name>
Login ist der interne
Name, muss weder der öffentlichen URL, noch dem tatsächlichen Datei- und
Pfadnamen der Servlet Klasse entsprechen.
<servlet-class>web.Login</servlet-class>
Die Servlet-Klasse hat einen vollständig
qualifizierten Namen, der sowohl den Klassennamen als auch den des Packages
enthält.
4
Beans
Beans sind wiederverwendbare
Softwarekomponenten, welche dazu dienen, Daten während einer Session im
Hintergrund zu speichern und zu bearbeiten. Grundsätzlich werden Beans zur
Datenverwaltung benötigt welche auch Verbindungen mit einer Datenbank
beinhalten. Dabei wird hauptsächlich mit den Befehlen getVariable bzw.
setVariable verwendet. Die Beans können jedoch auch in einer Datenbank
abgespeichert werden. Beans werden auch als
Container zur Datenübertragung verwendet
Eigenschaften
·
Kompakt, leicht zu erstellen und zu benutzen
·
Total portabel
·
Robuster, verteilter Rechenmechanismus
·
Unterstützung für flexible Entwicklungszeit
·
Öffentlicher Standardkonstruktor (Default constructor)
·
Serialisierbarkeit (Serializable)
·
Öffentliche Zugriffsmethoden (Public Getters/Setters)
Regeln
·
Klassenname: beliebig
·
Superklasse: beliebig
·
Konstruktor: Mindestens einer ohne Argumente
oder eine strukturierte Grundform.
·
Packaging: JAR-Datei-Manifesteintrag enthält
Java-Bean: True
·
Eigenschaften: Alle Eigenschaften müssen durch getEigenschaft
und setEigenschaft lesbar bzw. setzbar sein.
Instanziierung
Eine Bean besitzt immer
einen Konstruktor ohne Argumente (Standardkonstruktor). Dies
ermöglicht eine standardisierte Instanziierung, beispielsweise einer Schaltfläche:
JButton button = (JButton) Class.forName("javax.swing.JButton").newInstance();
Eine Alternative dieser
Instanziierung funktioniert wie folgt:
JButton button = new JButton();
4.1
Aufbau
Der Name Get oder Set Methode muss
folgendermassen gestaltet sein:
Get:
public Rückgabetyp getAttributname()
Set:
public void setAttributname(ParametertypParametername)
Beispiel:
Attribut: String foo
public String getFoo()
public void setFoo(String foo)
Wichtig: Der
Attributname muss gross geschrieben werden.
4.2
Beispiel
4.2.1
In JSP
<jsp:useBean
id="beanInstanceName" //
Name der Bean
scope="page|request|session|application" // Lebensdauer
{class="package.class" // Klasse (inkl. Paketpfad)
type="package.class" // Typ des Objektes z.B. List
class="package.class" type="package.class"
// Klasse und Typ können kombiniert werden
}
>
<!--
Other Elements -->
</jsp:useBean>
4.2.2
Als Klasse
package ch.zkb.test.beans;
public class Person {
private String vorname;
private String nachname;
private int alter;
public String getVorname() {
return vorname;
}
public void setVorname(String
vorname) {
this.vorname = vorname;
}
public String getNachname()
{
return nachname;
}
public void setNachname(String
nachname) {
this.nachname = nachname;
}
public int getAlter() {
return alter;
}
public void setAlter(int alter) {
this.alter = alter;
}
}
5
JDBC
5.1
Allgemeines
JDBC ist eine Datenbankschnittstelle der
Java-Plattform, die eine einheitliche Schnittstelle zu Datenbanken
verschiedener Hersteller bietet und speziell auf relationale Datenbanken
ausgerichtet ist.
JDBC ist in seiner Funktion als universelle
Datenbankschnittstelle vergleichbar mit z.B. ODBC unter Windows.
Zu den Aufgaben von JDBC gehört es,
Datenbankverbindungen aufzubauen und zu verwalten, SQL-Anfragen an die
Datenbank weiterzuleiten, die Ergebnisse in eine für Java nutzbare Form
umzuwandeln und dem Programm zur Verfügung zu stellen.
5.2
Anwendung
//1. Treiber laden
Class.forName("Driver");
//2. Verbindung zur
Datenbank herstellen
Connection conn = DriverManager.getConnection("db", "user", "pw");
//3. Statement erstellen
Statement statement = conn.createStatement();
//4. Statement ausführen, Ergebnis in ResultSet speichern
-->
ResultSet rset = statement.executeQuery("Statement");
//5. ResultSet auslesen -->
while(rset.next()){ /* irgendetwas machen
*/ }
//6. Alles wieder
schliessen -->
rset.close();
statement.close(); conn.close();
5.3
Hilfreiche Websiten
Tutorial von Sun:
JDBC Treiber
6
Aufgabe BMI
package pkg1;
import java.io.IOException;
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
int zaehler = 1;
public TestServlet() {
super();
}
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
// Deklarationen
String
groesse = "";
String
gewicht = "";
String
alter = "";
String
antwort = "";
String
zuhoch = "";
String zutief = "";
String
io = "";
double bmi;
double dblgroesse = 0;
double dblgewicht = 0;
double dblalter = 0;
// Initialisierungen
groesse
= request.getParameter("groesse");
gewicht
= request.getParameter("gewicht");
alter
= request.getParameter("alter");
zuhoch="Das ist zu
hoch!";
zutief="Das ist zu
tief!";
io="Das ist in
Ordnung";
// Werte
in Doubles umwandeln
if (groesse != ""){
dblgroesse
= Double.parseDouble(groesse);
}
if (gewicht != ""){
dblgewicht
= Double.parseDouble(gewicht);
}
if (alter != ""){
dblalter
= Double.parseDouble(alter);
}
// Wenn
in cm angegeben in m umwandeln
if(dblgroesse >100){
dblgroesse
= dblgroesse/100;
}
// BMI
berechnen
bmi=dblgewicht/(dblgroesse*dblgroesse);
bmi=
Math.round(bmi*100)/100.0;
// Abfragen
ob man je nach Alter den richtigen BMI hat
if (dblalter < 19){
antwort="Sie sind nicht alt
genug um diesen Rechner zu nutzen!!!";
}
else if (dblalter < 25){
if(bmi <
19){antwort=zutief;}
if(bmi > 24){antwort=zuhoch;}
else{antwort=io;}
}
else if (dblalter < 35){
if(bmi <
20){antwort=zutief;}
if(bmi >
25){antwort=zuhoch;}
else{antwort=io;}
}
else if (dblalter < 45){
if(bmi <
21){antwort=zutief;}
if(bmi >
26){antwort=zuhoch;}
else{antwort=io;}
}
else if (dblalter < 55){
if(bmi <
22){antwort=zutief;}
if(bmi >
27){antwort=zuhoch;}
else{antwort=io;}
}
else if (dblalter < 65){
if(bmi <
23){antwort=zutief;}
if(bmi >
28){antwort=zuhoch;}
else{antwort=io;}
}
else {
if(bmi <
24){antwort=zutief;}
if(bmi >
29){antwort=zuhoch;}
else{antwort=io;}
}
// Ausgaben
if (dblalter > 18){
response.getOutputStream().println("Ihr BMI ist: " + bmi +"<br>");
}
response.getOutputStream().println(antwort);
}
protected void doPost(HttpServletRequest
request, HttpServletResponse response) throws ServletException, IOException {
}
}
7
Aufgabe Session
7.1
Wichtige Codestellen zum Session-Handling:
Neue Session im Servlet erstellen:
HttpSession
session = request.getSession(true);
Session-Attribut setzen:
session.setAttribute("eingeloggt", eingeloggt);
Im JSP prüfeon ob User eigelogt ist:
<%if(session.getAttribute("eingeloggt")=="ja"){%>
Logout:
HttpSession
session = request.getSession(false);
session.invalidate();
response.sendRedirect(" );