08 Server

Webbasierte Anwendungen
Serverseitige Techniken
Univ.-Prof. Dr.-Ing. habil. Gero Mühl
Architektur von Anwendungssystemen (AVA)

Fakultät für Informatik und Elektrotechnik (IEF)
Universität Rostock
Überblick
> Request/Response
> Common Gateway Interface (CGI)
> Java Servlets
> Sessions
> Seitenbeschreibung
> Server Side Includes (SSI)
> Hypertext Preprocessor (PHP)
> Java Server Pages (JSP)
G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 2

Common Gateway Interface (CGI)

> CGI definiert eine Schnittstelle für Aufruf von Programmen

durch den Webserver und Übergabe von Clientparametern
> Aufruf durch Starten eines Prozesses mit den Clientparametern
> Standardausgabe des Prozesses ist Response
> Meist wird eine dynamisch generierte Webseite zurückgegeben
Webbrowser Anbieter
Praktikum in Grönland !
anmelden
Formular anfordern
Formular liefern
 HTTP HTTP
Client Daten senden Server
Antwort empfangen
/cgi-bin/anmelden.sh

> Per Konvention liegen CGI-Skripte meist
im Verzeichnis /cgi-bin des Web Servers
> Diverse Programmiersprache nutzbar

> Häufig Skriptsprachen: Shells, Perl, Python, ...
> Aber auch: C, C++, etc.
> Skript antwortet mit neuer Seite (zumindest HTTP-Header)

#!/bin/bash
echo "Content-type: text/html" ; echo
> Einfaches Beispiel in Perl

#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "Hello, World.";

Aufruf eines CGI-Skriptes
> Formular
<form action="/cgi-bin/guestbk.pl" method="get">
<form action="/cgi-bin/stats.pl" method="post">
> Verweis
<a href="/cgi-bin/stats.pl">Tagesstatistik</a>
> Grafikreferenz
<img src="/cgi-bin/counter.pl">
> Server Side Include (SSI)

> Automatisches Laden durch Weiterleitung
<meta http-equiv="refresh"
content="0;URL=/cgi-bin/welcome.pl">

CGI Parameterübergabe
> GET
> $QUERY_STRING (Umgebungsvariable) wird übergeben
> Beispiele
?vorname=Hans&nachname=M%FCller&...
?query=CGI+Tutorial
> Beinhaltet alle Parameter in einem String
(Leerzeichen durch + ersetzt)
> Wird vom Skript geparst und entsprechend verarbeitet
> POST
> Einlesen der Parameter (aus dem Body der Response) von der
Standardeingabe

CGI Beispiele
#!/bin/sh
cat - <<EOF
Content-type: text/html
<HTML><HEAD><TITLE>Datum und
Zeit</TITLE></HEAD>
<BODY><H1>Zeit und Datum:
EOF
date
cat - <<EOF
</H1></BODY></HTML>
EOF

CGI Beispiele
> Zugriff auf Umgebungsvariablen
#!/usr/bin/perl
print "Content-type: text/html\n\n";
foreach $key (keys %ENV) {
print "$key --> $ENV{$key}<br>";
}
> Query-String an Java übergeben, um GET-Request zu

verarbeiten
#!/bin/bash
echo $QUERY_STRING | java CGI
> Query-String mit Java auslesen, um GET-Request

zu verarbeiten
String queryString =
System.getEnv("QUERY_STRING");
CGI Sicherheit
> CGI-Programme sind „von jedem“ aufrufbar
> Ausführung eines Programms ohne Benutzerkonto

> Berechtigung des CGI-Programms entspricht der
des WWW-Servers
> Daher: Server nicht als root starten, sondern als wwwuser
> Alternativ kann CGI-Programm mit UID ihres Besitzers laufen
> Problem der Ausführung dynamisch erzeugter

(System)-Kommandos  Command Injection

CGI Diskussion
> Vorteile
> Geringe Anforderungen
> Verfügbarkeit auf Server
> Hohe Flexibilität
> Nachteile
> Niedrige Abstraktionsebene
> Sicherheit dem Anwendungsentwickler überlassen
> Hoher Ressourcenverbrauch (Prozess pro Request)
> Keine Ressourcenüberwachung

Literatur
> Spezifikation
> IETF RFC 3875.  http://tools.ietf.org/html/rfc3875
> W3C‘s CGI Seiten.  http://www.w3.org/CGI/
> Tutorials
> Apache Tutorial. Dynamic Content with CGI.
 http://httpd.apache.org/docs/current/howto/cgi.html
> Stefan Münz. SELFHTML: CGI.
 http://de.selfhtml.org/servercgi/cgi/index.htm
> FastCGI
> Webseite.  http://www.fastcgi.com
> White Paper.  http://www.fastcgi.com/drupal/node/6?q=node/15

Fragen?

Java Servlets

Java Servlets Aktuelle
Version
> Serverseitige Java-Programmschnipsel 4.0
> „CGI auf Java-Art“

> Servlet = Zusammenziehung von Server und Applet
> „Servlets sind für den Webserver das,
was Applets für den Webbrowser sind“
> Plattformunabhängige Alternative zu CGI

> Einfacher zu schreiben
> Schneller und sicherer in der Ausführung
> Java-API steht zur Verfügung (außer GUI)

Servlet Container
> Fungiert als Laufzeitumgebung für die Servlets
> Stellt Dienste bereit

> Lifecycle Management
> Session Management
> Authentifizierung und Autorisierung
> Transaktionen und Persistenz
> Verwaltung von Ressourcen (z.B. Pooling)
> …

Architektur
> Servlets werden über

Web-
Webserver mittels URL Browser
angesprochen
1. HTTP-Request 2. HTTP-Response
> Webserver übergibt
Apache
HTTP-Request mit Web-
„passender“ URL an Server
Connector
Servlet-Container, der
Apache JServ
das anzusprechende Protocol (AJP)
Servlet instanziiert Tomcat
Servlet-
> Servlet wird mit Servlet Container
HTTP-Request aufgerufen
und liefert HTTP-Response
Schnittstellen und Klassen Interface
Class
______javax.servlet.Servlet______ ____javax.servlet.ServletRequest____
void init(ServletConfig config)
void service(ServletRequest req,
ServletResponse res)
void destroy() _javax.servlet.http.HttpServletRequest_
___javax.servlet.GenericServlet___
___javax.servlet.ServletResponse___
__javax.servlet.http.HTTPServlet__
doGet(HttpServletRequest req,
HttpServletResponse res)
doPost(HttpServletRequest req, _javax.servlet.http.HttpServletResponse_
______MySimpleServlet________
Vom Servlet-Entwickler
zu implementieren

Schnittstelle Servlet / Klasse GenericServlet
> Interface Servlet init
> Von jeder Servlet-Klasse zu implementieren
> Klassenlader des Containers lädt Servlet-Klasse
> Container delegiert Client-Anfrage an Servlet
service
> Abarbeitung in eigenem Thread
> Wichtige Methoden der Schnittstelle destroy

> void init(ServletConfig config)
> Einmaliger Aufruf durch Container zur Initialisierung
> void service(ServletRequest req, ServletResponse res)
> Verarbeiten einer Anfrage und Erzeugen der zugehörigen Antwort
> void destroy()
> Aufruf durch Container am Lebensende zur Freigabe von Ressourcen
> Klasse GenericServlet unabhängig vom verwendeten Protokoll

> Eigenes Servlet von GenericServlet ableiten
> service-Methode überschreiben

Klasse HTTPServlet
> Klasse javax.servlet.http.HttpServlet

> Verarbeitung von HTTP-Anfragen durch doMethod()-
Methoden, die den Methoden des HTTP-Protokolls entsprechen
> doGet(), doPost(), doHead(), doPut(), doDelete(),
doOptions() und doTrace()
> doMethod(HttpServletRequest req,

> Parameter sind HTTP-spezifische Request-/Response-Objekte
> Vorgehen
> Eigenes Servlet von HttpServlet ableiten
> Benötigte doMethod()-Methode(n) überschreiben

Klasse HttpServletRequest
> Repräsentiert HTTP-Request des Clients
> Methoden
> String getHeader(String field)
> Abfragen von HTTP-Header-Feldern
> String getQueryString()
> Liefert Query String bei GET-Request
> String getParameter(String name)
> Parameter aus GET- oder POST-Request holen
> BufferedReader getReader()
ServletInputStream getInputStream()
> Zum Lesen von Zeichen bzw. Binärdaten aus dem Body
> Cookie[] getCookies()
> Liefert alle Cookies des Requests
> …

Klasse HttpServletResponse
> Repräsentiert HTTP-Response für den Client
> Methoden
> void setHeader(String field, String value)
> Setzen beliebiger HTTP-Header-Felder
> Für die wichtigsten Header-Felder existieren eigene
Methoden
> void setContentType(String type)
> Setzt Typ des Bodys der Response (z.B. auf text/html)
> void sendError(int sc, String msg)
> Fehlermeldung senden (z.B. 404, „Seite nicht gefunden“)
> PrintWriter getWriter()
ServletOutputStream getOutputStream()
> Zum Schreiben von Zeichen bzw. Binärdaten in den Body
> …

Servlet Beispiel
Annotation kennzeichnet Klasse
als Servlet und gibt URL an HttpServlet erweitern und benö-
tigte Methoden überschreiben
@WebServlet("/hello")
public class MySimpleServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest req,
throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<html><head>“);
out.println("<title>Response</title></head>");
out.println("<body><h1>HelloWorld</h1>");
out.println("</body></html>");
out.close();
} HTML-Ausgabe erzeugen
}

Servlet Beispiel 2
<FORM METHOD="POST" ACTION="/servlet/FormServlet">
<INPUT NAME="firstname" TYPE="text" SIZE="30">
<INPUT NAME="lastname" TYPE="text" SIZE="30">
<INPUT NAME="age" TYPE="text" SIZE="3">
<INPUT TYPE="SUBMIT">
</FORM>
HTML-Formular
public void doPost(HttpServletRequest request,

HttpServletResponse response)
throws ServletException, IOException
{
firstname = request.getParameter("firstname");
lastname = request.getParameter("lastname");
ageString = request.getParameter("age");
…
Servlet
} Formularparameter
aus Request extrahieren
Deployment einer Web-Anwendung
> Eine Web-Applikation besteht typischerweise aus einem
einzelnem Web Archive (.WAR Datei)
> ist im Prinzip eine JAR-Datei
> bildet einen Applikationskontext
> Struktur des Archivs

index.html Metainformationen über
META-INF/ den Inhalt des Archivs
MANIFEST.MF
WEB-INF/ Optionaler
Deployment Descriptor
web.xml
lib/
Bibliotheken
classes/
ava/ Klassen
MySimpleServlet.class

Servlets und Threads
> Zusammenspiel von Container und Servlets
> Container bearbeitet jede Client-Anfrage in der Regel
in einem eigenen Thread
> Er hält meist jedoch nur eine Servlet-Instanz pro Servlet-Klasse
vor, die sich die Threads teilen müssen
> Ohne weitere Vorkehrungen sind Probleme bei gleichzeitigem
Zugriff mehrerer Threads auf ein Servlet zu erwarten
> Lösungen für durch Multithreading verursachte Probleme

> Servlets zustandslos implementieren
> Methoden synchronisieren  Schlüsselwort synchronized
> Kritische Auswirkungen auf Leistung möglich

Asynchrone Request-Verarbeitung
> Bei synchroner Request-Verarbeitung muss der Request
abgeschlossen sein, wenn doMethod() returniert
> Langlaufende Aktionen blockieren ausführenden Thread
> Threads werden knapp
> Degradierung der Leistung
> Asynchrone Request-Verarbeitung

> Ermöglicht aus doMethod() zurückzuspringen,
ohne den Request abzuschließen
> Spätere Wiederaufnahme der Ausführung des Requests,
um diesen zum Abschluss zu bringen (evtl. mehrfach)
> Weitere Anwendungsmöglichkeit: Server-Side Push

> Auch bekannt als Reverse Ajax, Comet, …

Asynchrone Request-Verarbeitung
> Servlet für asynchrone Requests konfigurieren

> @WebServlet("/chat", asyncSupported=true)
> Request in asynchronen Modus versetzen

> AsyncContext ac = req.startAsync();
> Request oder Response aus asynchronem Kontext holen

> ac.getRequest();
> ac.getResponse();
> Request abschließen und Response schließen

> ac.complete();

Servlet Chat Beispiel
Speichert alle
Client-Requests
@WebServlet("/chat", asyncSupported=true)
public class MyServlet extends HttpServlet {
private static final Queue<AsyncContext> acQueue = Speichert die
new ConcurrentLinkedQueue<AsyncContext>(); Chat-Nachrichten
private static final BlockingQueue<String> messageQueue =

new LinkedBlockingQueue<String>();
@Override
public void init(ServletConfig config) throws
ServletException {
Runnable notifierRunnable = new Runnable() {
public void run() { Chat-Nachricht aus Queue
while (true) { entnehmen und an alle
message = messageQueue.take(); Requests weitergeben
for (AsyncContext ac : acQueue) {
PrintWriter acWriter = ac.getResponse().getWriter();
acWriter.println(message); acWriter.flush();
}}}
new Thread(notifierRunnable).start(); Thread starten, der
} Chat-Nachrichten an
Clients weitergibt

Servlet Chat Beispiel
@Override
public void doGet (HttpServletRequest req,
req.setAsyncTimeout(10 * 60 * 1000); // in ms
AsyncContext ac = req.startAsync();
acQueue.add(ac);
} Request in asynchronen Modus
schalten und in Queue speichern
@Override
public void doPost (HttpServletRequest req,
String message = req.getParameter("message“);
messageQueue.put(message);
} Neue Chat-Nachricht entgegen
} nehmen und in Queue speichern
Servlet Cookie API
> Klasse javax.servlet.http.Cookie

repräsentiert einen Cookie
> Konstruktor
> public Cookie(String name, String value)
> Setzen im Response Header (HTTPServletResponse)

> response.addCookie(userCookie);
> Lesen aus Request Header (HTTPServletRequest)

> Cookie[] cookies = request.getCookies();

Getter/Setter-Methoden von
javax.servlet.http.Cookie
> boolean isHttpOnly()

void setHttpOnly(boolean only)
> Cookie nicht an clientseitige Scripts übergeben (Setzen und Testen)
> boolean getSecure()

void setSecure(boolean flag)
> Cookie darf nur per HTTPS übertragen werden (Setzen und Testen)
> String getName()

void setName(String name)
> String getValue()

void setValue(String value)
> String getDomain()

void setDomain(String domain)

Literatur
> Spezifikation und Implementierung

> JSR 340. Java Servlet 3.1 Specification.
 http://jcp.org/en/jsr/detail?id=340
> Apache Tomcat.  http://tomcat.apache.org/
> Tutorials
> The Java EE 7 Tutorial. Chapter 17: Java Servlet Technology.
 http://docs.oracle.com/javaee/7/tutorial/doc/servlets.htm#BNAFD
> Tutorialspoint. Servlets Tutorial.
 http://www.tutorialspoint.com/servlets
> Bücher
> Tim Downey. Web Development with Java: Using Hibernate, JSPs
and Servlets. Springer, 2007.
> Bruce W. Perry. Java Servlet and JSP Cookbook.
O’Reilly Media, 2004.
Fragen?

Session Management

Java Servlets und Sessions
> Servlet Container bietet Session Management als Service an
> Verwendet Cookies wenn möglich, sonst Link Rewriting
> Sessions sind im gesamten ServletContext sichtbar
> Klasse javax.servlet.http.HttpSession

> Abstrahiert von Cookies und URL Rewriting
> Dient als Container für beliebige serialisierbare Objekte, die auf
dem Server liegen  Client bekommt nur eine ID
> HttpServletRequest.getSession()
> Erzeugt neue Session, falls noch keine vorhanden
> Wiederholte Aufrufe liefern existierende Session
> Anwendungsdaten werden als Attribute

an Sessions gebunden
> session.setAttribute(name, value)
> value = session.getAttribute(name)

Java Servlets und Sessions
> Sessions „fressen“ Betriebsmittel (z.B. Speicher)
> Explizite Invalidierung der Session

> session.invalidate()
> Globaler Timeout in web.xml einstellbar
> Einstellbarer Per-Session-Timeout

> session.setMaxInactiveTimeout()

Ereignisse
> Ereignisbehandlung folgt dem Listener-Modell
 Tritt ein Ereignis auf, so wird der zugehörige Listener aufgerufen
> Definition der Listener mittels Annotationen, im Deployment
Descriptor oder durch explizite Registrierung einer der
addListener-Methoden im ServletContext
Listener-Definition
@WebListener durch Annotation
public class SessionCounter
implements HTTPSessionListener {
privat AtomicInteger sessions = new AtomicInteger(0);
@Override
void sessionCreated(HttpSessionEvent se) {
sessions.getAndIncrement(); }
@Override
void sessionDestroyed(HttpSessionEvent se) {
sessions.getAndDecrement() ; }
int getActiveSessions() { return sessions.get(); }
}

Ereignisse: Klassen und Schnittstellen
_____java.util.EventListener_____
Implementiert von
Attribut-Objekten
_____HttpSessionListener_____ _HttpSessionActivationListener_
void sessionCreated( void sessionDidActivate(
HttpSessionEvent hse) HttpSessionEvent hse)
void sessionDestroyed( void sessionWillPassivate(
HttpSessionEvent hse) HttpSessionEvent hse)
____HttpSessionAttributeListener_____ _____HttpSessionBindingListener_____
void attributeAdded( void valueBound(
HttpSessionBindingEvent hsbe) HttpSessionBindingEvent hsbe)
void attributeRemoved( void valueUnbound(
HttpSessionBindingEvent hsbe) HttpSessionBindingEvent hsbe)
void attributeReplaced(
HttpSessionBindingEvent hsbe) Implementiert von
Attribut-Objekten
______HttpSessionEvent______ ____HttpSessionBindingEvent____
HttpSession getSession() HttpSession getSession()
String getName()
Object getValue()

Ereignisse: Sessions
> HttpSessionActivationListener-Interface
void sessionDidActivate(HttpSessionEvent hse)
void sessionWillPassivate(HttpSessionEvent hse)
> Implementiert von Attribut-Objekten, die benachrichtigt werden wollen,
wenn zugeordnete Session aktiviert oder passiviert wird
> HttpSessionListener-Interface
void sessionCreated(HttpSessionEvent hse)
void sessionDestroyed(HttpSessionEvent hse)
> Implementiert von Objekten, die benachrichtigt werden wollen, wenn
eine Session erzeugt oder zerstört wird
> HttpSessionEvent-Klasse
HttpSession getSession()

Ereignisse: Session-Attribute
> HttpSessionBindingListener-Interface
void valueBound(HttpSessionBindingEvent hsbe)
void valueUnbound(HttpSessionBindingEvent hsbe)
> Implementiert von Attribut-Objekten, die benachrichtigt werden wollen,
wenn sie gebunden oder entfernt werden
> HttpSessionAttributeListener-Interface
void attributeAdded(HttpSessionBindingEvent hsbe)
void attributeRemoved HttpSessionBindingEvent hsbe)
void attributeReplaced(HttpSessionBindingEvent hsbe)
> Implementiert von Objekten, die benachrichtigt werden wollen, wenn ein
Attribut einer beliebigen Session hinzugefügt, entfernt oder ersetzt wird
> HttpSessionBindingEvent-Klasse
HttpSession getSession()
String getName()
Object getValue()

Literatur
Siehe Literatur zu Java Servlets.

Fragen?

Server Side Includes (SSI)

> Anweisungen in HTML-Seite

> werden vom Webserver interpretiert und durch HTML ersetzt
> Einbettung der Anweisungen in HTML-Kommentare
> Syntax

> Datum/Zeit einblenden


> CGI-Skript ausführen


> Befehl ausführen


> Änderungsdatum einblenden

> Einbinden einer Datei auf dem gleichen Server


> If-then-else-Konstrukt

in foo

in bar

in neither


Literatur
> Tutorial
> Apache httpd Tutorial. Introduction to Server Side Includes.
 http://httpd.apache.org/docs/current/howto/ssi.html
> Stafan Münz. SELFHTML: Server Side Includes.
 http://de.selfhtml.org/servercgi/server/ssi.htm
> Referenzen
> W3C‘s Java Server JIGSAW. Server Side Include Reference.
 http://www.w3.org/Jigsaw/Doc/User/SSI.html

Fragen?

Hypertext Preprocessor (PHP)

PHP: Hypertext Preprocessor (PHP)
> Serverseitige Skriptsprache für Webanwendungen

> Open Source
> Plattformunabhängig
> Anleihen von und Ähnlichkeiten zu Perl, C, C++ und Java
> Dynamische, implizite und schwach typisierte Sprache
> Gute Datenbankunterstützung und viele Funktionsbibliotheken
> Häufiges Setup: Linux, Apache, MySQL und PHP  LAMP
> PHP-Interpreter
> Verarbeitet PHP-Datei, die PHP-Code und HTML-Code mixt
> Wechselt zwischen PHP-Code ausführen und HTML kopieren
> Zu Beginn ist der Interpreter im Modus HTML kopieren
> Die Ausgabe des Interpreters ist typischerweise eine HTML-Seite,
die an den Client übertragen wird
Geschichte
> 1995: Rasmus Lerdorf entwickelt Personal Home Page Tools
> CGI-Wrapper in Pearl, später in C geschrieben
> Datenbankanbindung für Formulare und Tabellen
> 1998: neuer Interpreter von Andi Gutmans und Zeev Suraski
> Gründung von Zend Technologies  Zend Engine
> 2000: PHP4 mit besserer Performance dank Interpiler
> 2004: PHP 5 mit überarbeitetem Objektmodell
> Private Methoden und Attribute, Überladung, Exceptions, Reflection
> Integration von SQLite; XML, DOM, JSON-Unterstützung
> 2007: Beginn der Arbeiten an PHP 6, jedoch 2010 zurückgestellt
> Features fließen in PHP 5 ein
> Namensräume, Closures, Traits, Generatoren, Koroutinen
> 2015: Verabschiedung von PHP 7  aktuell PHP 7.4
> Verbesserte Performance; Teilaufgabe der Abwärtskompatibilität

Einfaches Beispiel
<?php
header ("Content-type: text/html");
?>
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8" />
<title>Hello World</title>
</head>
<body>
<p>Hello
<?php
echo "World</p>";
?>
</body>
</html>

Beispiel mit if-Anweisung
<?php
if (strstr($_SERVER["HTTP_USER_AGENT"],
"MSIE")) {
?>
<h3>strstr muss true zurückgegeben haben</h3>
<b>Sie benutzen Internet Explorer</b>
<?php
} else {
?>
<h3>strstr muss false zurückgegeben haben </h3>
<b>Sie benutzen nicht Internet Explorer </b>
<?php
}
?>

CSS und PHP
...
<style type="text/css">  </style>
...
<table width="300">
<?php for($i=0;$i<=9;$i++){ ?>
<tr>
<td class="row_<?php echo $i % 2; ?>">
Reihe <?php echo $i; ?>
</td>
</tr>
<?php } ?>
</table>
...

Formulare und PHP
> Formular zur Datenerfassung

<form action="welcome.php" method="POST">
Enter your name: <input type="text" name="name">
Enter your age: <input type="text" name="age">
<input type="submit">
</form>
> Verarbeitung der Formulardaten

<html>
<body>
Welcome <?php echo $_POST["name"]; ?>.
You are <?php echo $_POST["age"]; ?> years old!
</body>
</html>

Cookies und PHP
> Cookie setzen

<?php setcookie( "user", "Alice", time()+3600 ); ?>
> Cookie abfragen

<?php
if (isset($_COOKIE["user"]))
echo "Welcome " . $_COOKIE["user"] . "!<br>";
else
echo "You are not logged in!<br>";
?>
> Cookie löschen

<?php setcookie( "user", "", time()-3600 ); ?>

Sessions und PHP
Muss vor dem
<html>-Tag stehen!
> Start einer Session
<?php session_start(); ?>
> Session Variable setzen
<?php $_SESSION['var'] = 4711; ?>
> Session Variable testen
<?php
if(isset($_SESSION['var']))
echo $_SESSION['var']
?>
> Session Variable löschen
<?php unset($_SESSION['var']); ?>
> Session beenden
<?php session_destroy(); ?>
Datenbankzugriff mit PHP Data Objects (PDO)
<?php
try {
$dbh = new PDO( 'mysql:host=localhost;dbname=northwind',
$user, $pwd );
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "<table>";
echo " <tr><th>Company</th><th>Contact</th></tr>";
foreach($dbh->query('SELECT * FROM customers') as $row) {
echo "<tr><th>" . $row['company'] . "</th>";
echo " <th>" . $row['contact'] . "</th></tr>";
}
echo "</table>";
$dbh = null;
} catch (PDOException $e) {
echo "Error: " . $e->getMessage() . "<br>"
}
?>
Literatur
> PHP Community und Dokumentation

> Webseite.  http://www.php.net
> PHP Handbuch.  http://www.php.net/manual
> Geschichte.  http://www.php.net/manual/phpfi2.php#history
> Tutorials
> W3Schools. PHP 5 Tutorial.  http://www.w3schools.com/php
> SELFPHP.  http://www.selfphp.de
> Tutorialspoint. PHP Tutorial.  http://www.tutorialspoint.com/php/
> Bücher
> Thomas Theis. Einstieg in PHP 5.5 und MySQL 5.6. Galileo
Computing, 2013.
> Robin Nixon. Learning PHP, MySQL, JavaScript, and CSS: A
Step-by-Step Guide to Creating Dynamic Websites. O’Reilly
Media, 2012.
Fragen?

Java Server Pages (JSP)

Java Server Pages (JSP) Aktuelle
Version
2.3
> Serverseitige Programmiersprache
> Zur dynamischen Erzeugung von HTML- und XML-Ausgaben
> Basiert auf Servlet Technologie
> JSPs werden zu Servlets kompiliert
> Ermöglicht „komfortablere“ Notation eines Servlets
> Gemischte Seitenbeschreibung
> Statischer Inhalte wie HTML  Statischer Template Code
> Dynamische Inhalte  JSP-Elemente
> JSP-Elemente
> Direktiven  Anweisungen für den JSP-Compiler
> Skriptelemente  Einbindung von Java-Code
> Aktionen  Einbindung von Server-Funktionen
> Tag-Bibliotheken (Tag Libraries)  Definition eigener Aktionen

JSP Beispiel (HTML + Java Code)
<html>
<head>
<title>JSP Beispiel</title>
</head>
<body>
Datum und Zeit:<%= new java.util.Date()
%><br/>
<% for (int i=0; i<5; i++) { %>
Das Quadrat von <%= i %> ist <%= i*i
%><br/>
<% } %> In dieser Syntax ist ein JSP kein valides
HTML-Dokument!
</body> X(HT)ML-konforme JSPs können in
</html> einer alternativen Syntax erstellt werden.

JSP Verarbeitung
Java
Server
Web-Server mit .jsp Page
JSP-Engine
generieren
Request
Response .java Servlet
Client kompilieren
Cache mit
kompiliertem Java
Servlet Byte
.class Code

JSP Direktiven
> <%@ directive {attribute="value"}* %>
> page-Direktive: <%@ page … %>

> Importieren von Bibliotheken
<%@ page import="java.util.*" %>
> Einstellungen für die Seite festlegen
<%@ page language="java" %> JSP Direktiven richten sich an
> HTTP-Session erzeugen ja/nein den JSP-Compiler. Sie werden
daher zum Zeitpunkt der
<%@ page session="true" %> Übersetzung ausgewertet.
> Von eigener Servlet-Basisklasse ableiten
<%@ page extends="myservlet" %>
> Fehlerseite festlegen
<%@ page errorPage="error.jsp" %>
> Ist Fehlerseite
<%@ page isErrorPage="true" %>

JSP Direktiven
> include-Direktive: <%@ include … %>

> Einbindung statischer Dokumente
<%@ include file="companyBanner.html" %>
> taglib-Direktive: <%@ taglib … %>

> Erweiterung der Menge der vorhandenen Actions
<%@ taglib uri="/mytaglib" prefix="mytags" %>
<mytags:cooltag>
...
</mytags:cooltag>

JSP Scripting
> Deklarationen: <%! declarations %>
> Definieren und überschreiben von Methoden,
z.B. jspInit() and jspDestroy()
<%! public void jspInit() { ... } %>
<%! public void jspDestroy() { ... } %>
> Scriptlets: <% java code fragment %>

> Wird in den Rumpf der service-Methode des generierten
Servlets eingefügt
<% java.util.Date date = new java.util.Date();
out.println(date); %>
> Ausdrücke: <%= expression %>

> Ausdruck auswerten und Ergebnis in String umwandeln,
der dann in die Seite eingefügt wird
<%= date %>

JSP Deklarationen Achtung: Mehrere Threads
können gleichzeitig auf
<HTML> einer JSP-Instanz arbeiten!
<HEAD>
<TITLE>Current Date</TITLE>
</HEAD>
<BODY> Member-Deklaration
<%!
double number = Math.random();
Date computeDate() {
return new Date();
} Methoden-Deklaration
%>
The time is now <%= computeDate() %>
Random number is <%= number %>
Was wird hier
</BODY> ausgegeben?
</HTML>

JSP Implizite Objekte
Name Typ
> request HttpServletRequest
> response HttpServletResponse
> session HttpSession
> out JspWriter
> application ServletContext
> config ServletConfig
> page äquivalent zu this
> exception java.lang.Throwable
> Innerhalb von Scriptlets und Ausdrücken kann

auf diese Objekte zugegriffen werden, z.B.
<% out.println(request.getRemoteHost()); %>

JSP Sessions Formular sendet Daten an JSP
<HTML><BODY>
<FORM METHOD="POST" ACTION="Save.jsp">
What's your name?
<INPUT TYPE="TEXT" NAME="username" SIZE="20">
<INPUT TYPE="TEXT" NAME="email" SIZE="20">
<INPUT TYPE="SUBMIT">
</FORM>
Form.html
</BODY></HTML>
<%
String name = request.getParameter("username");
session.setAttribute("username", name);
String email = request.getParameter("email");
session.setAttribute("email", email);
Save.jsp
%>
JSP Actions
> Starten zusätzliche Funktionalität zur Laufzeit
> Syntax
> mit Body <jsp:tag>body</jsp:tag>
> ohne Body <jsp:tag {attribute="name"}*/>
> Einfügen einer HTML- oder JSP-Seite

<jsp:include page="rurl" flush="true"/>
> Weiterleiten auf andere Seite

<jsp:forward page="errorPage.jsp"/>
<jsp:forward page="<%= ... %>"/>

JSP Actions und JavaBeans
> Aufruf einer JavaBean

> <jsp:useBean id="mybean" class="package.class"
scope="page|request|session|application"/>
> Instanziierung eines Objekts der angegebenen (Bean-)Klasse
unter gegebenen Namen (falls noch nicht existent)
> Gültigkeitsbereich kann über eine JSP hinausgehen
> Ermitteln und Ändern von Eigenschaften einer JavaBean
> <jsp:getProperty name="mybean" property="propName"/>
> <jsp:setProperty name="mybean" property="propName"
value="propValue"/>
> Mapping eines bzw. aller gleichnamigen Request-Parameter

> <jsp:setProperty name="mybean" property="propName"
param="requestParam"/>
> <jsp:setProperty name="mybean" property="*"/>

JavaBeans
> Komponentenmodell für Java

> Ursprünglich GUI-Komponenten
> Heute beliebige Java-Klasse, die gewisse Konventionen einhält
> Abstraktionsschicht für Logik und Datenzugriff
> Konventionen
> Parameterloser Konstruktor
> Zugriff auf Properties mit Getter- und Setter-Methoden
> Instanzen sind serialisierbar  Persistenz
> Implementieren die Schnittstelle java.io.Serializable
> Einsatzzweck bei JSPs
> Trennung der Präsentation (JSP) vom Datenmodell (Bean)
> View vs. Model

Model 1 Architecture
> JSP Nur für einfachste

> Behandelt Request Anwendungen sinnvoll!
> Übernimmt Steuerung
> Generiert Response
> Datenzugriff wird in Java Beans ausgelagert
1.
JSP
4.
Web- 2.
Browser 3.
Java Bean DB

Model 2 Architecture (MVC Pattern) Für nichttriviale
Anwendungen!
> Serverseitige Realisierung des MVC Patterns
> Model: Java Beans; View: JSP; Controller: Servlet
> Servlet leitet Request an passende JSP weiter

> ServletContext sc = getServletContext();
RequestDispatcher rd =
sc.getRequestDispatcher(forwardURL);
rd.forward(req, res);
1.
Servlet
5.
Web- 2.
Browser 3. 4.
JSP Java Bean DB

Beispiel (JSP und JavaBeans)
public class UserData {
public void setUsername(String value){username = value;}
public void setEmail(String value) {email = value;}
public String getUsername() {return username;}
public String getEmail() {return email;} Bean
}
<jsp:useBean id="user" class="UserData" scope="session"/>
<jsp:setProperty name="user" property="*"/>
</jsp:useBean> Save.jsp
<HTML><BODY>
<jsp:useBean id="user" class="UserData" scope="session"/>
Name: <%= user.getUsername() %><BR>
Email: <%= user.getEmail() %><BR>
</jsp:useBean> Load.jsp
</BODY></HTML>
JSP Standard Tag Library (JSTL)
> Nicht Teil der JSP-Spezifikation, sondern eigene Spezifikation
> Ersetzt Scriptlets bei einfachen Aufgaben
> Iteration: <c:foreach> Aktuelle
> Bedingungen: <c:if> Version
> Alternativen: <c:choose>, <c:when>, <c:otherwise> 1.2.1
<%@ page isELIgnored="false" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
...
Your shopping cart:
<table>
<c:forEach var="product" items="${cart}">
<tr><td>${product}</td></tr>
</c:forEach>
</table>
...
</html>

JSP XML View
Elementtyp Non-XML Syntax XML Tag
<jsp:directive.page ... />

Direktiven <%@ directive %>
<jsp:directive.include ... />
<jsp:declaration>
Deklarationen <%! declarations %> …
</jsp:declaration>
<jsp:expression>
Ausdrücke <%= expression %> …
</jsp:expression>
<jsp:scriptlet>
Codefragmente <% code fragment %> …
</jsp:scriptlet>

Aktuelle
Version
Expression Language (EL) 3.0
<html>
...
Selected CPU has TDP:
<%= ((Computer)req.getAttribute("computer")).getCPU().getTDP() %> W
...
</html> Scriptlet
<html>
...
<jsp:useBean id="computer" class="Computer" scope="request" />
Selected CPU has TDP:
<jsp:getProperty name="computer" property="CPU" /> W
...
</html> JSTL
<html> Lässt sich wegen fehlender

... Unterstützung der JSTL für
Your CPU has TDP: ${computer.CPU.TDP} W Verschachtelung nicht umsetzen
...
</html>
EL

Literatur
> Spezifikationen
> JavaServer Pages 2.3 Specification. 2nd Maintenance Release of
JSR 245.  http://jcp.org/en/jsr/detail?id=245
> JavaServer Pages Standard Tag Library 1.2 Specification. 2nd
Maintenance Release of JSR 52.  http://jcp.org/en/jsr/detail?id=52
> Expression Language 3.1 Specification. JSR 340.
 http://jcp.org/en/jsr/detail?id=340
> Tutorials
> The Java EE 5 Tutorial. Chapter 5: JavaServer Pages Technology.
 http://docs.oracle.com/javaee/5/tutorial/doc/bnagx.html
> Tutorialspoint. JSP Tutorial.  http://www.tutorialspoint.com/jsp
> Bücher
> Siehe Java Servlets.

Fragen?

Exemplarische Fragen zur Lernkontrolle
CGI und Servlets

1. Was ist CGI? Nennen Sie einige Anwendungsbeispiele!
2. Wie werden bei CGI der Request des Clients bzw. die
Formulardaten dem CGI-Skript übergeben?
3. Welche Sicherheitsprobleme können durch das Anbieten
von CGI Scripts auftreten?
4. Worin unterscheiden sich CGI und Java Servlets? Wo liegen
Gemeinsamkeiten?
5. Was sind Java Servlets und wie wird
ein Servlet implementiert?
6. Was ist der Lebenszyklus eines Servlets?
7. HTTP und Servlets sind zustandslos. Wie können dennoch
zustandsbehaftete Sitzungen realisiert werden?
Exemplarische Fragen zur Lernkontrolle
SSI, PHP und JSP

1. Was sind Server Side Includes?
2. Wie ist eine PHP-Seite aufgebaut?
3. Erläutern Sie einige Anwendungsbeispiele von PHP!
4. Was sind JavaServer Pages? Wie ist eine Seite aufgebaut?
5. Wie werden Java Server Pages ausgeführt?
6. Was versteht man unter dem Model/View/Controller-Muster?
Wie wird es bei JavaServer Pages angewendet?
7. Was ist eine Java Bean?
8. Welche weiteren ergänzenden Java Technologien gibt es für
JavaServer Pages? Was ist ihr Zweck? Wie funktionieren sie?

Vielen Dank für Ihre
Aufmerksamkeit!
Univ.-Prof. Dr.-Ing. Gero Mühl
gero.muehl@uni-rostock.de
https://www.ava.uni-rostock.de

08 Server

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

08 Server

Hochgeladen von

Copyright:

Verfügbare Formate

Webbasierte Anwendungen

Architektur von Anwendungssystemen (AVA)

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 2

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 3

> CGI definiert eine Schnittstelle für Aufruf von Programmen

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 4

> Diverse Programmiersprache nutzbar

> Skript antwortet mit neuer Seite (zumindest HTTP-Header)

> Einfaches Beispiel in Perl

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 5

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 6

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 7

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 8

> Query-String an Java übergeben, um GET-Request zu

> Query-String mit Java auslesen, um GET-Request

> CGI-Programme sind „von jedem“ aufrufbar

> Ausführung eines Programms ohne Benutzerkonto

> Problem der Ausführung dynamisch erzeugter

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 10

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 11

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 12

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 13

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 14

> „CGI auf Java-Art“

> Plattformunabhängige Alternative zu CGI

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 15

> Fungiert als Laufzeitumgebung für die Servlets

> Stellt Dienste bereit

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 16

> Servlets werden über

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 18

> Wichtige Methoden der Schnittstelle destroy

> Klasse GenericServlet unabhängig vom verwendeten Protokoll

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 19

> Klasse javax.servlet.http.HttpServlet

> doMethod(HttpServletRequest req,

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 20

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 21

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 22

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 23

public void doPost(HttpServletRequest request,

> Struktur des Archivs

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 25

> Lösungen für durch Multithreading verursachte Probleme

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 26

> Asynchrone Request-Verarbeitung

> Weitere Anwendungsmöglichkeit: Server-Side Push

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 27

> Servlet für asynchrone Requests konfigurieren

> Request in asynchronen Modus versetzen

> Request oder Response aus asynchronem Kontext holen

> Request abschließen und Response schließen

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 28

private static final BlockingQueue<String> messageQueue =

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 29

> Klasse javax.servlet.http.Cookie

> Setzen im Response Header (HTTPServletResponse)

> Lesen aus Request Header (HTTPServletRequest)

G. Mühl Webbasierte Anwendungen / Serverseitige Techniken 31

> boolean isHttpOnly()

> boolean getSecure()

> String getName()

> String getValue()