Spring/Hibernate har varit det dominerande ramverket allt efter som utvecklare har insett begränsningarna med tidigare EJB standarder. Först när EJB 3.0 och Persistence 2.0 släpptes 2005 så dök det upp en värdig konkurrent. Teamet bakom SpringSource har dock fortsatt ligga i framkant och sätter ännu de facto standarden för enterprice applikationer.

Den förmodligen största utmaningen är den komplexa setupen av ett Spring/Hibernate projekt, något man nu försöker bemöta med verktyget ROO.

Här följer en enkel setup för ett web-projekt med Spring 2.5 och Hibernate 3:

1.) Se till att kopiera in rätt .jar filer i projektet.

Samtliga jarer finns med om man laddat ner Spring med “dependencys”.

2.) Configurera deployment descriptorn att ladda applicationContext

Det rekommenderade sättet att göra detta på är att använda springs “ContextLoaderListener”. Per default kommer lyssnaren att leta efter /WEB-INF/applicationContext.xml att ladda.

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

Application context kan sedan splittas upp i flera filer för att göra konfigurationen hanterbar. Så här kan det se ut:

<?xml version="1.0"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"  "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!-- Import all beans that handles persistence -->
    <import resource="spring/persistenceConfig_was.xml"/>

    <!--  Service Layer -->
    <import resource="spring/services.xml"/>

    <!--  Dao Layer -->
    <import resource="spring/daos.xml"/>

</beans>

Man kan även configurera “contextConfiglocation” som context param i web.xml där man talar om vilka filer som ska mergas ihop till applicaktionContext. Detta är det rekommenderade sättet att göra det på. Filnamnen kan även föregås av “classpath:” om man tex vill addressera ett “shared library”.

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/spring/persistenceConfig_was.xml
            /WEB-INF/spring/services.xml
            /WEB-INF/spring/daos.xml
        </param-value>
    </context-param>

Och här är filerna vi refererar till:

3.) Configurera Hibernate Session Factory

Vi använder Springs org.springframework.orm.hibernate3.LocalSessionFactoryBean och definierar upp nödvändig Hibernate configuration. Sessionfactoryn placerar vi i en fil vi kallar för persistenceConfig.xml, som vi laddar som en del av application context. Det är en fördel att ha detta i en egen fil när det väl fungerar, då man inte vill ändra i den av misstag. I det här fallet använder vi en DerbyDatabas.:

    <!-- HIBERNATE SESSION FACTORY -->
        <bean id="sessionFactory"
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

            <property name="dataSource">
                <ref bean="dataSource" />
            </property>

            <property name="configLocation">
                   <value>/WEB-INF/spring/hibernate.cfg.xml</value>
               </property>           

            <property  name="configurationClass">
                   <value>org.hibernate.cfg.AnnotationConfiguration</value>
            </property>

            <property name="hibernateProperties">
                <props>
                    <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
                    <prop key="hibernate.show_sql">false</prop>
                    <prop key="hibernate.format_sql">false</prop><!-- Will "pretty print" sql in log if set to true -->
                    <prop key="hibernate.use_sql_comments">false</prop>
                    <prop key="hibernate.jdbc.batch_size">50</prop>
                    <prop key="hibernate.cache.use_second_level_cache">false</prop>

                    <prop key="hibernate.transaction.flush_before_completion">true</prop>
                    <prop key="hibernate.transaction.auto_close_session">true</prop>
                </props>
            </property>
        </bean>
    <!-- /HIBERNATE SESSION FACTORY -->

SessionFactory behöver även en datasource:

    <!-- DATASOURCE -->
        <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
            <property name="jndiName" value="java:comp/env/portalDs"/>
            <property name="lookupOnStartup" value="false"/>
            <property name="cache"     value="true"/>
            <property name="proxyInterface" value="javax.sql.DataSource"/>
         </bean>
    <!-- /DATASOURCE -->

4.) Configurera en transaction manager

Här använder vi sessionFactory och injectar i org.springframework.orm.hibernate3.HibernateTransactionManager. Vi konfigurerar även upp en sk txProxyTemplate att använda i tex framtida service proxys:

    <!-- TRANSATION CONFIGURATION -->
        <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>         

        <bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true">
            <property name="transactionManager"><ref bean="transactionManager"/></property>
            <property name="transactionAttributes">
                <props>
                    <!-- A "-" before the exception indicates that the transaction should be rolled back -->
                    <prop key="*">PROPAGATION_REQUIRED,-java.lang.Exception</prop>
                </props>
            </property>
        </bean>
    <!-- /TRANSATION CONFIGURATION -->

Ett alternativ (och rekommendationen) om man kör WebSphere 6 eller senare, är att använda org.springframework.transaction.jta.WebSphereUowTransactionManager i stället:

        <bean id="transactionManager"
          class="org.springframework.transaction.jta.WebSphereUowTransactionManager"/>

Sitter man i stället med en äldre version av WebSphere kan man använda WebSphereTransactionManagerFactoryBean:

    <bean id="wsTransactionManager" class="org.springframework.transaction.jta.WebSphereTransactionManagerFactoryBean"/> 

    <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
        <property name="transactionManager">
            <ref bean="wsTransactionManager"/>
        </property>
    </bean>

Med det avslutar jag första kapitlet - nästa steg är att börja konfigurera BO:s