Spring - Hibernate Tutorial (Teil 2) - java-base.org

java-base.org
Spring - Hibernate Tutorial (Teil 2)
27.05.2006
Letzte Aktualisierung 28.05.2006
Teil 2: Integration des Spring-Frameworks
Nachdem wir im ersten Teil bereits ein einfaches JSP-Projekt in Eclipse angelegt haben werden wir im folgenden Teil ein
einfaches "Hello-World"-Beispiel unter Nutzung des Spring-Frameworks entwickeln. Falls noch nicht geschehen
empfehle ich zuerst den ersten Teil des Tutorials durchzulesen und umzusetzen. Â
Vorbereitungen zu Integration des Spring-FrameworksÂ
Im ersten Schritt kopieren wir das Spring-Package (spring.jar) in das lib Verzeichnis des Tomcat-Servers
(TOMCAT_HOME/common/lib). Dieses Package muss danach in den Workspace des Eclipse-Projekts integriert werden.
Dies geschieht über den Menüpunkt: Project -> Properties -> Java Build Path. Das Spring-Package wird hierbei als
externes Archiv (Add External JARs) eingebunden. Der Build-path sollte danach folgendermaßen aussehen:
Â
Damit sind die Spring-Packages sowohl innerhalb des Tomcat Servers als such innerhalb des Eclpise-Projekts
verfügbar.
Im nächsten Schritt legen wir eine neue Datei mit Namen web.xml im Verzeichnis WEB-INF (WEB-INF/web.xml) mit
folgendem Inhalt an:
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
   <!-- Anmerkung 1 -->
   <display-name>spring_web</display-name>
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
   <!-- Anmerkung 2 -->
   <!-- Die üblichen Servlet-Parameter und das entsprechende Servlet-Mapping -->
   <servlet>
       <servlet-name>spring_web</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
   </servlet>
   <!-- Anmerkung 3 -->
   <servlet-mapping>
       <servlet-name>spring_web</servlet-name>
       <url-pattern>*.html</url-pattern>
   </servlet-mapping>
   <listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
   <!-- Anmerkung 4 -->
   <!-- Definition der weiteren Spring-Konfigurationsdateien -->
   <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/spring_web-service.xml</param-value>
   </context-param>
</web-app>
Â
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
Anmerkung 1:
Hierbei handelt es sich um den internen Namen des Servlets
Anmerkung 2:Â
Hier erfolgt die Definition des zum Einsatz kommenden Servlets. Wir nutzen hier das DispatcherServlet des SpringFrameworks. Ãœber dieses Servlet werden alle Anfragen an den Tomcat-Server bearbeitet.Â
Anmerkung 3:Â
Durch das Tag "servlet-mapping" wird definiert welche Anfragen an das DispatcherServlet weitergeleitet werden sollen.
In diesem Beispiel werden alle Anfragen welche auf .html enden vom DispatcherServlet verarbeitet.
Anmerkung 4:Â
In diesem Abschnitt können weitere Konfigurationsdateien definiert werden. Hier wurde bereits eine weitere Datei
"spring_web-service.xml" definiert. Diese Datei legen wir später an.Â
Als nächstes legen wir die Datei spring_web-servlet.xml im WEB-INF Verzeichnis an (WEB-INF/spring_web-servlet.xml).
Diese Datei wird beim Start des Tomcat Server automatisch eingelesen.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
   "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
ÂÂÂ
   <!-- Anmerkung 1 -->
   <!-- Mapping von URLs zu Controllern -->
   <bean id="urlMapper" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
      <property name="mappings">
         <props>
            <prop key="/hello_world.html">helloWorldController</prop>
         </props>
      </property>
    </bean>
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
   <!-- Anmerkung 2 -->
   <!-- Definition des HelloWorld-Controllers -->
   <bean id="helloWorldController" class="org.javabase.web.test.HelloWorldController">
      <property name="helloMessage">
         <value>Hello World...</value>
      </property>
   </bean>
   <!-- Anmerkung 3 -->
   <!-- Zuordnung der Views zur Verarbeitung des ModelAndView Objects-->
   <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name="prefix">
         <value>/WEB-INF/views/</value>
      </property>
      <property name="suffix">
         <value>.jsp</value>
      </property>
   </bean>
ÂÂÂ
</beans>
Â
Anmerkung 1:
Da wir bei der Erstllung des Hello-World-Beispiels Spring MVC (Model View Controller) nutzen muss zunächst eine
Controller-Bean definiert werden. In diesem Abschnitt wird die Anfrage "hello_world.html" auf die Bean
"helloWorldController" gemappt, d.h. alle Anfragen hello_world.html werden von dieser Bean verarbeitet.
Anmerkung 2:Â
Hier
erfolgt die Definition der helloWorldController Bean. Dieser Bean wird nun eine konkrete Klasse zugeordnet:
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
org.javabase.web.test.HelloWorldController. Diese Klasse werden wir weiter unten anlegen. Hier wird auch die
auszugebende Nachricht "Hello World..." durch Dependency Injection (siehe unten) definiert.Â
Anmerkung 3:Â
Der letzte Abschintt definiert, welche jsp-Seite für die Darstellung der Seite genutzt werden soll. Die Nuztung des
InternalViewResolver sorgt dafür, dass die Originalanfrage "hello_world.html" von der View hello_world.jsp verarbeitet
werden soll. Diese View werden wir später im Verzeichnis WEB-INF/views anlegen.
Damit der Tomcat Server später ohne Fehlermeldung startet müssen wir eine weitere Konfigurationsdatei "spring_webservice.xml" anlegen (WEB-INF/spring_web-servie.xml). Diese wird zunächst als leere Hülle für spätere
Konfigurationen erstellt:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
   "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
</beans>
Â
Erstellung der Controller-Klasse
Nun legen wir ein Package namens "org.javabase.web.test" im Verzeichnis WEB-INF/src an. Hier erstellen wir die
Klasse "HelloWorldController" mit folgendem Inhalt:
package org.javabase.web.test;
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class HelloWorldController implements Controller {
   private String helloMessage;
   public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {
ÂÂÂ ÂÂÂ ÂÂÂ
      return new ModelAndView("hello_world", "helloMessage", helloMessage);
ÂÂÂ }
   public void setHelloMessage(String helloMessage) {
      this.helloMessage = helloMessage;
ÂÂÂ }
}
Es ist ersichtlich, dass es sich bei der erstellten Controller-Klasse grundsätzlich um eine "normale" Java-Bean handelt.
Es gibt lediglich eine Instanzvariable namens helloMessage und eine entsprechende Setter-Methode zum initialsieren
des Wertes dieser Variablen. Die Klasse implementiert das Controller-Interface aus dem MVC-Packet des SpringFrameworks. Hierfür ist es notwendig eine weitere Methode namens handleRequest zu implementiern. Diese Methode
gibt ein Objekt der Klasse ModelAndView zurück welches später durch die jsp-Seite (View) ausgegeben wird. Das
ModelAndView Objekt wird mit folgenden drei Parametern erzeugt:
Â
Name der View
In unserem Beispiel "hello_world" welches auf die jsp-Seite "hello_world.jsp" gemappt wird
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
Variablenname
Unter welchem Variablennamen soll die Nachricht verfügbar sein? Hier: helloMessage
VariablenwertÂ
Und schließlich der Wert der Variablen "Hello World...".
Â
 Interessant hierbei ist: Der Wert des Strings helloWorld wird innerhalb der Klasse nicht definiert. Wir haben den
auszugebenden String "Hello World..." bereits in der Konfigurationsdatei "spring_web-servlet.xml" definiert. Doch wie
wird der in der Konfigurationsdatei definierte Wert innerhalb der Java-Klasse bekannt gemacht?
Hier kommt ein spezielles Java Muster (Pattern) zum Einsatz - Dependency Injection. Â
Das Prinzip der "Dependency Injection"
Ein wesentliches Feature des Spring-Frmeworls ist die sogenannte "Dependeny Injection", bzw. "Inversion of Controll".
Hierbei handelt es sich um ein Design-Pattern, welches im Objektorientierten Umfeld im häufiger zum Einsatz kommt.
Wesentliches Prinzip dieses Patterns ist die stärkere Trennung von Verknüpfungen zwischen Komponenten zu
ermöglichen, ohne diese Verknüpfungen (Relationen) fest im Code zu integrieren.Â
Anstelle von festen Verknüpfungen werden diese Abhängigkeiten von anderen Komponten über
Konfigurationsdateien realisiert. Im Rahmen von Spring kommt hier ein definiertes XML-Format zum Einsatz. Das SpringFramework nutzt das Prinzip der "Dependency Injection" in großem Umfang. Im Rahmen der weiteren Teile des Tutorials
werden noch viele Einsatzmöglichkeiten dieses Design-Patterns aufgezeigt.
In diesem Teil werden wir zu Erläuterung des Prinzips ein einfaches Beispiel für eine Dependency Injection nutzen.
Dazu werden wir eine JSP-Seite erzeugen welche die Nachricht "Hello World!" auf dem Browser ausgibt. Dabei werden
wir die Dependency Injection dazu nutzen die auszugebende Nachricht in eine externe Konfigurationsdatei auszulagern.
Wir werden also die Konfiguration der auszugebenden Nachricht vom implementierten Code trennen.
Beim Initialiseren der Controller-Bean durch das Spring-Framework wird der Wert für die Variable helloWorld aus der
Konfigurationsdatei gelesen und mit Hilfe der Setter-Methode innerhalb der Java-Klasse gesetzt. Diese Zuordnungen
kann nicht nur für einfache Stringzuweisungen genutzt werden. Das Prinzip ermögleicht es auch verschiedene
Klassen dynamisch zu verknüpfen. Wie das funktioniert werden ich später an konkreten Beispielen erläutern.
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
Erstellung der View zur Ausgabe der Nachricht
Damit die Nachricht nun endgültig über den Webbrowser ausgegeben werden kann. muss im letzten Schritt die jspSeite - die View - erstellt werden. Das Verzeichnis views muss zunächst noch angelegt werden (WEB-INF/views). Die jspDatei muss gemäß unserer Konfiguration in der web.xml Datei hello_world.jsp heißen und im eben erstellten Verzeichnis
WEB-INF/views gespeichert werden.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Hello World</title>
   </head>
   <body>
ÂÂÂ ÂÂÂ
   </body>
</html>
Hierbei handelt es sich um ein Standard jsp-Seite, wie wir sie bereits im 1. Teil des Tutorials verwendet haben. Eine
Besonderheit stellt die Zeile
dar. Hier geben wir die Hello World Nachricht aus. Der Wert für die Variable wird über das ModelAndView-Objekt des
Controllers an die jsp-Seite übergeben und einfach mit Hilfe des ${VARIABLENNAME} - Konstrukts ausgegeben. Zum
Testen des Beispiels muss der Tomcat-Server neu gestartet werden.
Durch Eingabe von http://localhost:8080/spring_web/helloWorld.html wird folgende Seite ausgegeben:
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33
java-base.org
Damit sind wir Ende des zweiten Teils angekommen. Die Schritten nochmals zusammengefasst:
- Definition der allgemeinen Servlet-Parameter in der Datei web.xml
- Definition des Controllers helloWorldController in der Datei spring_web-servlet.xml und setzen des Ausgabe-Strings
über Dependency Injection
- Erstellung der Controller-Klasse HelloWorldController
- Erstellung der View (hello_world.jsp)Â
Im nächsten Teil folgt die umsetzung einer Internationalisierungs-Strategie (I18N) für die Erstellung von
mehrsprachigen Web-Appliaktionen
http://java-base.org
Powered by Joomla!
Generiert: 7 April, 2017, 22:33