Servlets und Java Server Pages (JSP) Tutorial

Servlets und Java Server Pages (JSP) sind Java Programme, mit dessen Hilfe Browseranwendungen auf Basis von HTML realisiert werden können. Servlets sind Java Klassen, die einen bestimmten Aufbau haben und HTML Code enthalten können. Vor der ersten Ausführung werden die Servlets vom Webserver kompiliert und ausgeführt. Java Server Pages bestehen im Gegensatz zu Servlets hauptsächlich aus HTML Code, können aber auch Java Code enthalten. Die JSP Datei wird vom Webserver in ein Servlet transformiert, kompiliert und ausgeführt.
Das Ergebnis dieser kompilierten Dateien, ist vom Webserver generierter HTML Code. Für den Client ist es also anschließend nicht zu sehen, ob eine Website mit Java, PHP oder purem HTML geschrieben worden ist.

[ad#co-3]

JSPs

  • offene, frei verfügbare Spezifikation von Oracle
  • Alternative zu Mircosofts Active Server Pages (ASP)
  • serverseitige Programme
  • besteht hauptsächlich aus HTML Code – Java Code kann jedoch eingebettet werden

Für die Umsetzung webbasierter Anwendungen auf Basis von Servlets und JSP’s ist Spring (Spring MVC) ein weit verbreitetes Framework. Aus diesem Grund möchte ich an dieser Stelle auf das Spring MVC: Hello World Tutorial hinweisen.
Es ist für das Verständnis trotzdem hilfreich, zunächst dieses Tutorial durchzuführen, da Teile hieraus -wie zum Beispiel das Installieren des Tomcat Servers- Voraussetzung für das Spring Tutorial sind.

Servlets

  • Java Klassen, die auch mittels print Anweisung HTML Code generieren können
  • laufen in einer Laufzeitumgebung
  • Session Management sowie Verwaltung von Lebenszyklen bestimmter Objekte
  • Verwendung der kompletten Java Plattform möglich

Eclipse IDE for Java EE Developers

Als Grundlage für die Erstellung von Java Server Pages und Servlets ist eine Java Entwicklungsumgebung, welche die Voraussetzungen mit sich bringt, Weblösungen zu programmieren. Zum Erstellen von Enterprise Lösungen im Java Umfeld ist wohl die Eclipse IDE die bekannteste und meiste genutzte von allen. Die stets aktuellste Version der Eclipse IDE für die Entwicklung von Enterprise Entwicklungen ist auf der Eclipse Homepage im Downloadbereich verfügbar. Die Eclipse IDE for Java EE Developers ist rund 200 Megabyte groß und enthält bereits (fast) alle relevanten Werkzeuge die für das Erstellen von Java Server Pages und Servlets notwendig sind. In diesem Tutorial wird die Version Helios Service Release 1 verwendet.

Eclipse Enterprise Edition

Ist die Eclipse IDE einmal heruntergeladen und entpackt, fehlt im nächsten Schritt nur noch das Einrichten des Apache Tomcat Servers.

Apache Tomcat installieren

Um Java Server Pages und Servlets erstellen zu können, wird ein Servlet-Container benötigt. Hierzu bietet die Apache Software Foundation eine gute Lösung. Der Apache Tomcat stellt eine Umgebung bereit, in der Java-Code auf Webservern zu lesbaren HTML Code umgewandelt wird. Der Tomcat Servlet-Container leitet Anfragen an das Servlet weiter und verwaltet seinen Lebenszyklus.
Der Apache Tomcat Server kann für das Testen von Servlets und JSP Seiten in einem Apache-Server eingebunden, oder auch als Standalone Server eingesetzt werden. In diesem Tutorial verschmelzen wir die Eclipse IDE mit dem Apache Tomcat Server, so dass wir diesen später nicht explizit verwalten müssen.
Als erstes muss hierzu der Apache Tomcat heruntergeladen und an beliebiger Stelle entpackt werden. Anschließend wird ein neues „Server“ Projekt in Eclipse erstellt (File > New > Other > Server > server).

Apache Tomcat einrichten - Schritt 1

Im nächsten Schritt wählen wir den Apache Tomcat Server mit der Version aus, die zuvor heruntergeladen wurde (hier, Tomcat v6.0 Server).

Apache Tomcat einrichten - Schritt 2

Auf der nächsten Wizard Seite muss das root Verzeichnis, indem sich der Tomcat befindet, ausgewählt werden, bevor der Erstellungsprozess mit Finish abgeschlossen werden kann.

Apache Tomcat einrichten - Schritt 3

Als Ergebnis hat sich ein neues Project in dem Eclipse Project Exlporer mit dem Namen Servers angelegt. In den nachfolgenden Webprojekten kann anschließend dieser Server für die Darstellung der JSP Seiten verwendet werden.

Webprojekt erstellen

Da nun alle notwendigen Vorbereitungen getroffen wurden, kann das eigentlich Webprojekt erstellt werden. Hier muss ein Dynamic Web Project in Eclipse angelegt werden.

Dynamic Web Project anlegen

File > New > Dynamic Web Project

Dynamic Web Projekt anlegen

Im Grunde genommen kann in der aufpoppenden Wizardmaske das meiste übernommen werden. Das Projekt erhält einen Projektnamen (hier: de.michel.jee.MyFirstWebProject) sowie die passende Runtime (Apache Tomcat v6.0 ist der zuvor installierte Tomcat). Wer möchte, wählt zusätzlich einen separaten Speicherort für das Webprojekt. Mit Finish wird schlussendlich das neue Projekt erstellt.

New Dynamic Web Project

Die Grundstruktur des Projektes wird durch das Erstellen eines Dynamic Web Project in Eclipse automatisch hergestellt. Hierzu zählt beispielsweise der WebContent-, META-INF– oder auch der WEB-INF Ordner. Eine der wichtigsten Konfigurationsdateien ist die in dem WEB-INF befindliche web.xml. In dieser Datei werden grundlegende Verzeichnisstrukturen festgelegt. Ein kleiner Blick in die web.xml Datei sagt uns, dass als welcome-file unter anderem eine index.jsp Datei angesprochen wird. Da diese Datei nicht automatisch mit angelegt worden ist, muss dies nachgeholt werden.

index.jsp erstellen

Die index.jsp Datei wird diejenige Datei sein, welche als erstes bei dem Aufruf des Webservers abgerufen wird. Zum erstellen dieser Datei ist ein Rechtsklick auf den Ordner WebContent, anschließend auf New und schlussendlich auf JSP File notwendig.
Die neue Datei hat inhaltlich zunächst sehr hohe Ähnlichkeiten mit einer normalen HTML Datei. Anders als bei einer reinen HTML Datei, kann in der .jsp Datei nun Java Code eingefügt werden. Zum Testen wird das aktuelle Datum ausgegeben.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Mehr Tutorials gibt es auf: http://www.itblogging.de</title>
</head>
<body>

Hello World<br />
<%= new java.util.Date() %>

</body>
</html>

Tomcat Server starten

Um sicherzustellen, dass der Webserver richtig eingerichtet worden ist, wird dieser erstmalig gestartet. Rechtsklick auf das Projekt de.michel.jee.myFirstWebProject > Run As > Run on Server. Die Einstellungen können übernommen und der Server über Finish gestartet werden.

Apache Tomcat starten

In der Regel sollte sich nun in der Eclipse IDE der interne Browser öffnen. Passiert dies nicht, kann in einem beliebigen Browser unter der Webadresse http://localhost:8080/de.michel.jee.myFirstWebProject/ der Server aufgerufen werden. Als Resultat ist nachfolgendes Ausgabe sichtbar:

Hello World
Wed Nov 24 21:12:11 CET 2010 

Formularverwaltung mit jsp

Zur Veranschaulichung wird ein kleines simples Loginbeispiel erstellt. Hierzu wird zunächst die index.jsp Seite etwas umgestaltet. In diesem Beispiel wird das Formular mit der GET-Methode übertragen. Dies sollte natürlich in einem Produktivumfeld niemals passieren. Es dient in diesem Tutorial lediglich zur Veranschaulichung für die spätere Parameterverarbeitung.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Mehr Tutorials gibt es auf: http://www.itblogging.de</title>
</head>
<body>

Zum Login bitte Benutzername und Passwort eingeben:<br />
<hr />

<form method="get" name="login" action="loginCheck.jsp">
Benutzername<br />
<input type="text" name="loginName" /><br />
Passwort<br />
<input type="password" name="password" /><br />
<input type="submit" value="login" />
<input type="reset" value="reset" />
</form>

</body>
</html>

Das Ergebnis sollte nach dem Start des Tomcat Servers in etwa wie folgt aussehen:

Loginformular

Der Benutzername „simon“ sowie das Passwort „itblogging“ werden später für den Logincheck benötigt.
Wie dem einen oder anderen aufmerksamen Leser bestimmt aufgefallen ist, wird das Formular an die Datei loginCheck.jsp gesendet. Diese Datei muss zunächst im selben Ordner wie die index.jsp erstellt werden. loginCheck.jsp überprüft den Benutzernamen sowie das Passwort und gibt schlussendlich das entsprechende Ergebnis aus.

In der loginCheck JSP Seite steht nun ein Request Objekt zur Verfügung. Es ist ein vordefiniertes Objekt von HTTPServletRequest aus dem unter anderem die übergebenen Parameter ausgelesen werden können.
Die eingegeben Logindaten werden mit request.getParameter() aus dem Request Objekt angefordert (sie stehen in diesem Fall sogar in der Adressleiste) um sie anschließend zu überprüfen. Die Benutzerdatenüberprüfung wird an dieser Stelle aus Demonstrationszwecken ebenfalls sehr simpel gehalten.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>

<%
String loginName = request.getParameter("loginName");
String password = request.getParameter("password");

if(loginName.equals("simon"))
{
	if(password.equals("itblogging"))
	{
		out.println("Benutzername und Passwort wurden korrekt eingegeben");
	}else
	{
		out.println("Das Passwort ist falsch. Bitte versuche es erneut<br />");
		out.println("<a href='index.jsp'>Hier</a> geht es zur&uuml;ck zur Eingabemaske!");
	}
	
}else
{
	out.println("Benutzername nicht vorhanden<br />");
	out.println("<a href='index.jsp'>Hier</a> geht es zur&uuml;ck zur Eingabemaske!");
}
%>

</body>
</html>

Wurde der Benutzername sowie das Passwort korrekt eingegeben, wird der Text Benutzername und Passwort wurden korrekt eingegeben in dem Browser ausgegeben. Andernfalls wird es nochmals versucht.

Ein kleines Servletbeispiel

Zur Demonstration wird ein minimalistisches Servlet zum Zählen der Seitenzugriffe erstellt. Zunächst wird das Counter-Servlet wie folgt über die Eclipse IDE erstellt.
File > New > Other > Web > Servlet

Counter Servlet

Ein Servlet wird in der Regel immer mit einer doGet() und einer doPost() Methode erstellt. Die doGet() Funktion wird ausgeführt, sobald die Seite über die GET-Funktion (also die „normale“ Möglichkeit über die vollständige URI) aufgerufen wurde und die doPost() entsprechend, wenn die Seite über die POST-Methode aufgerufen wird. Logischerweise wird immer eine von beiden Funktionen ausgeführt. Eine Funktion, die jedoch unabhängig der Aufrufermethode angesprochen wird, ist die service() Methode. Genau diese wird für dieses Tutorial zunächst genutzt.

package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class Counter
 */
public class Counter extends HttpServlet {
	
	private static final long serialVersionUID = 1L;
	private int counter = 1;
       
	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		response.setContentType("text/html");
		PrintWriter writer = response.getWriter();
		
		writer.write("Ich bin ein Servlet und z&auml;hle die Seitenzugriffe<br />");
		writer.write("Es ist das " + counter++ + " mal das ich aufgerufen wurde!");
	}
}

Was macht nun dieses Servlet? Das Servlet verwaltet einen internen Counter, der bei jeder Anfrage um einen Wert hochgezählt wird. Zum testen kann das Servlet unter http://localhost:8080/de.michel.jee.myFirstWebProject/Counter aufgerufen werden.
Je öfter das Counter Servlet aufgerufen wird, desto höher ist der Zählerstand.
Nun stellt sich noch die Frage, woher der Browser weiß, das er genau dieses Servlet bei der oben genannten Adresse aufrufen soll. Ganz einfach. Bei der Erstellung des neuen Servlets wurde parallel die web.xml Datei bearbeitet. Nun ist diese nicht nur mit den welcome-files, sondern zusätzlich mit der Zuweisung des Counter Servlets gefüllt.

<servlet>
    <description></description>
    <display-name>Counter</display-name>
    <servlet-name>Counter</servlet-name>
    <servlet-class>servlet.Counter</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>Counter</servlet-name>
    <url-pattern>/Counter</url-pattern>
  </servlet-mapping>

Das Servlet erhält einen Namen sowie die Zuweisung der .java Datei (servlet.Counter). Das servlet-mapping macht nichts anderes, als die Client Anfrage an das richtige Servlet weiterzuleiten. Was anschließend passiert, kennen wir bereits.

Zusammenspiel zwischen JSP und Servlet

In dem JSP Beispiel wurde gezeigt, wie eine Parameterverwaltung innerhalb einer JSP verarbeitet werden kann. Das Loginformular kann nun dazu genutzt werden, ein eigenes LoginCheck Servlet anzusprechen. Hierzu wird analog zu dem Counter Servlet das LoginCheck Servlet erstellt.
Ergänzend muss das Formular in der index.jsp wie folgt angepasst werden:

<form method="GET" name="login" action="LoginCheck">

Das Formular sendet nun die eingegebenen Benutzerdaten zu dem LoginCheck Servlet. Wie bereits zuvor erwähnt, gibt es innerhalb eines Servlets die Möglichkeit zwischen den Aufrufermethoden zu unterscheiden. Da das Formular über die GET-Methode versendet wird, wird schlussfolgernd die doGet() Methode in dem Servlet angesprochen.

package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginCheck extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
	{
		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		
		String loginName = request.getParameter("loginName");
		String password = request.getParameter("password");

		if(loginName.equals("simon"))
		{
			if(password.equals("itblogging"))
			{
				out.println("Benutzername und Passwort wurden korrekt eingegeben");
			}else
			{
				out.println("Das Passwort ist falsch. Bitte versuche es erneut<br />");
				out.println("<a href='index.jsp'>Hier</a> geht es zur&uuml;ck zur Eingabemaske!");
			}
		}else
		{
			out.println("Benutzername nicht vorhanden<br />");
			out.println("<a href='index.jsp'>Hier</a> geht es zur&uuml;ck zur Eingabemaske!");
		}
	}
}

Der Einfachheit halber ist die Loginvalidierung aus der loginCheck.jsp übernommen und angepasst worden. Nach erneutem Start des Tomcat Servers sollte das Ergebnis (bis auf die URI) dasselbe sein, wie zuvor die Lösung über die JSP Variante.