本文基于SPRING2.56,HIBERANTE3.25及Oracle10g classes14.jar驱动,介绍SPRING与HIBERNATE是如何配合的细节,如SESSION、 事务、数据库连接何时打开与关闭;如果调用不是发自请求,不经过FILTER(如定时器对SERVICE调用),如何做到从头到尾只用一个SESSION? 此时SESSION需不需要手动关闭?从SESSION取得的数据库连接需不需要关闭, 看完本文,你会清楚里面每一个细节。
两种访问系统的路径:
1、request-->filters(spring and struts)-->actions-->AOP(transaction)-->services-->dao-->db
2、timer(run)->AOP(transaction)-->services-->dao-->db
下面是调用链的图示
在WEB.XML配置了OpenSessionInViewFilter,整个请求只用一个SESSION,
在ACTION与SERVICE之间使用SPRING的AOP配置事务拦截器,所以事务范围涵盖整个SERVICE的方法调用,
DAO中一般使用SPRING的HibernateTemplate对象操作数据库
首先看OpenSessionInViewFilter在web.xml和事务拦截器相关配置
Xml代码
复制代码
- <!--web.xml-->
- <filter>
- <filter-name>openSessionInViewFilter</filter-name>
- <filter-class>
- org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
- </filter-class>
- <init-param>
- <param-name>singleSession</param-name>
- <param-value>true</param-value>
- </init-param>
- </filter>
-
- /////SRPING配置文件中事务拦截器相关配置
- <!-- hibernate 事务管理者 -->
- <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
- <property name="sessionFactory" ref="sessionFactory"></property>
- </bean>
- <!-- hibernate 事务拦截器 -->
- <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
- <!-- 注入事务管理者 -->
- <property name="transactionManager" ref="transactionManager" />
- <property name="transactionAttributes">
- <!-- 定义事务属性-->
- <props>
- <prop key="*">PROPAGATION_REQUIRED</prop>
- <prop key="insert*">PROPAGATION_REQUIRED</prop>
- <prop key="add*">PROPAGATION_REQUIRED</prop>
- <prop key="save*">PROPAGATION_REQUIRED</prop>
- <prop key="update*">PROPAGATION_REQUIRED</prop>
- <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
- <prop key="search*">PROPAGATION_REQUIRED,readOnly</prop>
- <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
- <prop key="noTran*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
- </props>
- </property>
- </bean>
- /////配置service自动代理
- <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
- <property name="beanNames">
- <!-- 代理所有Service -->
- <list>
- <value>*Service</value>
- </list>
- </property>
- <property name="interceptorNames">
- <list>
- <value>transactionInterceptor</value>
- </list>
- </property>
- </bean>
|
//下面从FILTER开始分析代码
Java代码
复制代码
- //这是OpenSessionInViewFilter类的方法,请求到来时,此方法由父类OncePerRequestFilter的doFilter()方法调用,
- protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
- throws ServletException, IOException {
-
- //取得SessionFactory实例,实际上就是调用WebApplicationContext.getBean("beanName"),
- SessionFactory sessionFactory = lookupSessionFactory(request);
- //在lookupSessionFactory方法里看到原来此FILTER还支持配置sessionFactory为的名字,默认就叫sessionFactory,如果想改成其它名字具体配置方式:
- //在web.xml中,<init-param><param-name>sessionFactoryBeanName</param-name><param-value>sessionFactory</param-value></init-param>
-
- //此次调用有无打开SESSION,有的话在finally块关闭
- boolean participate = false;
- //是否单SESSION模式(上文web.xml中配置了),注意这并不意味着每个请求只用一个connection,下文详解
- if (isSingleSession()) {//这里我只分析单SESSION的情况,因为另一种情况不是此filter推荐的用法,就懒得看了
- // 单SESSION模式
-
- // 是否已经打开了SESSION,一般来说每个请求一开始是没有打开的,除非在打开SESSION之后进行forward跳转并再次被拦截
- if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
- participate = true;
- }
- else {
- logger.debug("Opening single Hibernate Session in OpenSessionInViewFilter");
- //打开session,注意想在整个请求内部都用SESSION,这一句还不够,还必须有下面一句。getSession方法如何打开SESSION接下来讲解
- Session session = getSession(sessionFactory);
- //把SESSION放入SessionHolder,再用sessionFactory作为KEY,SessionHolder作为VALUE放入MAP,再把此MAP放入ThreadLocal
- //------不熟ThreadLocal看这,其他人跳过,ThreadLocal有两个主要的方法,get()和set(value),用法和MAP差不多,只是不需要提供KEY,
- //KEY就是当前线程,这样对于每个线程,只能往ThreadLocal里放入一个对象,在此放入了一个MAP。
- //不同的线程可以同时操作这个ThreadLocal对象,放入内容,因为各自有着不同的KEY------//
- TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
- }
- }
- else {//非单Session模式,本文不讨论此情况
- // deferred close mode
- if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
- // Do not modify deferred close: just set the participate flag.
- participate = true;
- }else {
- SessionFactoryUtils.initDeferredClose(sessionFactory);
- }
- }
-
- try {//SESSION已打开,往下调用,-->action-->aop-->service-->dao-->db
- filterChain.doFilter(request, response);
- }
-
- finally {//目标调用完成,关闭SESSION
- if (!participate) {//如果上文打开了SESSION
- if (isSingleSession()) {
- //从ThreadLocal里面把上面放入的MAP移除
- SessionHolder sessionHolder =
- (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
- logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
- //关闭SESSION
- closeSession(sessionHolder.getSession(), sessionFactory);
- }
- else {
- // deferred close mode
- SessionFactoryUtils.processDeferredClose(sessionFactory);
- }
- }
- }
- }
|
getSession方法
Java代码
复制代码
- //OpenSessionInViewFilter类,还是上面那个FILTER类
- protected Session getSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
- //取SESSION,下文讲解
- Session session = SessionFactoryUtils.getSession(sessionFactory, true);
- //设置提交方式,getFlushMode默认返回FlushMode.NEVER,
- //NEVER看名字好像是永不提交,其实是外部显式调用FLUSH时才提交的意思,也许是因为名字不好,此变量已过时了,新的名字是FlushMode.MANUAL
- //如果请求是写操作,会在打开事务时被改成AUTO,
- FlushMode flushMode = getFlushMode();
- if (flushMode != null) {
- session.setFlushMode(flushMode);
- }
- return session;
- }
|
SessionFactoryUtils.doGetSession方法
Java代码
复制代码
- //SessionFactoryUtils类,取SESSION,此工具方法在以下两种情况被调用:在FILTER层开SESSION和在DAO层取SESSION去查数据库
- //在FILTER层调用时,没有事务(执行此方法的后半部份),在DAO层调用时,由于经过了AOP,开启了事务(执行方法的前半部份)
- //在没有JTA事务的环境中,此方法只是打开或取得一个SESSION,关于事务的事什么也没有做。
- private static Session doGetSession(
- SessionFactory sessionFactory, Interceptor entityInterceptor,
- SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)
- throws HibernateException, IllegalStateException {
-
- Assert.notNull(sessionFactory, "No SessionFactory specified");
- //上文放入的sessionHolder在这里被取出来,如果调用来源于FILTER,则还没有放入,取出空,如果DAO层的调用,那么就不为空了
- SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
- ///--------------前半部份-------------------//////////////
- if (sessionHolder != null && !sessionHolder.isEmpty()) {// DAO中的调用,取得非空值,
- Session session = null;
-
- //如果:事务是否已开始 && sessionHolder中没有SESSION或只有一个默认SESSION
- if (TransactionSynchronizationManager.isSynchronizationActive() &&
- sessionHolder.doesNotHoldNonDefaultSession()) {
- //取出SESSION,里面主要判断一下SESSION有没有被关闭
- session = sessionHolder.getValidatedSession();
- //session不为空 && 事务没有开始,
- if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {
- //在AOP中开始事务时,会将这个标志设为真,所以这里不会被执行,至少我还没有发现哪一次执行经过这里了
- logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");
- TransactionSynchronizationManager.registerSynchronization(//注册一个SESSION
- new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));
- sessionHolder.setSynchronizedWithTransaction(true);
- // 取出当前SESSION的提交方式
- FlushMode flushMode = session.getFlushMode();
- if (flushMode.lessThan(FlushMode.COMMIT) &&
- !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
- //如果是小于COMMIT,就是NEVER,那么改成自动
- session.setFlushMode(FlushMode.AUTO);
- //设置之前的提交模式
- sessionHolder.setPreviousFlushMode(flushMode);
- }
- }
- }
- else {//这里也是一般都不会被执行,因为AOP中已经开启了事务
- // No Spring transaction management active -> try JTA transaction synchronization.
- session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);
- }
- if (session != null) {
- return session;
- }
- }
- ////////-------------------后半部份--------------------------
-
- //来自FILTER的调用,一般sessionHolder为空(同一请求forward后被再次拦截就不会空,执行不到这里),
- logger.debug("Opening Hibernate Session");
- //调用HIBERNATE打开SESSION
- Session session = (entityInterceptor != null ?
- sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());
-
- // 当前请求是否已开启事务,FILTER中的调用,还没有到AOP层,事务没有打开,一般会执行ELSE
- if (TransactionSynchronizationManager.isSynchronizationActive()) {
- // We're within a Spring-managed transaction, possibly from JtaTransactionManager.
- logger.debug("Registering Spring transaction synchronization for new Hibernate Session");
- SessionHolder holderToUse = sessionHolder;
- if (holderToUse == null) {
- holderToUse = new SessionHolder(session);
- }
- else {
- holderToUse.addSession(session);
- }
- if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
- session.setFlushMode(FlushMode.NEVER);
- }
- TransactionSynchronizationManager.registerSynchronization(
- new SpringSessionSynchronization(holderToUse, sessionFactory, jdbcExceptionTranslator, true));
- holderToUse.setSynchronizedWithTransaction(true);
- if (holderToUse != sessionHolder) {
- TransactionSynchronizationManager.bindResource(sessionFactory, holderToUse);
- }
- }
- else {
- // 上面没有找到事务,从sessionFactory中找,如果sessionFactory有配置JTA事务,则注册事务
- // 本文也没有配置JTA事务,所以里面什么也没有干,还是没有注册事务
- registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);
- }
-
- // 如果不自动创建 && sessionHolder中没有session,则关闭SESSION
- if (!allowCreate && !isSessionTransactional(session, sessionFactory)) {
- closeSession(session);
- throw new IllegalStateException("No Hibernate Session bound to thread, " +
- "and configuration does not allow creation of non-transactional one here");
- }
- //到此就在FILTER中取得了(或者说打开了)SESSION,下面就从ACTION调用SERVICE这一节了。
- return session;
- }
|
//下面开始到了ACTION的操作,action调用service,此service实际上是Spring动态生成的代理类,此代理类调用
//目标SERVICE类对应的方法前,要经过AOP拦截,下面我们对ACTION到SERVICE这中间经过的所有类方法代码分析一遍。
//我的应用在AOP层配置了一个事务拦截器,所以这中间的代码主要操作事务相关。
//动态生成的代理类代码看不到,从动态代理类下面的那个类(JdkDynamicAopProxy)开始吧
Java代码
复制代码
- //JdkDynamicAopProxy类,此方法被动态代理类调用
- //参数说明:proxy动态代理类对象,method目标方法,args目标方法参数
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- MethodInvocation invocation = null;
- Object oldProxy = null;
- boolean setProxyContext = false;
-
- //targetSource对象包含目标SERVICE对象
- TargetSource targetSource = this.advised.targetSource;
- Class targetClass = null;
- Object target = null;
-
- try {
- //如果目标类没有重载equals方法 && 目前正在调用目标类的equals方法,那直接调本类重载方法,
- //这样就不需要再往下走,不需要再开启事务等等多余的操作以至于浪费性能了,下面的几个IF都是做类似的事
- if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
- // The target does not implement the equals(Object) method itself.
- return (equals(args[0]) ? Boolean.TRUE : Boolean.FALSE);
- }
- if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
- // The target does not implement the hashCode() method itself.
- return new Integer(hashCode());
- }
- if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
- method.getDeclaringClass().isAssignableFrom(Advised.class)) {
- // Service invocations on ProxyConfig with the proxy config...
- return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
- }
-
- Object retVal = null;
-
- //ProxyConfig类的exposeProxy属性,表示是否要将当前的代理对象放入AopContext中,
- //这样在你的Service中可以用AopContext.currentProxy()取得当前代理,相当于this引用,
- //不同于this引用的是,调用当前代理会被AOP拦截,而this不会。
- //此属性默认为FALSE,如果要打开,
- //在BeanNameAutoProxyCreator等代理类BEAN的配置中加入<property name="exposeProxy" value="true" />
- if (this.advised.exposeProxy) {
- // Make invocation available if necessary.
- oldProxy = AopContext.setCurrentProxy(proxy);
- setProxyContext = true;
- }
-
- // 取得目标(真实SERVICE对象)
- target = targetSource.getTarget();
- if (target != null) {
- targetClass = target.getClass();
- }
-
- // 取得所有拦截器
- List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
-
- // 如果没有拦截器
- if (chain.isEmpty()) {
- // 直接调用目标
- retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
- }
- else {//有拦截器
- // 创建一个调用器对象
- invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
- // 通过调用器往下调用目标或第一个拦截器
- retVal = invocation.proceed();
- }
-
- // 调用的返回结果目标类对象本身,就把它替换成代理类对象
- if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
- !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
- retVal = proxy;
- }
- return retVal;
- }
- finally {//释放资源
- //主要是从当前线程清除代理类对象
- if (target != null && !targetSource.isStatic()) {
- targetSource.releaseTarget(target);
- }
- if (setProxyContext) {
- // Restore old proxy.
- AopContext.setCurrentProxy(oldProxy);
- }
- }
- }
|
递归调用拦截器
Java代码
复制代码
- //ReflectiveMethodInvocation类,上面执行retVal = invocation.proceed();就进入到了这个方法
- //这个方法主要是递归调用各个拦截器,最后调用目标类
- public Object proceed() throws Throwable {
- // 判断是否还有拦截器要调用,
- if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
- //没有拦截器了,调用目标
- return invokeJoinpoint();
- }
-
- //取出拦截器
- Object interceptorOrInterceptionAdvice =
- this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
-
- //判断拦截器型,对不同类型的调用方法不一样,SPRING事务拦截器TransactionInterceptor是MethodInterceptor实现类,
- //不属于InterceptorAndDynamicMethodMatcher,执行ELSE
- if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
- InterceptorAndDynamicMethodMatcher dm =
- (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
- if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
- return dm.interceptor.invoke(this);
- }
- else {//方法匹配失败,跳过,继续递归
- return proceed();
- }
- }
- else {
- // 调用事务拦截器等,MethodInterceptor--林信良的SPRING手册介绍过个这接口如何使用
- return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
- }
- }
|
事务拦截器
Java代码
复制代码
- //TransactionInterceptor--SPRING的事务拦截器实现类,这个方法可以根据事务管理器的种类分类if和else上下两部分,
- //如果配置的是org.springframework.orm.hibernate3.HibernateTransactionManager等非CallbackPreferringPlatformTransactionManager接口实现类
- //则看只需要看if部份
- //了解这里工作原理很重要:
- //1、如果是请求发起的调用,流程路线为--FILTER打开Session,并且绑定到了线程信息中(TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session))),
- //在此方法里标志为旧SESSION,开始事务,调用目标,提交或回滚事务,判断如果是旧SESSION,则事务结束释放连接但不关闭SESSION,如果还用此SESSION再开启事务,再绑定另外的连接(所以上文说单SESSION并不等于同一个连接),最后在FILTER关闭SESSION。
- //2、如果不是请求发起的调用,如计划任务Timer.schedule(...)发起的SERVICE调用,流程为--在此方法打开SESSION,标志为新连接,开启事务,调用目标,提交或回滚事务,释放数据库连接,判断如果是新SESSION,则关闭SESSION。
- //总结如下:
- //1、只要有配置了此事务拦截器,底层使用SPRING的HibernateTemplate.getSession()或其提供的各种查询,那么SESSION和数据库连接的关闭不需要你操心。
- //2、如果要在Timer的run方法中多次调用SERVICE时,也要实现OpenSessionInViewFilter这样的效果,那么使用如这句,结束时要记得自已关闭SESSION。
- //打开SESSION后:TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
- //最后关闭SESSION:
- //SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory());
- //SessionFactoryUtils.closeSession(sessionHolder.getSession());
- public Object invoke(final MethodInvocation invocation) throws Throwable {
- // 取得目标类名
- Class targetClass = (invocation.getThis() != null ? invocation.getThis().getClass() : null);
-
- // 通过类名及方法名,取得事务属性,即<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>这些内容
- final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);
- //取得类名+方法名全称
- final String joinpointIdentification = methodIdentification(invocation.getMethod());
- //没有事务属性 || 事务管理者不是CallbackPreferringPlatformTransactionManager类型(事务采用回调方法实现的方式)
- if (txAttr == null || !(getTransactionManager() instanceof CallbackPreferringPlatformTransactionManager)) {
- //开始事务并创建事务信息对象(此对象主要包括事务属性和事务状态等信息),就是在这里调用了session.beginTransaction()方法
- //将事务信息以当前线程为KEY放入了TransactionAspectSupport.transactionInfoHolder对象中
- //注意:到这里如果当前取得到SessionHolder,那么SESSION就被标记成老SESSION,提交事务时就不会关闭之,反之那么session会在打开,并被标为新SESSION,提交事务时会把此SESSION关闭
- TransactionInfo txInfo = createTransactionIfNecessary(txAttr, joinpointIdentification);
- Object retVal = null;
- try {
- // 调用下一下拦截器,如果没有下一个拦截器,那么目标类会被调用
- retVal = invocation.proceed();
- }
- catch (Throwable ex) {
- // 发生异常时,在这里回滚,回滚时,除了rollBack,还执行session.clear(),setFlushMode(NEVER)等动作
- // 新SESSION会在此被关闭,老的则不会
- completeTransactionAfterThrowing(txInfo, ex);
- throw ex;
- }
- finally {
- //清理当前线程对应的事务信息,
- cleanupTransactionInfo(txInfo);
- }
- //未发生异常,提交事务,如果是新SESSION,会在此被关闭,老的则不会
- commitTransactionAfterReturning(txInfo);
- return retVal;
- }
-
- else {
- // 回调式的事务管理器,SPRING中只提供了一个WebSphereUowTransactionManager的具体实现,
- /**CallbackPreferringPlatformTransactionManager接口的注释
- * Extension of the {@link org.springframework.transaction.PlatformTransactionManager}
- * interface, exposing a method for executing a given callback within a transaction.
- * <p>Implementors of this interface automatically express a preference for
- * callbacks over programmatic <code>getTransaction</code>, <code>commit</code>
- * and <code>rollback</code> calls. Calling code may check whether a given
- * transaction manager implements this interface to choose to prepare a
- * callback instead of explicit transaction demarcation control.*/
- // 大意应该是可以由此接口的具体实现来决定事务的控制,我的E文一般般,有错的就砸砖
- try {
- Object result = ((CallbackPreferringPlatformTransactionManager) getTransactionManager()).execute(txAttr,
- new TransactionCallback() {
- public Object doInTransaction(TransactionStatus status) {
- TransactionInfo txInfo = prepareTransactionInfo(txAttr, joinpointIdentification, status);
- try {
- //往下调用
- return invocation.proceed();
- }
- catch (Throwable ex) {
- if (txAttr.rollbackOn(ex)) {
- // A RuntimeException: will lead to a rollback.
- if (ex instanceof RuntimeException) {
- throw (RuntimeException) ex;
- }
- else {
- throw new ThrowableHolderException(ex);
- }
- }
- else {
- // A normal return value: will lead to a commit.
- return new ThrowableHolder(ex);
- }
- }
- finally {
- cleanupTransactionInfo(txInfo);
- }
- }
- });
-
- // Check result: It might indicate a Throwable to rethrow.
- if (result instanceof ThrowableHolder) {
- throw ((ThrowableHolder) result).getThrowable();
- }
- else {
- return result;
- }
- }
- catch (ThrowableHolderException ex) {
- throw ex.getCause();
- }
- }
- }
|
分享到:
相关推荐
spring声明式事务实例 可复制修改使用。。。。。。。。。。
Spring声明式事务配置管理方法
Spring源代码解析(六):Spring声明式事务处理.doc
spring声明式事务处理demo。myeclipse工程
1. 基于Aspectj实现动态数据源...6. 实现事务内切换数据源(支持原生Spring声明式事务哟,仅此一家),并支持多数据源事务回滚(有了它除了跨服务的事务你需要考虑分布式事务,其他都不需要,极大的减少了系统的复杂程度)
Spring 声明式事务和Spring 编程式事务
Spring框架的声明式事务管理是Java开发中的核心特性,它为高效且可靠的数据操作提供了强大支持。...深入理解Spring声明式事务的工作原理,不仅能帮助开发者更高效地使用Spring框架,也是提升Java企业级开发能力的关键。
NULL 博文链接:https://babalaaaa.iteye.com/blog/538687
spring声明式事务.zip
spring声明式事务管理异常处理的测试
1.本例子的使用了 ssh 框架 2.本例子DAO层 使用了 getHibernateTemplate 来实现数据的新增修改和删除 3.本例子使用了声明式...4.本例子提供了详细的使用方法,可以根据 readme.txt 来逐步的验证声明式事务是否起作用
示例代码 博文链接:https://awaken2012.iteye.com/blog/1728283
06丨20%的业务代码的Spring声明式事务,可能都没处理正确 Spring 针对 Java Transaction API (JTA)、JDBC、Hibernate 和 Java Persistence API (JPA) 等事务 API,实现了一致的编程模型,而 Spring 的声明式事务功能...
Java高级编程 实验报告 spring 声明事务 实验目的 掌握spring 声明式事务管理配置 实验环境 本实验采用本实验采用的eclipse或者 Myeclpse开发工具。Spring 4.0以上 Jdk1.7以上、oracle/mysql。
spring声明式事务配置方法.docx
spring声明式事务管理+jdbc+连接池 包内为代码,下载可直接执行。 一直用s2sh,感觉hibernate不好用,所以写了一个spring声明式事务管理+jdbc+连接池。
spring声明式事务管理+jdbc+连接池.zip
spring声明式事务管理_入门
Spring声明式事务及BaseDao完整版
struts2+spring+hibernate ssh 整合+spring声明式事务管理