Spring和Hibernate的整合和四种事务管理方式

男娘i 2022-05-10 07:44 184阅读 0赞

在进行Spring和Hibernate整合之前先将需要的jar导入项目中：

**Spring需要的jar包：**

1、spring-core

2、spring-context

3、spring-jdbc

4、spring-beans

5、spring-web

6、spring-expression

7、spring-orm （spring和hibenate的整合包）

在pom.xml中编写spring3需要的包（3.1.2.RELEASE）：

<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-beans</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-expression</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-orm</artifactId>
    			<version>${spring.version}</version>
    		</dependency>

**Hibernate需要的jar包：**

<dependency>
    			<groupId>org.hibernate</groupId>
    			<artifactId>hibernate-core</artifactId>
    			<version>${hibernate.version}</version>
    		</dependency>

**数据库驱动jar包：**

<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.1</version>
    		</dependency>

**添加aspectjweaver包：**

<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>1.8.5</version>
    		</dependency>

**导入cglib包：**

<dependency>
    			<groupId>cglib</groupId>
    			<artifactId>cglib</artifactId>
    			<version>2.2.2</version>
    		</dependency>

以上就是spring和hibernate整合需要的jar包，还有数据库连接池的jar包在等下具体说整合方式的时候在给出。

**Spring和Hibernate的整合方式有两种：通过配置hibernate.cfg.xml 文件 和 在Spring配置文件中进行数据源配置；**

第一种：有hibernate.cfg.xml文件进行数据源配置，在有Spring直接引用

如果在hibernate.cfg.xml中进行数据源配置的话，必须指出hibernate.connection.provider\_class属性：

<property name="hibernate.connection.provider_class">
    		org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider
    	</property>

否则会报错：Cannot unwrap to requested type \[javax.sql.DataSource\]。然后引入hibernat-c3p0相关的jar包：

c3p0-0.9.2.1.jar，hibernate-c3p0-4.1.7.Final.jar，mchange-commons-java-0.2.3.4.jar

在pom.xml中进行配置如下（由于hibernate已经不再对dbcp提供支持，所以这里使用的是c3p0）：

<dependency>
    			<groupId>org.hibernate</groupId>
    			<artifactId>hibernate-c3p0</artifactId>
    			<version>4.1.7.Final</version>
    			
    			<exclusions>
    				<exclusion>
    					<groupId>c3p0</groupId>
    					<artifactId>c3p0</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		<dependency>
    			
    			<groupId>com.mchange</groupId>
    			<artifactId>c3p0</artifactId>
    			<version>0.9.2.1</version>
    		</dependency>
    		<dependency>
    			<groupId>com.mchange</groupId>
    			<artifactId>mchange-commons-java</artifactId>
    			<version>0.2.3.4</version>
    		</dependency>

在spring配置文件中如下配置：

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

第二种方式：在Spring中进行数据源配置

在Spring的连接池使用同dbcp，所以需要在pom.xml中进行配置（也可以使用上面的c3p0）：

<dependency>
    			<groupId>commons-dbcp</groupId>
    			<artifactId>commons-dbcp</artifactId>
    			<version>1.2.2</version>
    		</dependency>

在spring配置文件中数据源配置文件下：

<bean class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
    		id="sessionFactory">
    		<property name="dataSource" ref="dataSource"></property>
    		<property name="hibernateProperties">
    			<props>
    				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    				<prop key="hibernate.show_sql">true</prop>
    				<prop key="hibernate.format_sql">true</prop>
    				<prop key="hibernate.hbm2ddl.auto">create</prop>
    			</props>
    		</property>
    		<property name="mappingLocations">
    			<list>
    				<value>实体对应的xml文件地址</value>
    			</list>
    		</property>
    	</bean>

以上即是Spring和Hibernate整合的两种方式。

通过上面的设置可以使得Spring和Hibernate完成整合，下面开始说Spring管理Hibernate事务的四种管理方式：

**第一种方式，利用tx标签配置事务。**

<bean id="txManager"
    		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory"></property>
    	</bean>
    	
    	<tx:advice id="txAdvice" transaction-manager="txManager">
    		<tx:attributes>
    			<tx:method name="update" propagation="REQUIRED"/>
    			<tx:method name="*" read-only="false" />
    		</tx:attributes>
    	</tx:advice>
    
    	
    	<aop:config>
    		<aop:pointcut expression="execution(* com.cn.tch.spring_hibernate2.*.*(..))"
    			id="pt" />
    		<aop:advisor advice-ref="txAdvice" pointcut-ref="pt" />
    	</aop:config>

下面也给出几种传播特性的解释：

1. PROPAGATION\_REQUIRED: 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择；

2. PROPAGATION\_SUPPORTS: 支持当前事务，如果当前没有事务，就以非事务方式执行；

3. PROPAGATION\_MANDATORY: 支持当前事务，如果当前没有事务，就抛出异常；

4. PROPAGATION\_REQUIRES\_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起；

5. PROPAGATION\_NOT\_SUPPORTED: 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起；

6. PROPAGATION\_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常；

7. PROPAGATION\_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION\_REQUIRED 属性执行。

**   第二种方式，使用代理进行配置**

<bean id="transactionManager"
    		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory" />
    	</bean>
    	 <tx:annotation-driven transaction-manager="transactionManager" /> 
    	
    	<bean id="transactionProxy"
    		class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
    		abstract="true">
    		<property name="transactionManager" ref="transactionManager" />
    		<property name="transactionAttributes">
    			<props>
    				
    				<prop key="update">PROPAGATION_SUPPORTS,-Exception</prop>
    			</props>
    		</property>
    	</bean>
    	
    	<bean id="deptProxy" parent="transactionProxy">
    		<property name="target" ref="deptDao"></property>
    	</bean>

在使用代理管理事务时，如果需要使用到getCurrentSession()这个方法，需要设置（这里所说的有点像是第四种管理方式的配置，有可能代理模式不支持使用getCurrentSession（））：

<tx:annotation-driven transaction-manager="transactionManager" />

同时需要在service上添加@Transactional，不然会报错：org.hibernate.HibernateException: No Session found for current thread

**第三种方式，使用拦截器**

<bean id="transactionManager"
    		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory" />
    	</bean>
    	
    	<bean id="transactionInterceptor"
    		class="org.springframework.transaction.interceptor.TransactionInterceptor">
    		<property name="transactionManager" ref="transactionManager" />
    		<property name="transactionAttributes">
    			<props>
    				
    				<prop key="update">PROPAGATION_REQUIRED,-Exception</prop>
    				<prop key="modify*">PROPAGATION_REQUIRED,+MyException</prop>
                   
    			</props>
    		</property>
    	</bean>
    	
    	<bean id="proxyFactory"
    		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    		<property name="interceptorNames">
    			<list>
    				<value>transactionInterceptor</value>
    			</list>
    		</property>
    		<property name="beanNames">
    			<list>
    				<value>deptDao</value>
    			</list>
    		</property>
    	</bean>

第四种方式，使用注解方式

同时需要在service类上面添加@Transactional。

纵观以上四种在Spring中配置Hibernate事务的方法，其核心都是一样的，不同的只是实现的方式而已。所以看到这，这篇博文中你只需要记住4句话，就可以轻松理解在Spring中配置Hibernate事务的核心：

1.配置SessionFactory

2.配置事务容器

3.配置事务规则

4.配置事务入口