Spring2.5.3+Struts2.0.11.1+Hibernate3.2.6整合备忘

Php、Rails等众多web开发框架，使开发者的眼睛眼花缭乱。一时间我们不知道到底该选择哪些技术手段才能够使我们能够用最少的资源完成最多的事情。再怎样去选择，始终无法将Java抛弃和忘却，毕竟是最熟悉和最有感情的语言工具。因为工作需要采用Spring2.5.3+Struts2.0.11.1+Hibernate3.2.6去完成一个项目，在这里，把环境组合搭建的流程和思路记录下来以做备忘，给相关的朋友提供一个简单的参考。

我们需要分享，才能逐步提高我们的技术水平和综合能力。

开发环境：Eclipse3.2/MyEclipse5.1/jdk5(Myeclipse默认)/tomcat5.5/MySQL

一、配置管理
之所以第一处说明，我认为这是一个很关键的地方。对于系统配置文件的管理，能够为系统以后扩展提供极大的方便。
参考资料：若干条J2EE应用中运用“配置”的最佳实践：http://www.iteye.com/topic/185542
1、项目结构图


源文件夹conf，存储系统所有的配置文件，使系统文件能够得到集中的管理，这种思路为系统的维护和扩展，在配置文件管理方面提供了有力的支持。使你可以容易的维护个人负责的模块、方便的增加新的模块配置文件而对系统不产生影响。

1)web.xml
整个应用的配置，无需多说。

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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">

	<description>Create Soft Dep products : cssi v2.0</description>

	<!-- 加载Srping配置文件 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath*:context/applicationContext-config.xml</param-value>
	</context-param>

	<!-- Ajax 标签配置 -->
	<context-param>
		<param-name>AjaxPartsTaglibConfig</param-name>
		<param-value>/WEB-INF/ajax_config.xml</param-value>
	</context-param>
	<context-param>
		<param-name>AjaxPartsTaglibValidateConfig</param-name>
		<param-value>false</param-value>
	</context-param>

	<!-- 配置Struts2过滤器 -->
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<!-- 字符集过滤 -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>

	<!-- 启动Spring -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 防止内存泄露 -->
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>

	<!-- 会话超时 5分钟 -->
	<session-config>
		<session-timeout>5</session-timeout>
	</session-config>

	<!-- 默认启动 -->
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

由于conf是源文件夹，Eclipse会自动把其下文件资源编译到 WEB-INF/classes文件夹下，因此，在web.xml中的这一句classpath*:context/applicationContext-config.xml，指定Spring配置文件的路径是在context目录下。通常我们的系统设计可能会采用模块独立的Spring配置文件，那么为什么再这里只加载一个Spring配置文件？如何扩展模块配置文件？下面看一下applicationContext-config.xml的内容

2)context/applicationContext-config.xml
Spring总配置文件，负责加载各个应用模块的配置

<?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: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-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<import resource="applicationContext-dataAccess.xml" />

	<!-- 通用bean定义 -->
	<bean id="baseDAO" class="cn.createsoft.dao.impl.hibernate.BaseDAOHibernateImpl">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	
	<!-- 加载其他Service/modu等配置文件 -->
	<import resource="classpath*:service/*/applicationContext-*.xml" />

</beans>

可以看到：
1> <import resource="applicationContext-dataAccess.xml" /> 这句，是加载数据访问配置文件
2> <import resource="classpath*:service/*/applicationContext-*.xml" /> 这句，是加载所有在classpath下，service目录下，所有子目录的配置文件。为了便于管理，各个模块的配置文件采用独立的文件夹管理，通过这样的配置，我们可以在Service下方便的增加和维护模块配置，而不会造成一个配置文件多人修改的烦人的场面了。
3> 一个子模块的配置的例子
service/user/applicationContext-user.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: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-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<bean id="userDAO" class="cn.createsoft.user.dao.impl.UsersDAOHibernateImpl" parent="baseDAO"></bean>

	<!-- 声明用户模块Action -->
	<bean id="userAction" class="cn.createsoft.user.web.actoin.UserAction">
		<property name="userDAO" ref="userDAO"></property>
	</bean>

	<!-- 声明登陆Action -->
	<bean id="loginAction" class="cn.createsoft.user.web.actoin.LoginAction">
		<property name="userDAO" ref="userDAO"></property>
	</bean>

	<!-- 声明登陆验证拦截器 -->
	<bean id="loginInterceptor" class="cn.createsoft.user.interceptor.LoginedInterceptor"></bean>

</beans>

3)applicationContext-dataAccess.xml
数据库访问配置文件(采用C3P0连接池)

<?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: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-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 加载属性文件 -->
	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath*:context/jdbc.properties</value>
			</list>
		</property>
	</bean>

	<!-- 使用C3P0数据库连接池进行数据源的配置 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
		<property name="driverClass">
			<value>${datasource.driverClassName}</value>
		</property>
		<property name="jdbcUrl">
			<value>${datasource.url}</value>
		</property>
		<property name="user">
			<value>${datasource.username}</value>
		</property>
		<property name="password">
			<value>${datasource.password}</value>
		</property>
		<property name="acquireIncrement">
			<value>${c3p0.acquireIncrement}</value>
		</property>
		<property name="initialPoolSize">
			<value>${c3p0.initialPoolSize}</value>
		</property>
		<property name="minPoolSize">
			<value>${c3p0.minPoolSize}</value>
		</property>
		<property name="maxPoolSize">
			<value>${c3p0.maxPoolSize}</value>
		</property>
		<property name="maxIdleTime">
			<value>${c3p0.maxIdleTime}</value>
		</property>
		<property name="idleConnectionTestPeriod">
			<value>${c3p0.idleConnectionTestPeriod}</value>
		</property>
		<property name="maxStatements">
			<value>${c3p0.maxStatements}</value>
		</property>
		<property name="numHelperThreads">
			<value>${c3p0.numHelperThreads}</value>
		</property>

	</bean>

	<!-- 根据上面暴露的数据源配置定义Hibernate SessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
				<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
				<prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>
				<prop key="hiberante.autoReconnect">${hiberante.autoReconnect}</prop>
			</props>
		</property>
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath*:context</value>
				<value>classpath*:persistent</value>
			</list>
		</property>
	</bean>

	<!-- 配置事务管理器bean,使用HibernateTransactionManager事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<!-- 为事务管理器注入sessionFactory" -->
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<!--
		
		
		<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
		<tx:method name="get*" read-only="true" rollback-for="Exception" />
		<tx:method name="save*" read-only="false" />
		</tx:attributes>
		</tx:advice>
		
		<aop:config proxy-target-class="true">
		<aop:advisor pointcut="execution(* *.*.*(..))" advice-ref="txAdvice" />
		</aop:config>
		
		
	--><!-- 配置事务拦截器Bean -->
	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
		<!-- 为事务拦截器bean注入一个事物管理器 -->
		<property name="transactionManager" ref="transactionManager"></property>
		<property name="transactionAttributes">
			<!-- 定义事务传播属性 -->
			<props>
				<prop key="insert*">PROPAGATION_REQUIRED</prop>
				<prop key="update*">PROPAGATION_REQUIRED</prop>
				<prop key="save*">PROPAGATION_REQUIRED</prop>
				<prop key="add*">PROPAGATION_REQUIRED</prop>
				<prop key="update*">PROPAGATION_REQUIRED</prop>
				<prop key="remove*">PROPAGATION_REQUIRED</prop>
				<prop key="delete*">PROPAGATION_REQUIRED</prop>
				<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="change*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
			</props>
		</property>
	</bean>

</beans>

数据库相关配置由一个jdbc.properties定义，当然我们也可以直接写进这个文件当中，看个人的习惯了。

4)jdbc.properties
数据库配置

#定义数据库连接属性
datasource.type=mysql
datasource.driverClassName=com.mysql.jdbc.Driver
#datasource.driverClassName=oracle.jdbc.driver.OracleDriver
datasource.url=jdbc:mysql://localhost:3306/productsi_test?useUnicode=true&characterEncoding=UTF-8
#datasource.url=jdbc:oracle:thin:@localhost:1521:SID

datasource.username=root
datasource.password=root

datasource.maxActive=10
datasource.maxIdle=2
datasource.maxWait=120000
datasource.whenExhaustedAction=1
datasource.validationQuery=select 1 from dual
datasource.testOnBorrow=true
datasource.testOnReturn=false

#c3p0数据库连接池配置
c3p0.acquireIncrement=2
c3p0.initialPoolSize=3
c3p0.idleConnectionTestPeriod=18000
c3p0.minPoolSize=2
c3p0.maxPoolSize=20
c3p0.maxStatements=100
c3p0.numHelperThreads=10
c3p0.maxIdleTime=25000


#hibernate属性配置
hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
hibernate.jdbc.batch_size=25
hibernate.jdbc.fetch_size=50
hibernate.show_sql=true
hibernate.connection.release_mode=after_transaction
hiberante.autoReconnect=true
hibernate.connection.release_mode=auto

5)Struts.xml

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

	<!-- 加载各个模块的配置文件 -->
	<include file="struts-default.xml"></include>
	
	<constant name="struts.devMode" value="true" />
	
	<package name="default" extends="struts-default" namespace="/">

		<interceptors>
			<!-- 检查用户是否登陆 -->
			<interceptor name="login" class="loginInterceptor"></interceptor>
			<!-- 检查是否有权限访问改模块 -->

			<!-- 拦截器堆栈 -->
			<interceptor-stack name="AuthorizatedInterceptor">
				<interceptor-ref name="login" />
			</interceptor-stack>

		</interceptors>

		<!-- 定义全局返回值 -->
		<global-results>
			<result name="login" type="redirect-action">tologin</result>
			<result name="error">/error.jsp</result>
		</global-results>

		<!-- 进入登陆页面 -->
		<action name="tologin" class="loginAction" method="tologin">
			<result>/login.jsp</result>
		</action>

		<!-- 用户登陆 -->
		<action name="login" class="loginAction" method="login">
			<result>/welcome.html</result>
		</action>
		
		<action name="test" class="loginAction" method="test">
		</action>

	</package>

	<include file="/service/user/struts-user.xml"></include>

</struts>

将Struts的所有Action或其他bean交由Spring来管理，在相关Spring配置文件中，声明(见：applicationContext-user.xml中bean的声明)，在相关Struts配置文件中，action标签中，属性class的值是Spring声明的bean id即可。

在配置过程中，唯一让我遗憾的是，struts配置文件，好像不和spring一样，支持如classpath*:的路径声明。根据模块自立的原则，每个子模块应该拥有自己的Struts配置文件，那么就需要在Struts.xml当中加载，如：<include file="/service/user/struts-user.xml"></include>，无论我怎么试，Struts.xml必须放在classes跟目录下，不能放在classpath的子目录中，配置子模块也只能在struts.xml中手动的增加，
否则配置不成功。不过，作为统一的Struts配置文件内容，是否智能加载模块配置，影响也不大。这里也请有经验的朋友给予指点。


6)struts.properties
配置文件，不再多说

struts.tag.altSyntax=true
struts.devMode=true
### These can be used to set the default HTTP and HTTPS  ports    
struts.url.http.port=80
#webwork.url.https.port = 443   
   
### This can be used to set your locale and encoding scheme    
struts.custom.i18n.resources=ApplicationResources
struts.locale=zh_CN
struts.i18n.encoding=utf-8
   
# uses javax.servlet.context.tempdir by default    
struts.multipart.parser=com.opensymphony.webwork.dispatcher.multipart.PellMultiPartRequest    
#struts.multipart.saveDir=tmp   
struts.multipart.saveDir=/tmp
struts.multipart.maxSize=512000000
struts.configuration.xml.reload=true
   
struts.objectFactory=spring

类库图：

评论

5 楼 黑暗浪子 2009-10-19  

有一个问题：
可否把所有applicationContext-*.xml和applicationContext-config.xml放在context文件夹下？
这样在applicationContext-config.xml中代码可写成
<import resource="classpath*:context/applicationContext-*.xml" />
我试了一下，action里的dao内始终是nullpoint异常啊。

why？why？why？why？why？

4 楼 gmingsoft04 2008-09-19  

你好,看了你的BASEDAO ,好象是在hibernate syn工具自动生成的BASEDAO基础上修改的,方法命名很规范,而且还带分页程序,能不能把cn.createsoft.common.pagination.PageControlBean这个PageControlBean类以及怎么在JSP调用中用这个类呢也贴出来啊  我写程序到现在为止,还没试过分页呢.请大哥赐教.我将会受用不尽.谢谢了.真的很渴望有通俗易懂又易用的分页程序啊.

3 楼 单身男人 2008-08-06  

呵呵，不好意思，最近工作比较忙，一直没有上来看看：）BaseDAO只是提供了通用的一些数据操作方法，可以看看我的源码,每个人的设计思路不同，采用DAO或者抽象类来实现类似功能

/**

 * UpdateDAO.java

 * created by 2008-4-29 下午05:54:03

 */

package cn.createsoft.dao;



import java.io.Serializable;

import java.util.List;



import org.springframework.orm.hibernate3.HibernateTemplate;



import cn.createsoft.common.pagination.PageControlBean;



/**

 * @author hjf

 * 

 */

public interface BaseDAO {



	/**

	 * 保存数据对象

	 * 

	 * @param object

	 */

	public void save(Object arg0);



	/**

	 * 更新对象

	 * 

	 * @param arg0

	 */

	public void update(Object arg0);



	/**

	 * 用语句更新对象

	 * 

	 * @param hql

	 *            带参数的hql语句，如：update Object t where t.name = ? and t.id = ?

	 * @param parameters

	 *            参数值数组，与hql中的?号对应 参数

	 */

	public void update(String hql, Object[] parameters);



	/**

	 * 删除对象

	 * 

	 * @param arg0

	 */

	public void delete(Object arg0);



	/**

	 * 删除对象

	 * 

	 * @param clazz

	 *            对象类型

	 * @param id

	 *            对象id

	 */

	public void delete(Class clazz, Serializable id);



	/**

	 * 用语句删除对象

	 * 

	 * @param hql

	 *            带参数的hql语句，如：delete Object t where t.name = ? and t.id = ? 查询语句

	 * @param parameters

	 *            参数值数组，与hql中的?号对应 参数

	 */

	public void delete(String hql, Object[] parameters);



	/**

	 * 根据类型删除全部对象

	 * 

	 * @param clazz

	 * @return 删除的对象数

	 */

	public void deleteAll(Class clazz);



	/**

	 * 根据对象类型和id加载一个对象，对于经常用到的对象推荐使用此方法。load方法会在2个级别的缓存查找对象后，再去数据库查找记录

	 * 

	 * @param clazz

	 * @param id

	 * @return 如果数据库没有记录，则会抛出ObjectNotFoundException异常， 有则返回一个对象的代理

	 */

	public Object load(Class clazz, Serializable id);



	/**

	 * 根据对象类型和id加载一个对象

	 * 

	 * @param clazz

	 * @param id

	 * @return 如果数据库没有记录，则会返回null对象

	 */

	public Object get(Class clazz, Serializable id);



	/**

	 * 根据查询语句和参数得到一个对象

	 * 

	 * @param hql

	 *            带参数的hql语句，如：selete * from Object t where t.username = ? and

	 *            t.password = ? 查询语句

	 * @param parameters

	 * @return 如果没有符合条件的则返回null

	 */

	public Object get(String hql, Object[] parameters);



	/**

	 * 查询对象

	 * 

	 * @param query

	 *            查询hql语句

	 * @return

	 */

	public List find(final String query);



	/**

	 * 查询对象

	 * 

	 * @param query

	 *            带参数的查询语句

	 * @param parameter

	 *            参数值列表

	 * @return

	 */

	public List find(String query, Object parameter);



	/**

	 * 外置命名查询

	 * 

	 * @param namedQuery

	 * @return

	 */

	public List findByNamedQuery(String namedQuery);



	/**

	 * 外置命名查询

	 * 

	 * @param query

	 * @param parameter

	 * @return

	 */

	public List findByNamedQuery(String query, Object parameter);



	/**

	 * 外置命名查询

	 * 

	 * @param query

	 * @param parameters

	 * @return

	 */

	public List findByNamedQuery(String query, Object[] parameters);



	/**

	 * 查询全部对象

	 * 

	 * @param clazz

	 * @return

	 */

	public List findAll(Class clazz);



	/**

	 * 返回HQL语句查询结果从第startIndex开始的count条记录

	 * 

	 * @param hql

	 *            查询语句

	 * @param startIndex

	 *            每页的第一条记录。第一页的第一条记录为0

	 * @param count

	 *            每页的记录条数

	 * @return 查询某一页的结果

	 */

	public List getObjects(String hql, int startIndex, int count);



	/**

	 * 返回HQL语句查询结果

	 * 

	 * @param hql

	 * @param bean

	 * @return

	 */

	public List getPagiationObjects(String hql, PageControlBean bean);



	/**

	 * 得到HibernateTemplate对象

	 * 

	 * @return

	 */

	public HibernateTemplate getHibernateTemplate();

}

2 楼 kikumail 2008-07-27  

大哥你好,反复看了你的整合方法,越看越觉得不错.但是有一点不太明白,你的baseDAO是如何实现的,能贴出来看一下吗?谢谢

1 楼 kikumail 2008-06-09  

好复杂，能不能把src目录贴出来