最新版的SSH框整合（Spring 3.1.1 + Struts 2.3.1.2 + BoneCP + Hibernate 4.1）更新增加C3P0和EhCache配置...

最新推荐文章于 2018-05-28 14:41:41 发布
最新推荐文章于 2018-05-28 14:41:41 发布
阅读量61 收藏
点赞数
文章标签： java 运维 数据库
原文链接：https://my.oschina.net/eriloanjoan/blog/717567
版权

       最近一直有朋友在问，最新版的Spring、Struts、Hibernate整合老是有问题，昨晚大概看了一下。从Hibernate 4 开始，本身已经很好的实现了数据库事务模块，而Spring也把Hibernate4之后的HibernateDaoSupport去掉了，Spring建议使用官方的HibernateAPI进行操作。这样一来，以前习惯使用HibernateDaoSupport来操作的人来说刚刚开始可能有些不习惯。我根据官方的说明，大概的整合一下，高手可以路过，给刚上路的朋友们。


现在把主要的代码和配置贴出来，供大家参考，我本人不会发完整的项目，其它配置文件和代码和以前没有什么大变化，直接就能用，主要就是Dao。


        之前发过的几篇文章都被人转了N千次，但是我发现被转的文章都没有标明原作者，有的还把自己的大名写上去了。用我同事的一句说：“没文化真可怕！” 那些转载不留名的朋友，你们不羞愧吗？做人要厚道，转载请留名！


更新增加C3P0和EhCache配置



Web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<display-name>Eriloan_com</display-name>
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:/spring-config/applicationContext-*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<listener>
		<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
	</listener>
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>
	<listener>
		<listener-class>org.apache.struts2.dispatcher.ng.listener.StrutsListener</listener-class>
	</listener>
	<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>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<filter>
		<filter-name>struts-cleanup</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts-cleanup</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<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>
	<filter>
		<filter-name>openSessionInViewFilter</filter-name>
		<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
		<init-param>
			<param-name>sessionFactoryBeanName</param-name>
			<param-value>sessionFactory</param-value>
		</init-param>
		<init-param>
			<param-name>singleSession</param-name>
			<param-value>true</param-value>
		</init-param>
		<init-param>
			<param-name>flushMode</param-name>
			<param-value>AUTO</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>openSessionInViewFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
	<error-page>
		<error-code>404</error-code>
		<location>/WEB-INF/errorPage/404.jsp</location>
	</error-page>
	<error-page>
		<error-code>500</error-code>
		<location>/WEB-INF/errorPage/500.jsp</location>
	</error-page>
</web-app>

Spring配置文件（applicationContext-common.xml）更新增加C3P0和EhCache配置：

<?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:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
	xmlns:tool="http://www.springframework.org/schema/tool" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans.xsd
	 http://www.springframework.org/schema/tx
	 http://www.springframework.org/schema/tx/spring-tx.xsd
	 http://www.springframework.org/schema/aop
	 http://www.springframework.org/schema/aop/spring-aop.xsd
	 http://www.springframework.org/schema/jee
	 http://www.springframework.org/schema/jee/spring-jee.xsd
	 http://www.springframework.org/schema/context
	 http://www.springframework.org/schema/context/spring-context.xsd
	 http://www.springframework.org/schema/util
	 http://www.springframework.org/schema/util/spring-util.xsd
	 http://www.springframework.org/schema/tool
	 http://www.springframework.org/schema/tool/spring-tool.xsd"
	default-lazy-init="true" default-autowire="byName">

	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:/dataBaseInfo.properties</value>
			</list>
		</property>
	</bean>

	<!-- <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean" 
		p:jndiName="java:comp/env/jdbc/MySSH" /> -->

	<!-- BoneCP -->
<!-- 	<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" -->
<!-- 		p:driverClass="${jdbc.driver}" p:jdbcUrl="${jdbc.url}" p:username="${jdbc.username}" -->
<!-- 		p:password="${jdbc.password}" p:idleConnectionTestPeriodInMinutes="${bonecp.idleConnectionTestPeriodInMinutes}" -->
<!-- 		p:idleMaxAgeInMinutes="${bonecp.idleMaxAgeInMinutes}" -->
<!-- 		p:maxConnectionsPerPartition="${bonecp.maxConnectionsPerPartition}" -->
<!-- 		p:minConnectionsPerPartition="${bonecp.minConnectionsPerPartition}" -->
<!-- 		p:partitionCount="${bonecp.partitionCount}" p:acquireIncrement="${bonecp.acquireIncrement}" -->
<!-- 		p:statementsCacheSize="${bonecp.statementsCacheSize}" -->
<!-- 		p:disableConnectionTracking="${bonecp.disableConnectionTracking}" -->
<!-- 		p:releaseHelperThreads="${bonecp.releaseHelperThreads}" destroy-method="close" /> -->
		
	<!-- C3P0 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		p:driverClass="${jdbc.driver}" p:jdbcUrl="${jdbc.url}" p:user="${jdbc.username}"
		p:password="${jdbc.password}" p:acquireIncrement="${c3p0.acquireIncrement}"
		p:initialPoolSize="${c3p0.initialPoolSize}" p:minPoolSize="${c3p0.minPoolSize}"
		p:maxPoolSize="${c3p0.maxPoolSize}" p:maxIdleTime="${c3p0.maxIdleTime}"
		p:idleConnectionTestPeriod="${c3p0.idleConnectionTestPeriod}" p:maxStatements="${c3p0.maxStatements}"
		p:numHelperThreads="${c3p0.numHelperThreads}" p:checkoutTimeout="${c3p0.checkoutTimeout}" 
		destroy-method="close" />

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
		p:dataSource-ref="dataSource" p:mappingLocations="classpath*:/com/eriloan/web/**/**/bo/*.hbm.xml">
		
		<property name="hibernateProperties">
			<props>
				<!-- C3P0 方式 (此节点配置是可选项，可以不用配置，有的配置覆盖了原生的配置，只是给出可以配置的项，使用BoneCP配置的时候请注释掉) Begin-->
				<prop key="hibernate.connection.pool_size">${hibernate.connection.pool_size}</prop>
				<prop key="hibernate.c3p0.min_size">${hibernate.c3p0.min_size}</prop>
				<prop key="hibernate.c3p0.max_size">${hibernate.c3p0.max_size}</prop>
				<prop key="hibernate.c3p0.max_statements">${hibernate.c3p0.max_statements}</prop>
				<prop key="hibernate.c3p0.timeout">${hibernate.c3p0.timeout}</prop>
				<prop key="hibernate.c3p0.idle_test_period">${hibernate.c3p0.idle_test_period}</prop>
				<prop key="hibernate.c3p0.acquire_increment">${hibernate.c3p0.max_statements}</prop>				
				<!-- C3P0 方式 End-->
				
				<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.use_sql_comments">${hibernate.use_sql_comments}</prop>
				<prop key="hibernate.max_fetch_depth">${hibernate.max_fetch_depth}</prop>
				<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
				<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
				
				<!-- EhCache -->
				<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
				<prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
				<prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
				
				<prop key="hibernate.order_updates">${hibernate.order_updates}</prop>
				<prop key="hibernate.query.factory_class">${hibernate.query.factory_class}</prop>
				<prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
				<prop key="hibernate.current_session_context_class">${hibernate.current_session_context_class}</prop>
<!-- 				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> -->
			</props>
		</property>
	</bean>

	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager" />

	<bean id="transactionInterceptor"
		class="org.springframework.transaction.interceptor.TransactionInterceptor"
		p:transactionManager-ref="transactionManager">
		<property name="transactionAttributes">
			<props>
				<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="select*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>				
				<prop key="sync*">PROPAGATION_REQUIRED</prop>
				<prop key="finish*">PROPAGATION_REQUIRED</prop>
				<prop key="add*">PROPAGATION_REQUIRED</prop>
				<prop key="insert*">PROPAGATION_REQUIRED</prop>
				<prop key="edit*">PROPAGATION_REQUIRED</prop>
				<prop key="update*">PROPAGATION_REQUIRED</prop>
				<prop key="save*">PROPAGATION_REQUIRED</prop>
				<prop key="remove*">PROPAGATION_REQUIRED</prop>
				<prop key="delete*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED,-java.lang.Exception</prop>
			</props>
		</property>
	</bean>

	<bean id="ProxyCreator"
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
		p:beanNames="*Service,*ServiceImpl" p:interceptorNames="transactionInterceptor" />

	<!-- 数据库操作Bean -->
	<bean id="dao" class="dao.DaoImpl" scope="singleton" />
	
	<!-- 分页对象 -->
	<bean id="page" class="bo.PageEntity" scope="prototype" />

	<!--Service 原始Bean -->
	<bean id="baseService" class="service.BaseServiceImpl" scope="singleton" />
	
	<!--Action 原始Bean -->
	<bean id="baseAction" class="action.BaseAction" scope="prototype" />

</beans>



SpringBean配置文件（applicationContext-beans.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:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
	xmlns:tool="http://www.springframework.org/schema/tool" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans.xsd
	 http://www.springframework.org/schema/tx
	 http://www.springframework.org/schema/tx/spring-tx.xsd
	 http://www.springframework.org/schema/aop
	 http://www.springframework.org/schema/aop/spring-aop.xsd
	 http://www.springframework.org/schema/jee
	 http://www.springframework.org/schema/jee/spring-jee.xsd
	 http://www.springframework.org/schema/context
	 http://www.springframework.org/schema/context/spring-context.xsd
	 http://www.springframework.org/schema/util
	 http://www.springframework.org/schema/util/spring-util.xsd
	 http://www.springframework.org/schema/tool
	 http://www.springframework.org/schema/tool/spring-tool.xsd"
	default-lazy-init="true" default-autowire="byName" >

	<!-- Test Bean By Eric Shi -->
	<bean id="testService"
		class="com.eriloan.web.test.service.impl.TestServiceImpl"
		scope="singleton" />
	<bean id="testAction" class="com.eriloan.web.test.action.TestAction"
		scope="prototype" />

	
</beans>

Struts2 配置主配置文件（struts.xml）： 

<?xml version="1.0" encoding="UTF-8" ?>

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

<struts>
	<include file="struts-default.xml" />

	<!-- 默认的配置包 -->
	<package name="defaultPackage" extends="struts-default,json-default,jfreechart-default,spring-default">


		<global-results>
			<!-- 公用返回页面 -->
			<result name="error" type="dispatcher">/errorPage/index.jsp</result>
			<result name="login" type="dispatcher">/login.jsp</result>
			<result name="defaultLogin" type="redirect">/quitSys.jsp</result>
			<result name="loginOut" type="redirect">/loginAction!loginPage.action
			</result>
			<result name="ajaxJson" type="json">
				<param name="contentType">text/html</param>
				<param name="root">ajax_json</param>
			</result>
			<!-- 异常返回页面 -->
			<result name="actionException" type="dispatcher">/WEB-INF/errorPage/ServiceException.jsp
			</result>
			<result name="serviceException" type="dispatcher">/WEB-INF/errorPage/ServiceException.jsp
			</result>
			<result name="daoException" type="dispatcher">/WEB-INF/errorPage/ServiceException.jsp
			</result>
			<result name="exception" type="dispatcher">/WEB-INF/errorPage/ServiceException.jsp
			</result>
		</global-results>
		<!-- 异常处理 -->
		<global-exception-mappings>
			<!-- Action 层异常处理 -->
			<exception-mapping result="actionException"
				exception="system.exception.ActionException" />
			<!-- Service 层异常处理 -->
			<exception-mapping result="serviceException"
				exception="system.exception.ServiceException" />
			<!-- DAO 层异常处理 -->
			<exception-mapping result="daoException"
				exception="system.exception.DaoException" />
			<!-- 未知的系统异常，后台没有对此信息进行归类 -->
			<exception-mapping result="exception" exception="java.lang.Exception" />
		</global-exception-mappings>
	</package>
	
	<!--前台调用静态方法-->
	<!-- <constant name="struts.ognl.allowStaticMethodAccess" value="true"></constant> -->
	
	<!-- Test by Eric -->
	<include file="/struts-config/test/test_Struts.xml" />

</struts>

Struts 2业务配置文件（test_Struts.xml）： 

<?xml version="1.0" encoding="UTF-8" ?>

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

<struts>
	<package name="testPackage" extends="defaultPackage">
		<action name="testAction" class="testAction">
			<!--Test Path-->
		   <result name="gotoTestPage" type="dispatcher">/page/test/testPage.jsp</result> 		 
		</action>
	</package>
</struts>

Struts2 属性配置文件（struts.properties）： 

struts.devMode=true
struts.action.extension=action
struts.objectFactory = spring
struts.objectFactory.spring.autoWire = name
struts.objectFactory.spring.useClassCache = true
struts.objectFactory.spring.autoWire.alwaysRespect = true
struts.configuration.xml.reload=true
struts.i18n.encoding = utf-8
struts.tag.altSyntax=true
struts.custom.i18n.resources=Eriloan_Text
struts.locale=zh_CN
struts.ui.theme = simple 
struts.ognl.allowStaticMethodAccess=true
struts.multipart.maxSize=10000000000
#struts2.sslplugin.httpPort=8080
#struts2.sslplugin.httpsPort=8443
#struts2.sslplugin.annotations=true
#struts.multipart.parser=cos
#struts.multipart.parser=pell
struts.multipart.parser=jakarta
struts.multipart.saveDir=tempUpload


数据库配置文件 更新增加C3P0和EhCache配置：

#MySQL配置
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
#hibernate.dialect=org.hibernate.dialect.MySQLDialect
jdbc.url=jdbc:mysql://localhost:3306/app_eriloan?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
jdbc.driver=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=eric

hibernate.show_sql=true
hibernate.format_sql=false
hibernate.use_sql_comments=false
hibernate.cache.use_second_level_cache=false

#EhCache
hibernate.cache.use_query_cache=false
hibernate.cache.provider_class=net.sf.ehcache.hibernate.EhCacheProvider
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

hibernate.hbm2ddl.auto=update
hibernate.order_updates=true
hibernate.jdbc.batch_size=30
hibernate.jdbc.fetch_size=100
hibernate.max_fetch_depth=2

#Hibernate4 C3P0
hibernate.connection.pool_size=5
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=200
hibernate.c3p0.timeout=2000
hibernate.c3p0.idle_test_period=10
hibernate.c3p0.acquire_increment=5
hibernate.c3p0.max_statements=50

#hibernate4.0事务的模式
#1:org.hibernate.context.internal.ThreadLocalSessionContext - 当前session通过当前执行的线程来跟踪和界定。
#2:org.hibernate.context.internal.JTASessionContext - 当前session根据JTA来跟踪和界定。这和以前的仅支持JTA的方法是完全一样的。
#3:org.hibernate.context.internal.ManagedSessionContext
#4:org.springframework.orm.hibernate4.SpringSessionContext - spring的事务管理。
hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext
#Hibernate4.0的查询翻译器：
hibernate.query.factory_class=org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory
#Hibernate3.0的查询翻译器：
#hibernate.query.factory_class=org.hibernate.hql.ast.ASTQueryTranslatorFactory
#Hibernate2.1的查询翻译器
#hibernate.query.factory_class=org.hibernate.hql.classic.ClassicQueryTranslatorFactory


#Connection Pooling

#acquireIncrement: 当连接池中的连接耗尽的时候一次同时获取的连接数。Default: 3
#idleConnectionTestPeriod:检查数据库连接池中控线连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0
#idleMaxAge:连接池中未使用的链接最大存活时间，单位是分，默认值：60，如果要永远存活设置为0
#maxConnectionsPerPartition:每个分区最大的连接数
#minConnectionsPerPartition:每个分区最小的连接数
#partitionCount:分区数，默认值2，最小1，推荐3-4，视应用而定
#acquireIncrement:每次去拿数据库连接的时候一次性要拿几个，默认值：2
#statementsCacheSize:缓存prepared statements的大小，默认值：0
#releaseHelperThreads:每个分区释放链接助理进程的数量，默认值：3，除非你的一个数据库连接的时间内做了很多工作，不然过多的助理进程会影响你的性能 

#BoneCP
bonecp.minPoolSize=5
bonecp.maxPoolSize=20
bonecp.maxIdleTime=1800
bonecp.idleConnectionTestPeriodInMinutes=240
bonecp.maxStatements=0
bonecp.idleMaxAgeInMinutes=240
bonecp.maxConnectionsPerPartition=30
bonecp.minConnectionsPerPartition=5
bonecp.partitionCount=3
bonecp.acquireIncrement=5
bonecp.statementsCacheSize=50
bonecp.releaseHelperThreads=2
bonecp.disableConnectionTracking=true

#C3P0
c3p0.acquireIncrement=10
c3p0.initialPoolSize=15
c3p0.minPoolSize=30
c3p0.maxPoolSize=120
c3p0.maxIdleTime=30
c3p0.idleConnectionTestPeriod=30
c3p0.maxStatements=0
c3p0.numHelperThreads=100
c3p0.checkoutTimeout=0
c3p0.validate=true





Dao代码：


package dao;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.SessionFactory;

import system.exception.DaoException;
import bo.PageEntity;
import dao.hqlProvider.IHqlProviderSet;

/**
 * 
 * <p>Copyright: All Rights Reserved</p>
 * <p>Company: 北京新线科技发展有限公司 http://www.NewLineTech.cn</p>
 * <p>Description: Dao实现类 </p>
 * 
 * @author：Eric
 */
public class DaoImpl implements IDao{
	protected Logger log = Logger.getLogger(DaoImpl.class);

	/**
	 * Hibernate Session 工厂
	 */
	private SessionFactory sessionFactory;

	/**
	 * 
	 * <br/>Description:根据传入的实体向数据库添加一条记录
	 * 
	 * @author Eric
	 * @param obj
	 * @throws DaoException
	 */
	public void addObject(Object obj) throws DaoException{
		log.debug("BaseDao addObject object " + obj);
		try{
			sessionFactory.getCurrentSession().save(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象添加记录异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:强制刷新Hibernate缓存提交数据更改操作
	 * 
	 * @author Eric
	 * @return
	 * @version V1.0
	 */
	public void dbFlush() throws DaoException{
		log.debug("BaseDao addObject dbFlush");
		try{
			sessionFactory.getCurrentSession().flush();
		}catch(Exception e){
			throw new DaoException("刷新缓存失败，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体向数据库添加一条记录,返回插入记录的主键
	 * 
	 * @author Eric
	 * @param obj
	 * @return
	 * @throws DaoException
	 */
	public String addObjectPK(Object obj) throws DaoException{
		log.debug("BaseDao addObjectPK object " + obj);
		String id = null;
		try{
			id = (String) sessionFactory.getCurrentSession().save(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象添加记录异常，请联系管理员！",e);
		}
		return id;
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体从数据库删除一条记录
	 * 
	 * @author Eric
	 * @param obj
	 * @throws DaoException
	 */
	public void deleteObject(Object obj) throws DaoException{
		log.debug("BaseDao deleteObject object " + obj);
		try{
			sessionFactory.getCurrentSession().delete(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象删除记录异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体与ID从数据库删除一条记录
	 * 
	 * @author Eric
	 * @param cls
	 * @param id
	 * @throws DaoException
	 */
	@SuppressWarnings({"rawtypes"})
	public void deleteObject(Class cls,Serializable id) throws DaoException{
		log.debug("BaseDao deleteObject Class " + cls.getName() + " id " + id.toString());
		try{
			this.deleteObject(sessionFactory.getCurrentSession().get(cls,id));
		}catch(Exception e){
			throw new DaoException("根据传入对象与ID删除记录异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体修改数据库中一条记录
	 * 
	 * @author Eric
	 * @param obj
	 * @throws DaoException
	 */
	public void updateObject(Object obj) throws DaoException{
		log.debug("BaseDao updateObject object " + obj);
		try{
			sessionFactory.getCurrentSession().update(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象更新记录异常，请联系管理员！");
		}
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体修改数据库中一条记录,返回更新记录的主键
	 * 
	 * @author Eric
	 * @param obj
	 * @return
	 * @throws DaoException
	 */
	public String updateObjectPK(Object obj) throws DaoException{
		log.debug("BaseDao updateObjectPK object " + obj);
		String id = null;
		try{
			id = this.addObjectPK(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象更新记录异常，请联系管理员！",e);
		}
		return id;
	}

	/**
	 * 
	 * <br/>Description:根据传入的实体添加或修改数据库中一条记录
	 * 
	 * @author Eric
	 * @param obj
	 * @throws DaoException
	 */
	public void addOrUpdate(Object obj) throws DaoException{
		log.debug("BaseDao updateObjectPK object " + obj);
		try{
			sessionFactory.getCurrentSession().saveOrUpdate(obj);
		}catch(Exception e){
			throw new DaoException("根据传入对象保存数据异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据ID返回一个对象
	 * 
	 * @author Eric
	 * @param cls
	 * @param id
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings({"rawtypes"})
	public Object findObjectById(Class cls,Serializable id) throws DaoException{
		log.debug("BaseDao findObjectById Class " + cls.getName() + " id " + id.toString());
		Object obj = null;
		try{
			obj = sessionFactory.getCurrentSession().get(cls,id);
		}catch(Exception e){
			throw new DaoException("根据对象及ID查询记录异常，请联系管理员！",e);
		}
		return obj;
	}

	/**
	 * 
	 * <br/>Description:根据实体返回一个集合
	 * 
	 * @author Eric
	 * @param cls
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings({"rawtypes"})
	public List findAllData(Class cls) throws DaoException{
		log.debug("BaseDao findAllData Class " + cls.getName());
		List list = null;
		try{
			list = sessionFactory.getCurrentSession().createQuery(" from " + cls.getName() + "").list();
		}catch(Exception e){
			throw new DaoException("根据对象查询记录异常，请联系管理员！",e);
		}
		return list;
	}

	/**
	 * 
	 * <br/>Description:根据传入HQL语句返回一个集合(供DAO使用)
	 * 
	 * @author Eric
	 * @param hql
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings("rawtypes")
	public List findHQLObject(String hql) throws DaoException{
		try{
			return sessionFactory.getCurrentSession().createQuery(hql).list();
		}catch(Exception e){
			throw new DaoException("根据传入条件语句查询记录异常，请联系管理员！");
		}
	}

	/**
	 * 
	 * <br/>Description:按HQL提供者别名与条件查询集合
	 * 
	 * @author Eric
	 * @param hqlProviderSet
	 * @param queryName
	 * @param paramMap
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings("rawtypes")
	public List findListByHqlName(IHqlProviderSet hqlProviderSet,String queryName,Map paramMap) throws DaoException{
		String hql;
		try{
			hql = hqlProviderSet.getHqlByQryName(queryName);
			Query query = sessionFactory.getCurrentSession().createQuery(hql);
			if(paramMap != null){
				hqlArgs(paramMap,query);
			}

			return query.list();
		}catch(Exception e){
			throw new DaoException("按HQL提供者别名与条件查询集合异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:按HQL提供者别名、条件、分页信息查询集合
	 * 
	 * @author Eric
	 * @param hqlProviderSet
	 * @param queryName
	 * @param paramMap
	 * @param page
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings("rawtypes")
	public List findListByHqlName(IHqlProviderSet hqlProviderSet,String queryName,Map paramMap,PageEntity page) throws DaoException{
		String hql;
		try{
			hql = hqlProviderSet.getHqlByQryName(queryName);

			Query query = sessionFactory.getCurrentSession().createQuery(hql);

			if(paramMap != null){
				hqlArgs(paramMap,query);
			}

			query.setFirstResult((page.getPageNo() - 1) * page.getPageSize());
			query.setMaxResults(page.getPageSize());

			return query.list();
		}catch(Exception e){
			throw new DaoException("按HQL提供者别名、条件、分页信息查询集合异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据传入实体对象返回总记录数
	 * 
	 * @author Eric
	 * @param cls
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings("rawtypes")
	public int findIntRowCountByHqlName(Class cls) throws DaoException{
		try{
			Query query = sessionFactory.getCurrentSession().createQuery(" select count(c.id) from " + cls.getName() + " c ");
			List list = query.list();
			int rowCount = ((Number) list.get(0)).intValue();
			return rowCount;
		}catch(Exception e){
			throw new DaoException("查询记录总数异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:根据HQL提供者别名与条件查询记录总数
	 * 
	 * @author Eric
	 * @param hqlProviderSet
	 * @param queryName
	 * @param paramMap
	 * @return
	 * @throws DaoException
	 */
	@SuppressWarnings("rawtypes")
	public int findIntRowCountByHqlName(IHqlProviderSet hqlProviderSet,String queryName,Map paramMap) throws DaoException{
		String hql;
		try{
			hql = hqlProviderSet.getHqlByQryName(queryName);
			Query query = sessionFactory.getCurrentSession().createQuery(hql);
			if(paramMap != null){
				hqlArgs(paramMap,query);
			}
			List list = query.list();
			int rowCount = ((Number) list.get(0)).intValue();
			return rowCount;
		}catch(Exception e){
			throw new DaoException("执行带参数的查询记录总数异常，请联系管理员！",e);
		}
	}

	/**
	 * 
	 * <br/>Description:为Hibernate查询设置参数
	 * 
	 * @author Eric
	 * @param argsMap
	 * @param query
	 */
	@SuppressWarnings("rawtypes")
	public void hqlArgs(Map argsMap,Query query){
		Iterator itKey = argsMap.keySet().iterator();
		while(itKey.hasNext()){
			String key = (String) itKey.next();
			@SuppressWarnings("unused")
			Object obj = argsMap.get(key);
			if(argsMap.get(key) instanceof List){
				query.setParameterList(key,(List) argsMap.get(key));
			}else{
				query.setParameter(key,argsMap.get(key));
			}
		}
	}

	public SessionFactory getSessionFactory(){
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory){
		this.sessionFactory = sessionFactory;
	}
}


IHqlProviderSet实现：

public String getHqlByQryName(String queryName) throws HqlException{
		try{
			BeanWrapper bw = new BeanWrapperImpl(this);
			String hql = (String) bw.getPropertyValue(queryName);
			return hql;
		}catch(Exception e){
			throw new HqlException("HQL提供者别名生成语句失败。",e);
		}
	}



Jar包：








转载于:https://my.oschina.net/eriloanjoan/blog/717567

choucong6567
关注
最新版的SSH框整合（Spring 3.1.1 + Struts 2.3.1.2 + BoneCP + Hibernate 4.1）更新增加C3P0和EhCache配置
荣之联--史丙利(Eric Shi)
02-27 1万+
最近一直有朋友在问，最新版的Spring、Struts、Hibernate整合老是有问题，昨晚大概看了一下。从Hibernate 4 开始，本身已经很好的实现了数据库事务模块，而Spring也把Hibernate4之后的HibernateDaoSupport去掉了，Spring建议使用官方的HibernateAPI进行操作。这样一来，以前习惯使用HibernateDaoSupport来操作的人来说
最新struts2.3.1.2_+spring3.1.1_+hibernate4.1.2整合完整版
05-02
之前做android开发，现在搞一下java web的东西，发现hibernate都升到4了，整合一下三个框架，基于最新版的struts2.3.1.2_spring3.1.1_hibernate4.1.2进行整合的，网上看了很多别人的整合，好像多多少少都有点问题，...
BoneCP连接池和Ehcache注解缓存整合到Spring
12-30
代码内含BoneCp连接池和注解缓存。没有提供Spring的jar包。只要加入Spring的包就可以使用。或者只需要BoneCP和注解缓存的可以直接到lib里拿jar包。
ssh配置c3p0
菜青虫
02-10 532
1、需要引进的包：c3p0-0.9.2.jar，mchange-commons-java-0.2.3.3.jar 2、applicationContext.xml 配置 这样写也可以--> <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSour
ssh整合配置c3p0
伟大的程序员
05-28 320
applicationContext.xml中&lt;!-- 读取db.properties文件 --&gt; &lt;context:property-placeholder location="classpath:db.properties" /&gt; &lt;!-- 配置c3p0连接池 --&gt; &lt;bean name="dataSource" class="com.mchange...
ssh 中使用c3p0 的连接池配置
sd2131512的专栏
07-21 9943
applicationContext.xml 文件： <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-
Struts 2.3.1.2+Spring 3.1.1+mybatis 3.1.0 基础框架
05-04
Struts 2.3.1.2、Spring 3.1.1 和 MyBatis 3.1.0 是三个非常重要的开源框架，它们在Java Web开发中扮演着核心角色。这个基础框架组合旨在提供一个高效、灵活且可扩展的开发环境。下面将详细介绍这三个框架及其相互间...
整合SSH_Struts2.3.4.1+Spring3.1.1+Hibernate4.1.6
01-02
压缩包中包含的"整合SSH_Struts2.3.4.1+Spring3.1.1+Hibernate4.1.6+mysql.doc"文档很可能是详细的操作指南，包括每一步的配置细节、代码示例和常见问题解答。而"SSH.rar"文件则包含了整个项目的源码，包括Maven或...
struts2.3.1.2+spring3.1.1
03-30
Struts2.3.1.2与Spring3.1.1是两个经典的Java Web开发框架的版本，它们的集成在企业级应用开发中非常常见。Struts2作为MVC（模型-视图-控制器）框架，负责处理HTTP请求，提供业务逻辑的控制流，而Spring则是一个全面...
ssh 登录，模糊查询，判断重复添加数据
06-01
hibernate+struts2+spring 做的登录，模糊查询，判断重复添加数据的问题。有即时提示。登录窗口可以随意拖拽 。变幻颜色等。
最新版SSH框架（spring3.1.2+hibernate4.1.4+struts2.3.4+bonecp0.7.1）
07-17
最新版SSH框架（spring3.1.2+hibernate4.1.4+struts2.3.4+bonecp0.7.1） 使用bonecp作为数据库连接池工具 下载后可以运行，有例子，使用freemarker模板展示。
spring+hibernate+JPA+BoneCP
09-15
原创资源，码超所值，价廉物美。此项目是spring+hibernate+JPA+BoneCP的大整合。所用的技术比较多，如Spring的IOC，AOP,Transactiion,Annotation，Spring_JUnit_Test及Log4j；Hibernate的JPA Annotation；BoneCP的数据库连接测等。是很好的学习资料！
SSH整合c3p0连接池的配置
大漠孤烟
10-14 207
1.Hibernate3 已经取消了对DBCP的支持，原因是当DBCP连接因为某个原因断掉后，不会自动重新连接，必须重启服务器。 2.在dbcp方式的连接池下，如果有下面的代码，数据不会保存到数据库 &lt;property name="defaultAutoCommit"&gt; &lt;value&gt;false&lt;/value&gt; &lt;/property&gt; ...
关于SSH框架插入N条数据
12-31 203
有一个Excel文件，要读取里面的每一条记录，有很多条，并把记录保存到数据库中。 应该在Action中直接调用service保存还是在service中保存。 事务边界在service 如果在Action中保存，每次都要开启一个事务，是不是会影响效率？但是在service中的话要是有一条出现问题就全部回滚了，不知该如何处理，有什么好的解决方案吗
SSH+Activiti 整合（Spring 3.1.1 + Struts 2.3.3 + BoneCP 0.7.1 + Hibernate 4.1.4 + Activiti 5.9）
编程资料大全
06-09 129
最近项目要用到工作流，所以考察了一下现在的开源工作流引擎，最终考虑在原SSH框架上整合Activiti 工作流引擎。还是那句话请转载的人注明出处，不要做让人看不起的IT人。 多的不说了，本版只提供配置文件，其它部分文件代码可能参考我写的新版SSH整合一文。 applicationContext-common.xml &lt;?xml version="1.0" encodin...
spring + hibernate4 + BoneCP 配置
cppsoldier2006的博客
07-19 179
[size=medium]BoneCP(http://www.jolbox.com/) 号称是最快的java数据库连接池，我们项目中使用的就是它。其与spring，hibernate4的配置如下所示： ...
ssh转账时,插入两条数据进表,并更新数据
czc103的博客
08-06 448
ssh
SpringMVC+Mybatis+Maven+Bonecp+EclipseSTS
arthur.dy.lee的专栏
09-26 2391
SpringMVC+Mybatis+Maven+Bonecp+EclipseSTS
SpringMVC 3.1.1 + Hibernate 4.1.0 整合实战与关键技术
如Hibernate Release 4.1.0 Final、Hibernate Validator 4.2.0 Final、Spring Framework 3.1.1 with Docs、Proxool、Log4j 1.2.16、SLF4J 1.6.1等，以及MySQL Connector-J 5.1.10、Hamcrest 1.3.0 RC2和Ehcache ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值