eclipse下搭建SSH整合環境(Struts2+Spring+Hibernate+maven)

時間 2019-11-11

標籤 eclipse 搭建 ssh 整合環境 struts2+spring+hibernate+maven struts spring hibernate maven 欄目 Eclipse 简体版

原文原文鏈接

1，建立一個maven工程，在選擇Archetype時選擇webapp： html

2，下一步配置maven的pom.xml文件，獲取依賴的jar包： java

<!-- struts2核心包 -->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.3.1.2</version>
</dependency>

<!-- struts2與spring整合的包 --> 
<dependency> 
    <groupId>org.apache.struts</groupId> 
    <artifactId>struts2-spring-plugin</artifactId> 
    <version>2.3.1.2</version> 
</dependency>

<!-- 在 Struts2中要使用 Ajax得到Json數據。要使用Ajax必須引用此Jar --> 
<dependency> 
    <groupId>org.apache.struts</groupId> 
    <artifactId>struts2-json-plugin</artifactId> 
    <version>2.3.1.2</version> 
</dependency>

<!-- Hibernate核心包 --> 
<dependency> 
    <groupId>org.hibernate</groupId> 
    <artifactId>hibernate-core</artifactId> 
    <version>3.6.10.Final</version> 
</dependency>

<!-- spring3可選的依賴注入，不可缺乏 --> 
<dependency> 
    <groupId>org.aspectj</groupId> 
    <artifactId>aspectjweaver</artifactId> 
    <version>1.7.3</version> 
</dependency>

<!-- 擴展Java類與實現Java接口 --> 
<dependency> 
    <groupId>cglib</groupId> 
    <artifactId>cglib</artifactId> 
    <version>2.2</version> 
</dependency>

<!-- 運用Log4j必須用到這個包 --> 
<dependency> 
    <groupId>org.slf4j</groupId> 
    <artifactId>slf4j-api</artifactId> 
    <version>1.7.5</version> 
    <scope>compile</scope> 
</dependency>

<!-- Spring包 --> 
<!-- Spring核心包 --> 
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
    <type>jar</type> 
</dependency>

<!-- Spring在WEB上的MVC框架上加上這個包 --> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-webmvc</artifactId> 
    <version>3.2.3.RELEASE</version> 
    <type>jar</type> 
    <scope>compile</scope> 
</dependency>

<!-- log4j日誌包 --> 
<dependency> 
    <groupId>log4j</groupId> 
    <artifactId>log4j</artifactId> 
    <version>1.2.16</version> 
    <scope>compile</scope> 
</dependency>

<!-- jsp接口 --> 
<dependency> 
    <groupId>javax.servlet.jsp</groupId> 
    <artifactId>jsp-api</artifactId> 
    <version>2.1</version> 
    <scope>provided</scope> 
</dependency>

<!-- 鏈接池 --> 
<dependency> 
    <groupId>c3p0</groupId> 
    <artifactId>c3p0</artifactId> 
    <version>0.9.1.2</version> 
</dependency>

<!-- servlet接口 --> 
<dependency> 
    <groupId>javax.servlet</groupId> 
    <artifactId>servlet-api</artifactId> 
    <version>2.5</version> 
    <scope>provided</scope> 
</dependency>

<!-- Mysql數據庫JDBC鏈接包 --> 
<dependency> 
    <groupId>mysql</groupId> 
    <artifactId>mysql-connector-java</artifactId> 
    <version>5.1.26</version> 
    <scope>compile</scope> 
</dependency>

若是沒使用maven,eclipse默認會去bin目錄找class文件，若是使用了maven,則會去target\test-classes目錄下去找class文件。恰好個人打包腳本中包含了mvn clean命令，將target\test-classes目錄下的文件清空了，在target\test-classes目錄尚未對應的class文件，因此會拋ClassNotFoundException！Project-clean操做讓eclipse從新編譯，恰好能夠解決這個問題。 mysql

3，在src下建立目錄webapp/WEB-INF/，並在WEB-INF下建立web.xml文件。 web

一，spring環境搭建+測試 spring

在web.xml文件中添加spring的啓動監聽器ContextLoaderListener sql

<!-- 監聽器Spring --> 
    <listener> 
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
    </listener>  
    <!-- 定位applicationContext.xml的物理位置 --> 
    <context-param> 
        <param-name>contextConfigLocation</param-name> 
        <param-value>classpath:applicationContext.xml</param-value> 
    </context-param>

這樣在web容器啓動的時候，會自動裝配Spring的位於/WEB-INF/下的applicationContext.xml配置文件通常狀況下，因爲須要配置的bean較多，因此都是將bean按業務分類，在不一樣的配置文件中進行配置。而後在applicationContext.xml文件中導入分類的配置文件的。數據庫

可是如今測試的時候會直接在applicationContext.xml文件下進行bean配置： express

<bean name="person" class="us.xuhang.project.domain.Person">
    <property name="age" value="23" />
</bean>

測試：

@Test
public void testSpringEnv(){
    //加載Spring的配置文件，獲得ApplicationContext對象
    ApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
    //獲取bean對象
    Person person = (Person) context.getBean("person");
    System.out.println(person.getAge());
}

二，Spring和Hibernate的整合+測試

SessionFactory是Hibernate中的一個類，這個類主要負責保存HIbernate的配置信息，以及對Session的操做。
apache

在Hibernate的核心配置文件hibernate.cfg.xml中配置<session-factory/>: json

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- sessionFactory表明一個數據庫的描述 -->
    <session-factory>
        <!-- 數據庫用戶名、密碼、驅動、URL、數據庫方言 -->
        <property name="connection.password">123456</property>
        <property name="connection.username">root</property>
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/eclipseweb
        </property>
        <!-- 告訴hibernate連接的是什麼數據庫 -->
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <!-- 顯示sql語句 -->
        <property name="show_sql">true</property>
        <!-- validate 默認值 根據持久化類和映射文件檢查表的結構 update hibernate容器在啓動的時候，會根據持久化類和映射文件檢查表的結構
            若是不存在，則建立，若是存在，則更新 create 每次啓動hibernate容器，無論表是否存在，都會建立 create-drop 當啓動hibernate容器時建立表，當hibernate容器銷燬時，刪除表 -->
        <property name="hbm2ddl.auto">update</property>
        <property name="format_sql">true</property>
        <!-- 持久化類和數據庫表的映射文件 -->
        <mapping resource="us/xuhang/project/domain/Person.hbm.xml" />
    </session-factory>
</hibernate-configuration>

在Hibernate3.6版本中的dtd文有變化，改爲上面的，否則會提示錯誤。

編寫Person的映射文件Person.hbm.xml(位於和Person類相同的目錄下)。配置實體類和數據庫表的映射關係。

<hibernate-mapping>
    <class name="us.xuhang.project.domain.Person">
        <id name="pid" length="40">
            <generator class="assigned"></generator>
        </id>
        <property name="name" length="20"></property>
        <property name="age" type="int"></property>
    </class>
</hibernate-mapping>

爲防止該配置文件找不到，最好將該文件複製到src/main/resources下

src/main/resources/us/xuhang/project/domain/

測試：

@Test
    public void testHibernateEnv(){
        //加載指定目錄下的配置文件，獲得configuration對象
        Configuration cfg = new Configuration().configure("hibernate/hibernate.cfg.xml");
        //根據configuration對象獲得session工廠對象
        SessionFactory factory = cfg.buildSessionFactory();
        //使用工廠類打開一個session
        Session session = factory.openSession();
        //開啓事務
        Transaction tx = session.beginTransaction();
        //建立待插入數據庫的對象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
        Person p = (Person) context.getBean("person");
        p.setPid(UUID.randomUUID().toString());
        p.setName("xxx");
        //保存對象
        session.save(p);
        //提交事務
        tx.commit();
        //關閉資源
        session.close();
        factory.close();
    }

以上是Hibernate本身管理SessionFactory的建立，下面將SessionFactory的建立過程交給Spring容器：

若是關於數據庫的鏈接信息等仍然在Hibernate的配置文件中配置，即由Hibernate管理數據庫的鏈接，則只須要在Spring的配置文件中配置SessionFactory的bean時注入configLocation，值爲Hibernate的配置文件路徑：classpath:hibernate/hibernate.cfg.xml

<!-- 若是關於數據庫的屬性在hibernate.cfg.xml中配置了，設置hibernate.cfg.xml的location便可 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation">
            <value>classpath:hibernate/hibernate.cfg.xml</value>
        </property>
    </bean>

還有一種方法是有Spring來管理數據庫的鏈接，這裏使用c3p0來幫助管理數據源

<!-- 用Bean定義c3p0數據源 --> 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc\:mysql\://localhost\:3306/eclipseweb" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>
 
 
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <!-- 經過classpath的方式指向了映射文件所在的目錄,把domain包及子包下全部的映射文件所有加載了 -->
        <property name="mappingDirectoryLocations">
            <value>classpath:us/xuhang/project/domain</value>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
 
    <!-- 定義事務管理器（聲明式的事務） -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
 
    <!-- 切入點表達式 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
    
    <!-- 切面 -->
    <aop:config>
        <aop:pointcut id="interceptorPointCuts" expression="execution(* us.xuhang.project.dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />      
    </aop:config>

將SessionFactory對象的建立交給Spring容器來管理，在Spring的配置文件中配置SessionFactory的bean。

若是SessionFactory交給Hibernate管理，能夠直接在Hibernate的配置文件hibernate.cfg.xml中使用<session-factory/>配置數據庫的鏈接信息，而後在Spring的配置文件中導入Hibernate的配置文件：

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="configLocation">
        <value>classpath:hibernate/hibernate.cfg.xml</value>
    </property>
</bean>

同時在<session-factory/>中加入持久化類和數據庫表的映射文件路徑：

<mapping resource="us/xuhang/project/domain/Person.hbm.xml" />

若是SessionFactory交給Spring容器管理，其中在Spring的配置文件中給SessionFactory注入數據源DataSource，數據源可使用JDBC數據源，也可使用第三方的C3P0數據源管理。

若是使用JDBC數據源，只需將DataSource的bean的class屬性值改成org.springframework.jdbc.datasource.DriverManagerDataSource，而後給該類注入相應的屬性。

<!-- 用Bean定義jdbc數據源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

若是使用C3P0數據源，則將DataSource的bean的class屬性值改成對應的類com.mchange.v2.c3p0.ComboPooledDataSource，而後注入該類的相應的屬性。

<!-- 用Bean定義c3p0數據源 --> 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driverClassName}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

以後將數據源注入到SessionFactory中，同時加入映射文件的路徑和數據庫的方言等配置

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <property name="mappingDirectoryLocations">
            <value>classpath:us/xuhang/project/domain</value>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

三，Spring和Struts2的整合

在web.xml中加入struts2的核心過濾器：

<filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

struts的配置文件struts.xml需放在classpath路徑下，而後按照業務不一樣分類配置struts，而後再在struts中include：

<struts>
    <!-- 告訴struts由spring容器做爲bean工廠 -->
    <constant name="struts.objectFactory" value="spring"></constant>
    <include file="struts/struts-person.xml" />
</struts>

struts/struts-person.xml：

<package name="person" namespace="/" extends="struts-default">
    <!-- 這裏action對象的建立有spring容器管理，因此class值再也不指定具體的全路徑類名，而是直接從spring容器中取，這裏的值爲spring容器管理action的id值 -->
    <action name="personAction1" class="personAction1" method="personAction">
        <result name="success">index.jsp</result>
    </action>
</package>

spring的配置文件中管理action的bean：

<bean id="personAction1" class="us.xuhang.project.controller.PersonAction" scope="prototype">
    <property name="param" value="springControlStruts" />
</bean>

struts和Spring整合以後就會發現struts的映射文件中action的class值應爲Spring中相應action的id。

因爲struts的action是多例的，因此在spring容器管理action對象建立的時候須要指明一下，設置action的scope屬性值爲prototype。

SSH零配置整合

web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd">
    <!-- 監聽器Spring -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 定位applicationContext.xml的物理位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext.xml</param-value>
    </context-param>
    <!-- hibernate 懶加載的問題過濾 ,能夠不配置 -->
    <filter>
        <description>hibernate Session 過濾器</description>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- struts配置 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
    <context:annotation-config />
    <context:component-scan base-package="us.xuhang.project.ssh" />
    <context:property-placeholder location="classpath:hibernate.properties"/>
    <import resource="classpath:hibernate.cfg.xml"/>
    <aop:aspectj-autoproxy />
    <!-- 定義事務管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
 
    <!-- 加載事務驅動 -->
    <!-- 對@Transactional這個註解進行的驅動，這是基於註解的方式使用事務配置聲明，這樣在具體應用中能夠指定對哪些方法使用事務 -->
    <tx:annotation-driven transaction-manager="transactionManager"
        proxy-target-class="true" />
 
    <!-- 事務的策略 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="select*" propagation="REQUIRED" read-only="true" />
            <tx:method name="*" read-only="true" />
        </tx:attributes>
    </tx:advice>
 
    <!-- AOP配置 -->
    <aop:config>
        <!-- 對知足下面表達式的(業務邏輯層)方法實施事務 -->
        <aop:pointcut id="txPointcut"
            expression="execution(* us.xuhang.project.service.*.*(..))" />
        <!-- 引用上面的事務策略txAdvice -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
    </aop:config>
 
    <!-- 聲明日誌記錄通知 -->
    <bean id="logInterceptor" class="us.xuhang.project.interceptor.LogInterceptor"></bean>
    <aop:config>
        <!-- 配置一個切面 -->
        <aop:aspect id="point" ref="logInterceptor">
            <!-- 配置切入點，指定切入點表達式 -->
            <!-- 此句也可放到 aop:aspect標籤外依然有效 -->
            <aop:pointcut expression="execution(public * us.xuhang.project.service..*.*(..))"
                id="myMethod" />
            <!-- 應用前置通知 -->
            <aop:before method="before" pointcut-ref="myMethod" />
            <!-- 應用環繞通知需指定向下進行 -->
            <aop:around method="around" pointcut-ref="myMethod" />
            <!-- 應用後通知 -->
            <aop:after-returning method="afterReturning" pointcut-ref="myMethod" />
            <!-- 應用拋出異常後通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="myMethod" />
        </aop:aspect>
    </aop:config>
</beans>

struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
 
<struts>
    <!-- 使用Spring -->
    <constant name="struts.objectFactory" value="spring" />
    <constant name="struts.devMode" value="true" />
    <constant name="struts.configuration.xml.reload" value="true" />
     
    <package name="default" extends="struts-default" namespace="/">
        <!-- 聲明攔截器 -->
        <interceptors>
            <!-- 權限攔截器 -->
            <interceptor name="authority"
                class="us.xuhang.project.interceptor.AuthorityInterceptor" />
            <!-- 異常攔截器 -->
            <interceptor name="exceptionInterceptor"
                class="us.xuhang.project.interceptor.ExceptionInterceptor" />
            <!-- 聲明攔截器棧！解決struts安全漏洞，攔截全部的帶有#號的url -->
            <interceptor-stack name="MyStack">
                <interceptor-ref name="authority" />
                <interceptor-ref name="exceptionInterceptor" />
                <interceptor-ref name="params">
                    <param name="excludeParams">.*\\u0023.*</param>
                </interceptor-ref>
                <!-- 使用自定義攔截器後就不會再使用默認攔截器棧，這裏須要把默認攔截器棧加進來。 -->
                <interceptor-ref name="defaultStack" />
            </interceptor-stack>
        </interceptors>
 
        <default-interceptor-ref name="MyStack" />
        <!-- 定義全局的result -->
        <global-results>
            <result name="login">/index.jsp</result>
            <result name="error">/error.jsp</result>
        </global-results>
    </package>
 
</struts>

hibernate.cfg.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" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
 
    <!-- C3P0 數據源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${hibernate.connection.driver_class}" />
        <property name="jdbcUrl" value="${hibernate.connection.url}" />
        <property name="user" value="${hibernate.connection.username}" />
        <property name="password" value="${hibernate.connection.password}" />
        <property name="initialPoolSize" value="${hibernate.connection.initialPoolSize}" />
        <property name="minPoolSize" value="${hibernate.connection.minPoolSize}" />
        <property name="maxPoolSize" value="${hibernate.connection.maxPoolSize}" />
        <property name="preferredTestQuery" value="select 1 from dual " />
    </bean>
 
    <!-- SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.tianlihu.projects.ssh.*.po" />
        <property name="useTransactionAwareDataSource" value="true" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <prop key="hibernate.temp.use_jdbc_metadata_defaults">${hibernate.temp.use_jdbc_metadata_defaults}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                <prop key="hibernate.connection.autocommit">false</prop>
                <prop key="hibernate.current_session_context_class">thread</prop>
            </props>
        </property>
    </bean>
 
    <!-- 配置事務管理 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
 
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
 
    <aop:aspectj-autoproxy />
    <tx:annotation-driven />
</beans>

hibernate.properties:

## hibernate
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=create-drop
hibernate.temp.use_jdbc_metadata_defaults=false
 
## hibernate cache
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
hibernate.cache.use_query_cache=false
hibernate.cache.use_second_level_cache=true
 
## C3P0 configuration
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=GBK
hibernate.connection.username=root
hibernate.connection.password=root
hibernate.connection.initialPoolSize=1
hibernate.connection.minPoolSize=1
hibernate.connection.maxPoolSize=3