Anbindung von Spring und JPA/Hibernate

Kurzüberblick Spring

• Das Spring Framework vereinfacht die Entwicklung mit Java/Java EE und stellt vor allem eine ausgereifte Plattform zur Implementierung von Geschäftslogiken bereit.
• Entkopplung per Dependency Injection: Komponenten lösen ihre Abhängigkeiten nicht selbst auf sondern bekommen sie von außen injiziert.
• IoC-Container: Bauplan für die Komponenten der Anwendung (Spring Beans) wird in XML beschrieben, zur Laufzeit werden alle Komponenten erzeugt und mit ihren Abhängigkeiten verdrahtet.
• Spring stellt viele ausgereifte Komponenten zur Integration von anderen Frameworks wie JPA, Hibernate, Quartz Scheduler, EhCache etc. bereit.
• Wicket bietet mit wicket-spring Unterstützung für das Spring Framework.

Abhängigkeiten Spring Framework (pom.xml)

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>2.5.6.SEC01</version>
    <type>jar</type>
    <scope>compile</scope>
    <exclusions><exclusion>
        <artifactId>commons-logging</artifactId>
        <groupId>commons-logging</groupId>
    </exclusion></exclusions>
</dependency>
<dependency>
    <groupId>org.apache.wicket</groupId>
    <artifactId>wicket-spring</artifactId>
    <version>1.4.1</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>

Deklaration von Spring Beans in applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans         xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
                      http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <bean id="carRepository" class="de.ralfebert.cars.persistence.CarRepository">
    </bean>

    <bean id="carService" class="de.ralfebert.cars.service.CarService">
        <property name="carRepository" ref="carRepository"/>
    </bean>

</beans>

Initialisierung Spring Framework

• Spring wird über einen in der web.xml zu deklarierenden Listener beim Start der Web-Anwendung initialisiert:

  <listener>
      <listener-class>
          org.springframework.web.context.ContextLoaderListener
      </listener-class>
  </listener>
  

• Optional können die XML-Dateien mit den Spring Beans konfiguriert werden, standardmäßig wird WEB-INF/applicationContext.xml verwendet:

  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-services.xml, classpath:spring-dao.xml</param-value>
  </context-param>
  

Wicket-Anwendung als Spring Bean

• Die Wicket-Applikationsklasse wird als Spring Bean definiert:

  <bean id="wicketApplication" class="de.ralfebert.someapp.SomeWicketApplication"/>
  

• SpringWebApplicationFactory ist als applicationFactory für den Wicket Filter zu konfigurieren:

  <filter>
      <filter-name>wicketfilter</filter-name>
      <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
      <init-param>
          <param-name>applicationFactoryClassName</param-name>
          <param-value>org.apache.wicket.spring.SpringWebApplicationFactory</param-value>
      </init-param>
  </filter>
  

Spring Beans in Wicket

• Wicket-Komponenten und Seiten werden regelmäßig direkt erzeugt und können im Gegensatz zu Repository oder Service-Objekten nicht vom Spring Framework vorab erzeugt und verdrahtet werden.

• wicket-spring stellt die Klasse SpringComponentInjector bereit, mit der Spring Beans automatisch injiziert werden. Dieser wird in der Applikationsklasse konfiguriert:

  @Override
  protected void init() {
      addComponentInstantiationListener(new SpringComponentInjector(this));
  }
  

Spring Beans in Komponenten und Seiten injizieren

• Dadurch werden in allen von Wicket gemanagten Komponenten automatisch mit @SpringBean annotierte Felder injiziert:

  public class SomePage extends WebPage {
  
      // inject by type
      @SpringBean
      private ISomeService someService;
      
      // inject by name
      @SpringBean(name="someOtherService")
      private ISomeOtherService someOtherService;
      
  }
  

Spring Beans in Modellen und anderen Klassen

• Der gleiche Mechanismus kann in beliebigen Klassen (insb. in Modellklassen) verwendet werden. Die Injektion der abhängigen Komponenten muss jedoch manuell ausgelöst werden:

  InjectorHolder.getInjector().inject(this);
  

Eclipse IDE Tipps & Tricks: Spring IDE

• Die Spring IDE für Eclipse bietet komfortable Tools zur Arbeit mit Spring und vereinfacht insbesondere die Erstellung der XML-Dateien.

• Von folgender Update Site ist Spring IDE Core zu installieren:

  http://dist.springframework.org/release/IDE

• Spring-Projekte müssen als solche ausgezeichnet werden mit Projekt-Kontextmenü > Spring Tools > Add Spring Project Nature

• Bean-XML-Konfigurationsdateien können erstellt werden mit File > New > Other > Spring > Spring Bean Configuration File

• Spring IDE wird erweitert durch SpringSource Tool Suite (kostenlos, kein Open Source)

Wicket und JPA/Hibernate

• JPA-Frameworks wie Hibernate können problemlos für die Persistenzschicht einer Web-Anwendung verwendet werden (Spring bietet hier z.B. ausgezeichnete Unterstützung).
• Problem: Umgang mit Lazy Loading, d.h. dem späteren Nachladen von Objekten.
• Variante 1: Lazy Loading deaktivieren und alle Objekte vorab laden.
• Variante 2: Niemals persistente Objekte in die Web-Anwendung reichen (diese könnten auch direkt manipuliert werden), sondern nicht-persistente Kopien (DTO's - Data Transfer Objects)

Wicket und JPA/Hibernate: OpenSessionInViewFilter

• Variante 3: Mit OpenSessionInViewFilter eine Persistenz-Session je Web-Request bereitstellen (Definition in web.xml):

  <filter>
      <filter-name>hibernateFilter</filter-name>
      <filter-class>
          org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
      </filter-class>
  </filter>
  <filter-mapping>
      <filter-name>hibernateFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>
  

Weitere Informationen

• Wicket/Spring/Hibernate configuration: http://wicketinaction.com/2009/06/wicketspringhibernate-configuration/
• Apache Wicket and Spring: http://cwiki.apache.org/WICKET/spring.html
• Spring Documentation: http://www.springsource.org/documentation