`
jetway
  • 浏览: 485852 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

hibernate和jdbc事务统一控制

阅读更多

hibernate和jdbc事务统一控制

“Hibernate与JDBC(iBATIS)  都使用 DataSourceTransactionManager 同样可以保证事务
原理就是保证了 connection 的唯一性。
jdbc我是调spring的jdbcTemplate来操作,
经过测试。在同一个数据源的情况下直接使用Hibernate的TxManager可以同步事务,问题解决。

Rod Johnson的话:
引用
It is possible--and sometimes useful--to have coordinated transactions for both. Your JDBC transactions will be managed by the HibernateTransactionManager if you work with the same JDBC DataSource in the same transaction. That is, create the SessionFactory using Spring's SessionFactoryBean using the same DataSource that your JdbcTemplates use.

The only issue to watch, of course, is that you may be invalidating your Hibernate cache by JDBC changes. Generally I find it best to use JDBC to update only tables that don't have Hibernate mappings.


Juergen Hoeller的话:
引用
As Rod said, simply keep using HibernateTransactionManager, which auto-detects the DataSource used by Hibernate and seamlessly exposes Hibernate transactions as JDBC transactions for that DataSource. JDBC code that accesses the same DataSource via Spring will automatically participate in such transactions.

Note that you must specify the DataSource for Hibernate via LocalSessionFactoryBean's "dataSource" property to allow HibernateTransactionManager to auto-detect it. Alternatively, you can explicitly pass the DataSource to HibernateTransactionManager's "dataSource" property.

由此可见要保证事务的一致性,在spring下面的配置还是很方便的。

详细实例如下:(这是我自己机器上的例子,已经测试通过)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
  3. <!--
  4.         - Application context definition for PetClinic on JDBC.
  5. -->
  6. <beans>
  7.         <!-- ========================= RESOURCE DEFINITIONS ========================= -->
  8.         <!-- Configurer that replaces ${...} placeholders with values from a properties file -->
  9.         <!-- (in this case, JDBC-related settings for the dataSource definition below) -->
  10.         <!--  
  11.                 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  12.                 <property name="location" value="/WEB-INF/jdbc.properties"/>
  13.                 </bean>
  14.         -->
  15.         <!--
  16.                 Simple local DataSource that works in any environment.
  17.                 This uses the JDBC DriverManager to obtain connections, and does NOT perform connection
  18.                 pooling. Connection pooling is essential to all real-world applications.
  19.                 This definition is good for getting started, as it introduces no dependencies beyond
  20.                 the JDK, but DriverManagerDataSource is not intended for production usage.
  21.         -->
  22.         <!--
  23.                 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  24.                 <property name="driverClassName" value="${jdbc.driverClassName}"/>
  25.                 <property name="url" value="${jdbc.url}"/>
  26.                 <property name="username" value="${jdbc.username}"/>
  27.                 <property name="password" value="${jdbc.password}"/>
  28.                 </bean>
  29.         -->
  30.         <!--  在spring中直接配置jdbc链接  测试的时候可以使用!
  31.         <bean id="dataSource"
  32.                 class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  33.                 <property name="driverClassName"
  34.                         value="net.sourceforge.jtds.jdbc.Driver" />
  35.                 <property name="url"
  36.                         value="jdbc:jtds:sqlserver://localhost:1433/gjxt;SelectMethod=cursor;charset=GBK;tds=8.0;lastupdatecount=true" />
  37.                 <property name="username" value="sa" />
  38.                 <property name="password" value="sa" />
  39.         </bean>-->
  40.          
  41.          <!-- 通过proxool来配置数据源-->
  42.         <bean id="dataSource"
  43.                 class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  44.                 <property name="driverClassName"
  45.                         value="org.logicalcobwebs.proxool.ProxoolDriver" />
  46.                 <property name="url"
  47.                         value="proxool.qxgldb" />
  48.         </bean>          
  49.         <!--
  50.                 Alternative local DataSource that works in any environment, and offers much better performance.
  51.                 Uses Apache Commons DBCP for connection pooling. See Commons DBCP documentation
  52.                 for the required JAR files. See the PetStore sample application also shipped with
  53.                 Spring, for an example of Commons DBCP usage and the necessary build script.
  54.                 Alternatively you can use another connection pool such as C3P0, similarly configured
  55.                 using Spring.
  56.                 A standalone connection pool such as Commons DBCP is a good choice for use outside an
  57.                 application server environment, including web applications running in a web container without
  58.                 JTA, or integration testing using the org.springframework.test package.
  59.         -->
  60.         <!--
  61.                 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  62.                 <property name="driverClassName" value="${jdbc.driverClassName}"/>
  63.                 <property name="url" value="${jdbc.url}"/>
  64.                 <property name="username" value="${jdbc.username}"/>
  65.                 <property name="password" value="${jdbc.password}"/>
  66.                 </bean>
  67.         -->
  68.         <!-- JNDI DataSource for J2EE environments -->
  69.         <!--
  70.                 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
  71.                 <property name="jndiName" value="java:comp/env/jdbc/petclinic"/>
  72.                 </bean>
  73.         -->
  74.         <!-- 本地jdbc连接抽取器和oracle lobhandler类 用于存取流程定义文件 -->
  75.         <bean id="nativeJdbcExtractor"
  76.                 class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"
  77.                 lazy-init="true" />
  78.         <bean id="oracleLobHandler"
  79.                 class="org.springframework.jdbc.support.lob.OracleLobHandler"
  80.                 lazy-init="true">
  81.                 <property name="nativeJdbcExtractor" ref="nativeJdbcExtractor" />
  82.         </bean>
  83.         <bean id="defaltLobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler"
  84.                 lazy-init="true">
  85.         </bean>       
  86.         <!--  session factory for sql server, 指定了lobHandler -->
  87.         <!--          -->
  88.         <bean id="MyHibernateSessionFactory"
  89.                 class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  90.                 <property name="dataSource">
  91.                         <ref bean="dataSource" />
  92.                 </property>
  93.                 <property name="lobHandler">
  94.                         <ref bean="defaltLobHandler" />
  95.                 </property>                 
  96.                 <property name="hibernateProperties">
  97.                         <props>
  98.                                 <prop key="hibernate.dialect">
  99.                                         org.hibernate.dialect.SQLServerDialect
  100.                                 </prop>
  101.                                 <prop key="hibernate.show_sql">true</prop>
  102.                         </props>
  103.                 </property>
  104.                 <property name="mappingJarLocations">
  105.                         <list>
  106.                                 <value>
  107.                                         WEB-INF/lib/fireflow*.jar
  108.                                 </value>
  109.                         </list>
  110.                 </property>
  111.                 <property name="mappingLocations">
  112.                         <list>
  113.                                 <value>
  114.                                         WEB-INF/classes/org/fireflow/example/**/*.hbm.xml
  115.                                 </value>
  116.                         </list>
  117.                 </property>
  118.         </bean>
  119.          
  120.         <bean id="transactionManager"
  121.                 class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  122.                 <property name="sessionFactory">
  123.                         <ref bean="MyHibernateSessionFactory" />
  124.                 </property>
  125.         </bean>
  126.        
  127.         <!-- Transaction manager for a single JDBC DataSource (alternative to JTA)
  128.         <bean id="transactionManager"
  129.                 class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  130.                 <property name="dataSource" ref="dataSource" />
  131.         </bean>-->
  132.         <!-- Transaction manager that delegates to JTA (for a transactional JNDI DataSource) -->
  133.         <!--  
  134.                 <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>
  135.         -->
  136.         <bean id="baseTransactionProxy" abstract="true"
  137.                 class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  138.                 <property name="transactionManager">
  139.                         <ref bean="transactionManager" />
  140.                 </property>
  141.                 <property name="transactionAttributes">
  142.                         <props>
  143.                                 <prop key="create*">
  144.                                         PROPAGATION_REQUIRED,-Exception
  145.                                 </prop>
  146.                                 <prop key="update*">
  147.                                         PROPAGATION_REQUIRED,-Exception
  148.                                 </prop>
  149.                                 <prop key="delete*">
  150.                                         PROPAGATION_REQUIRED,-Exception
  151.                                 </prop>
  152.                                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
  153.                                 <prop key="retrieve*">
  154.                                         PROPAGATION_REQUIRED,readOnly
  155.                                 </prop>
  156.                                 <prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
  157.                         </props>
  158.                 </property>
  159.         </bean>
  160.         <!--  
  161.         通过BeanNameAutoProxyCreator来实现spring的事务控制-->
  162.         <bean
  163.                 class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
  164.                 <property name="transactionInterceptor"
  165.                         ref="transactionInterceptor" />
  166.         </bean>
  167.                
  168.         <bean id="transactionInterceptor"
  169.                 class="org.springframework.transaction.interceptor.TransactionInterceptor">
  170.                 <property name="transactionManager">
  171.                         <ref bean="transactionManager" />
  172.                 </property>
  173.                 <property name="transactionAttributes">
  174.                         <props>
  175.                                 <prop key="create*">
  176.                                         PROPAGATION_REQUIRED,-Exception
  177.                                 </prop>
  178.                                 <prop key="update*">
  179.                                         PROPAGATION_REQUIRED,-Exception
  180.                                 </prop>
  181.                                 <prop key="delete*">
  182.                                         PROPAGATION_REQUIRED,-Exception
  183.                                 </prop>
  184.                                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
  185.                                 <prop key="retrieve*">
  186.                                         PROPAGATION_REQUIRED,readOnly
  187.                                 </prop>
  188.                                 <prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
  189.                         </props>
  190.                 </property>
  191.         </bean>
  192.        
  193.         <bean
  194.                 class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  195.                 <property name="beanNames">
  196.                         <value>*ServiceDao</value>
  197.                 </property>
  198.                 <property name="interceptorNames">
  199.                         <list>
  200.                                 <value>transactionInterceptor</value>
  201.                         </list>
  202.                 </property>
  203.         </bean>
  204.         <!-- ========================= BUSINESS OBJECT DEFINITIONS ========================= -->
  205. </beans>
分享到:
评论

相关推荐

    Hibernate and JDBC

    JDBC(Java Database Connectivity)是一种用于执行SQL语句的Java API,它可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了高度的抽象层,允许Java开发者在不深入了解底层...

    类似hibernate的jdbc封装

    标题提到的"类似hibernate的jdbc封装"就是这样的一个实践,它试图在不引入庞大框架的情况下,提供类似Hibernate的便捷性。 首先,我们来了解JDBC(Java Database Connectivity),它是Java中用于连接数据库的标准...

    hibernate jdbc需要用的jar

    然而,为了使Hibernate正常工作,我们需要依赖一些外部库,包括JDBC驱动和连接池管理工具。标题提到的“hibernate jdbc需要用的jar”指的是在使用Hibernate进行数据库交互时,必不可少的两个组件。 首先,`commons-...

    JDBC与Hibernate的比较

    JDBC提供了更多的灵活性和控制力,适合对性能有特殊需求或者需要精确控制SQL查询的情况;而Hibernate则更适合于需要快速开发、减少编码量并关注业务逻辑的场景。选择哪种方式取决于具体项目的需求和技术团队的能力...

    spring,struts,hibernate,事务

    Hibernate支持JDBC事务和JTA(Java Transaction API)事务,可以与Spring的事务管理机制集成,实现统一的事务策略。 在SSH事务配置中,提到的“通用性”是指通过合理配置,可以将事务管理应用到多个DAO(数据访问...

    异常处理和JDBC

    4. **一致性和兼容性**:JDBC的目标是提供一个统一的接口,无论底层数据库是什么,都能提供一致的行为。这使得开发者无需因数据库类型的变化而修改大量代码。 5. **简化数据库操作**:JDBC提供了一些高级功能,如...

    Hibernate事务处理

    Hibernate通过封装JDBC或JTA事务管理,为Java开发者提供了一套易于使用的事务管理API,使得在复杂的应用场景下,数据操作更加安全可靠。正确理解和应用事务处理,对于构建高质量的数据库应用至关重要。

    Hibernate技术.PPT

    - 使用Hibernate,可以通过统一的API(如Session)进行数据库操作,避免了因直接使用JDBC导致的代码不一致性和重复性,提高了代码的可维护性。 6. **Hibernate的功能扩展** - Hibernate提供了对象关系映射(O/R ...

    struts2、hibernate和spring框架整合所需的jar以及配置文档

    **Struts2** 是一个强大的MVC框架,主要负责处理用户请求和控制业务流程。它提供了丰富的拦截器(Interceptor)机制,支持多种视图技术,并且能够与各种模板引擎如FreeMarker、JSP等无缝集成。Struts2的核心配置文件...

    Hibernate可选配置大全

    - **用途**:确保SQL语句的正确性和高效性,通常Hibernate能根据JDBC元数据自动识别。 ##### 2. hibernate.show_sql - **功能**:控制是否在控制台或日志中显示执行的SQL语句。 - **取值**:`true`或`false`,默认...

    struts和hibernate和spring

    例如,Spring可以作为全局的事务管理器,统一管理Struts和Hibernate中的事务;而Hibernate作为数据访问层,负责数据库交互;Struts或SpringMVC则负责处理用户请求,展示视图,实现业务逻辑。 在学习这三个框架时,...

    hibernate与spring整合demo

    3. 配置简化:Spring可以统一管理Hibernate的SessionFactory和Session,简化配置文件。 4. AOP集成:Spring的AOP可以与Hibernate的事务管理结合,提供更灵活的事务策略。 四、整合步骤 1. 引入依赖:在项目中添加...

    Hibernate Hibernate5 讲义 PDF

    Hibernate的懒加载、缓存策略以及事务管理等高级特性,使得它能高效地与关系型数据库进行交互,满足现代应用程序对数据持久化的需求。 北京动力节点教育培训公司提供的Hibernate5讲义,不仅对Hibernate框架进行了...

    Hibernate必须包

    3. **JTA(Java Transaction API)**:在分布式环境中处理事务是必要的,JTA提供了统一的事务管理。Hibernate支持JTA事务管理,因此在需要时,需要引入对应的JTA实现,如Jboss Transactions或Atomikos。 4. **SLF4J...

    Hibernate、Spring和Struts工作原理及使用理由

    - **简化数据访问层**:Hibernate封装了JDBC,减少了很多重复的数据库操作代码。 - **ORM(对象关系映射)**:提供了对象和数据库表之间的映射,使开发者可以使用面向对象的方式来操作数据库。 - **反射机制**:利用...

    spring和hibernate整合

    总的来说,Spring和Hibernate的整合旨在提供一个统一的、可扩展的开发环境,使得开发者可以更专注于业务逻辑,而不是底层的数据库操作和事务管理。通过合理配置和设计,这种整合可以提高开发效率,增强系统的可维护...

    用Hibernate和Spring开发持久层

    Spring的事务管理可以无缝地与Hibernate结合,提供统一的事务边界控制,使得事务管理变得更加简洁和高效。 #### 四、构建事务持久层 在实际应用中,通过Spring来管理Hibernate的SessionFactory,并利用Spring的...

    hibernate_questions

    JDBC 更侧重于底层控制和性能,而 Hibernate 提供了更高的抽象级别,使得数据库操作更加简单直观。根据项目的具体需求,合理选择使用 Hibernate 或 JDBC,可以帮助开发者高效地完成数据库相关的开发工作。

    JDBC数据库连接JAR包

    4. **JDBC事务管理** - 自动提交:默认情况下,JDBC每条SQL语句都会开启一个事务并自动提交。可通过`Connection.setAutoCommit(false)`关闭自动提交,手动控制事务。 - 显式事务:通过`Connection.commit()`和`...

    整合Hibernate+JSF

    3. **事务管理**:Hibernate支持JTA(Java Transaction API)和JDBC事务管理。事务控制对于保证数据的一致性和完整性至关重要。 4. **Criteria和HQL查询**:除了传统的SQL查询,Hibernate提供了Criteria查询和HQL...

Global site tag (gtag.js) - Google Analytics