# JSF, JSP, Servlets - ich verstehe nur noch Bahnhof



## Saheeda (5. Mai 2015)

Guten Abend,

ich sehe bei den ganzen Begrifflichkeiten so langsam nicht mehr durch, vielleicht kann mir ja jemand helfen, das bisschen zu sortieren.
Ich habe u.a. versucht mit diesem Tut zu verstehen, was Sache ist, bin aber kein Stückchen schlauer geworden.


JSF ist, soweit ich das verstanden habe, der große Überbegriff für das MVC-Framework, mit dem Web-Anwendungen unter Java gebaut werden.


Wenn ich mir im Eclipse ein Servlet erstellen lasse, sieht das für mich sehr stark nach nem Controller aus: Ich habe Routing-Definitionen mit exakten Pfaden, Requestmethoden und kann nach Bedarf aus dem Request selbst Header- oder Body-Informationen holen.
In den Beispielen, die ich bisher gefunden habe, wurde der Response aber händisch zusammengebaut:

```
public static final String HTML_START="<html><body>";
public static final String HTML_END="</body></html>";  


protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	PrintWriter out = response.getWriter();
        Date date = new Date();
        out.println(HTML_START + "<h2>Hi There!</h2><br/><h3>Date="+date +"</h3>"+HTML_END);
    }
```
Das sieht für mich ziemlich falsch und für alles jenseits von Hello-World absolut unpraktikabel aus.


Bei JSP dachte ich zunächst, dass dies die View-Komponente wäre. Jetzt lese ich aber ganz oft, dass JSPs zu Servlets umgewandelt werden, also nur ne andere Form von Controller sind.


Dann bin ich noch über den Begriff Bean gestolpert. Laut StackOverflow ist das ne ganz normale Klasse, die: Serializable implementiert, sämtliche Felder privat hat und einen parameterlosen Konstruktor besitzt. Korrekt?


Wo ist die View-Komponente?

Sind Servlets und JSPs nun das gleiche, nur in anderer Schreibweise?

Wie steuere ich über Servlets das Anzeigen/Laden bestimmter html-Dateien? (Oder wie auch immer das Format in dem Fall heißt.)


Vielen Dank!


----------



## stg (6. Mai 2015)

In der Java-Web-Welt basiert eigentlich alles auf Servlets. Das sind Java-Klassen, die einen HTTP-Request verarbeiten und einen HTTP Response generieren. Also genau so etwas, wie das von dir gepostete Hello-World Beispiel. Und ja, du hast Recht, Servlets schreibt man kaum noch selbst, es sei denn, es ist wirklich mal für spezielle Fälle noch notwendig.

JSF ist _ein_ MVC Framework.
Du schreibst hierbei aber nur die Views (in Form von xhtml-Seiten) und das Model selbst (hier sind die Beans einzuordnen). Den Controller-Part übernimmt wiederrum ein spezielles Servlet, das FacesServlet. Hier passiert alles wichtige, Bei einer Anfrage an deinem Server liest das FacesServlet die passende xhtml-Seite aus und generiert daraus HTML Code für den Response. Auch werden hier Daten aus dem Model in die View geschaufelt und umgekehrt, Validierungen vorgenommen undundund ... um all das musst du dich selbst aber gar nicht kümmern. Controller schreibt man in JSF MVC Anwendungen nicht mehr selbst.

Wenn man das berücksichtigt ist auch klar, wieso man sich hier an die Bean-Spezifikation halten sollte. JSF verlangt das einfach, damit das FacesServlet auch tatsächlich die Controller-Rolle gescheit übernehmen kann.

JSP ist eine View-Rendering-Technologie, wird aber faktisch nicht mehr untersützt. JSF verwendet stattdessen Facelets. (Du kannst JSF auch mit JSP als Renderer benutzen, aber das willst du nicht!  )

Reicht dir das als erste Übersicht? Wenn nicht, frag einfach noch mal


----------



## Saheeda (6. Mai 2015)

Hallo stg,

vielen Dank für die fixe Antwort.

Beans sind also quasi die Entitäten, die ich darstellen möchte, erweitert um einige zusätzliche Annotations, um als solche erkannt zu werden?
Baut man dann zwei Klassen? "Pur" und als Bean?


Wenn ich in Eclipse ein Maven-WebApp-Project erstelle, bekomme ich diese Struktur erstellt.


Wenn ich dich jetzt richtig verstanden habe, muss ich nur an 3 Stellen arbeiten:
- src/main/java - Was stelle ich dar (Model)
- src/main/webapp/*.xhtml - Wie stelle ich es dar (Views)
- /webapp/WEB-INF/web.xml - Wodurch stelle ich es dar (Routen-Mapping)


*Face*lets ist "nur" diese besonderen Syntax, mit der man in der View deklariert, wo das Model reingebastelt werden soll.
Rein vom Begriff her ist das *Face*sServlet also der "Controller", welcher Facelets und Beans verknüpft. Korrekt?


Ich verstehe aber noch nicht, warum folgende web.xml so funktioniert:


```
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<display-name>Servlet 3.0 Web Application</display-name>

	<welcome-file-list>
		<welcome-file>faces/home.xhtml</welcome-file>
	</welcome-file-list>

	<servlet>
		<servlet-name>Faces Servlet</servlet-name>
		<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>Faces Servlet</servlet-name>
		<url-pattern>/faces/*</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>Faces Servlet</servlet-name>
		<url-pattern>*.jsf</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>Faces Servlet</servlet-name>
		<url-pattern>*.faces</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>Faces Servlet</servlet-name>
		<url-pattern>*.xhtml</url-pattern>
	</servlet-mapping>
</web-app>
```
- Warum bekomme ich den Inhalt der home.xhtml ausgegeben? Ich habe nirgendwo einen Ordner faces.

- Was sind die .jsf und .faces - Dateien, die im Mapping angegeben sind?


----------



## stg (7. Mai 2015)

Was du hier in der web.xml siehst, ist das servlet-mapping für das FacesServlet. Dein Server empfängt ganz normal HTTP Anfragen. Anhand des Mappings wird entschieden, an welches _Servlet_ die Anfrage weitergeleitet wird. Das hat soweit noch gar nichts mit den Dateien in deinem Projekt zu tun. Das FacesServlet, welches dann die Anfragen erhält, entscheidet nach definierten Regeln dann, welches xhtml File es für die weitere Verarbeitung heranziehen muss. Für all deine vier Mappings würde jeweils das gleiche xhtml-File herangezogen werden, der Client hat also vier verschiedene Möglichkeiten die selbe Seite aufzurufen. Ich würde aber dazu raten nur das letzte (*.xhtml) mapping stehen zu lassen und den Rest zu löschen. Die anderen bringen nur Probleme, aber das geht hier vorerst zu weit..

Beans ... ja das ist so eine Sache für sich. Das kann alles und nichts bedeuten. In deinem Application Server werden verschiedene Frameworks benutzt und es "schwirren verschiedene Container herum". Damit deine Klassen von der richtigen Stelle verwaltet werden können (sofern du nicht alles selbst machen willst, und das willst du nicht...) müssen diese bestimmtn Regeln folgen. So wird meist vorrausgesetzt, dass ein öffentlicher Standard-Konstruktur existiert und Zugriff auf Properties über öffentliche getter/setter erfolgt. Und damit ist deine Klasse dann eine Bean. Das hält dich aber nicht davon ab _zusätzlich_ ganz wie gehabt alles mögliche andere zu programmieren, wie z.B. Factories, finale, nicht instanzierbare Helper-Klassen undundund...

Wir eine Bean von einem Framework (zum Beispiel JSF) verwaltet, spricht man auch von einer ManagedBean. Damit eine Bean zur ManagedBean wird, muss man sie dem Framwork irgendwie bekannt machen. Das geschieht heutzutage eigentlich nur noch über Annotations (es ginge aber auch, ähnlich wie bei deinem FacesServlet, welches so dem Servlet-Container bekannt gemacht wurde,  über die web.xml). JSF ManagedBeans werden über kurz oder lang vermutlich verschwinden und werden immer mehr durch CDI ManagedBeans ersetzt, aber ich will dich nicht groß noch mehr verwirren, also ignorier die letzte Aussage zunächst einmal, behalte das nur im Hinterkopf ... alles gleichzeitig zu lernen überspannt den Bogen maßlos 

Mit Entittäten meint man normalerweise aber wiederum etwas anderes, und zwar bestimmte Klassen (ja, auch wieder Beans), welche dein _Daten_model abbilden. Das ist (zunächst einmal) ganz losgelöst von JSF, Servlets und co. Wenn du in alten (SE) Projekten bereits ein funktionierendes Datenmodel hast, kannst du das getrost verwenden.
Üblicherweise will man seine Daten aber irgendwie auch persistieren. Und da kommt schon wieder ein neuer Spieler ins Team. Du kannst deine Entittäen zum Beispiel vom JPA Framework verwalten lassen und damit dein Datenmodel auf eine relationale Datenbank mappen. 

Facelets ist nur der ViewRenderer, der im Hintergrund vom FacesServlet verwendet wird, um aus deiner xhtml-Seite des Response auf die HTTP Anfrage zu generieren. Vereinfacht läuft das ganze also so ab: 
1. Der Server erhält eine Anfrage z.B. für "faces/home.xhtml"
2. Anhand des Mappings in der web.xml wird enschieden, die Anfrage an das FacesServlet weiterzuleiten
3. Das FacesServlet sucht sich die für den Response benötigten Ressourcen zusammen, u.A. die Datei "home.xhtml"
4. Mittels Facelets wird aus dem xml-Code in der Datei nun HTML für den Response generiert.
5. Das generierte HTML wird an den Client unter der Adresse "faces/home.xhtml" zurückgegeben
Der Client ruft also gar nicht direkt die Datei home.xhtml aus und bekommt diese auch gar nicht direkt zu sehen.


----------



## Saheeda (7. Mai 2015)

Vielen Dank für die ausführliche Erklärung!
 Ich bau mir am besten ne Beispielanwendung und schau mal, wie weit ich komme.


----------

