spring 和hibernate集成 采用声明式事务

原文地址：spring 和hibernate集成 采用声明式事务作者：雪狼首领

采用声明式事务

 

1、声明式事务配置

* 配置SessionFactory

* 配置事务管理器

* 事务的传播特性

* 那些类那些方法使用事务

 

2、编写业务逻辑方法

* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是

Hibernate Session的轻量级封装

* 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的

* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理

* 关于事务边界的设置，通常设置到业务层，不要添加到Dao上

 

3、了解事务的几种传播特性

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 属性执行

 

4、Spring事务的隔离级别

1. ISOLATION_DEFAULT：这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.

另外四个与JDBC的隔离级别相对应

2. ISOLATION_READ_UNCOMMITTED：这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。

这种隔离级别会产生脏读，不可重复读和幻像读。

3. ISOLATION_READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据

4. ISOLATION_REPEATABLE_READ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。

它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。

5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。

除了防止脏读，不可重复读外，还避免了幻像读。

 

hibernate.cfg.xml

 

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

 

<hibernate-configuration>

<session-factory >

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/spring_hibernate_2</property>

<property name="connection.useUnicode">true</property>

<property name="connection.characterEncoding">UTF-8</property>

<property name="hibernate.connection.username">root</property>

<property name="hibernate.connection.password"></property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="hibernate.current_session_context_class">thread</property>

<!--

<property name="hibernate.current_session_context_class">jta</property>

-->

<property name="show_sql">true</property>

<mapping resource="com/jonsion/model/User.hbm.xml"/>

<mapping resource="com/jonsion/model/Log.hbm.xml"/>

</session-factory>

</hibernate-configuration>

 

 

 

 

log4j.properties

 

### direct log messages to stdout ###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.out

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

 

### direct messages to file hibernate.log ###

#log4j.appender.file=org.apache.log4j.FileAppender

#log4j.appender.file.File=hibernate.log

#log4j.appender.file.layout=org.apache.log4j.PatternLayout

#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

 

### set log levels - for more verbose logging change 'info' to 'debug' ###

 

log4j.rootLogger=warn, stdout

 

#log4j.logger.org.hibernate=info

#log4j.logger.org.hibernate=debug

 

### log HQL query parser activity

#log4j.logger.org.hibernate.hql.ast.AST=debug

 

### log just the SQL

#log4j.logger.org.hibernate.SQL=debug

 

### log JDBC bind parameters ###

#log4j.logger.org.hibernate.type=info

#log4j.logger.org.hibernate.type=debug

 

### log schema export/update ###

#log4j.logger.org.hibernate.tool.hbm2ddl=debug

 

### log HQL parse trees

#log4j.logger.org.hibernate.hql=debug

 

### log cache activity ###

#log4j.logger.org.hibernate.cache=debug

 

### log transaction activity

#log4j.logger.org.hibernate.transaction=debug

 

### log JDBC resource acquisition

#log4j.logger.org.hibernate.jdbc=debug

 

### enable the following line if you want to track down connection ###

### leakages when using DriverManagerConnectionProvider ###

#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

 

 

 

applicationContext-beans.xml

 

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

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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="userManage" class="com.jonsion.manager.UserManageImpl">

<property name="sessionFactory" ref="sessionFactory"/>

<property name="logManage" ref="logManage"/>

</bean>

<bean id="logManage" class="com.jonsion.manager.LogManageImpl">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

</beans>

 

 

 

applicationContext-common.xml

 

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

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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">

<!-- 配置sessionFactory -->

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation">

<value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

<!-- 配置事务管理器 -->

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

<property name="sessionFactory">

<ref bean="sessionFactory"/>

</property>

</bean>

<!-- 配置事务的传播特性 -->

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="add*" propagation="REQUIRED"/>

<tx:method name="del*" propagation="REQUIRED"/>

<tx:method name="modify*" propagation="REQUIRED"/>

<tx:method name="*" read-only="true"/>

</tx:attributes>

</tx:advice>

<!-- 那些类的哪些方法参与事务 -->

<aop:config>

<aop:pointcut id="allManagerMethod" expression="execution(* com.jonsion.manager.*.*(..))"/>

<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>

</aop:config>

</beans>

 

 

 

package com.jonsion.util;

 

import org.hibernate.cfg.Configuration;

import org.hibernate.tool.hbm2ddl.SchemaExport;

 

public class Hbm2Ddl {

public static void main(String[] args) {

//读取hibernate.cfg.xml配置文件

Configuration cfg=new Configuration().configure();

//根据对象生成DDL和相应的表

SchemaExport se=new SchemaExport(cfg);

se.create(true, true);

}

}

 

 

package com.jonsion.util;

 

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

 

public class HibernateUtils {

private static SessionFactory factory;

static{

// public Configuration configure() throws HibernateException {

// configure( "/hibernate.cfg.xml" );

// return this;

// }

try{

Configuration cfg=new Configuration().configure();

factory=cfg.buildSessionFactory();

}catch(Exception ex){

ex.printStackTrace();

}

}

public static SessionFactory getSessionFactory(){

return factory;

}

public static Session getSession(){

return factory.openSession();

}

public static void closeSession(Session session){

if(session!=null){

if(session.isOpen()){

session.close();

}

}

}

}

 

 

 

package com.jonsion.model;

 

import java.util.Date;

 

public class Log {

private int id;

private int type;

private String detial;

private Date logDate;

 

public int getId() {

return id;

}

 

public void setId(int id) {

this.id = id;

}

 

public int getType() {

return type;

}

 

public void setType(int type) {

this.type = type;

}

 

public String getDetial() {

return detial;

}

 

public void setDetial(String detial) {

this.detial = detial;

}

 

public Date getLogDate() {

return logDate;

}

 

public void setLogDate(Date logDate) {

this.logDate = logDate;

}

}

 

 

package com.jonsion.model;

 

 

public class User {

private int id;

private String username;

 

public int getId() {

return id;

}

 

public void setId(int id) {

this.id = id;

}

 

public String getUsername() {

return username;

}

 

public void setUsername(String username) {

this.username = username;

}

}

 

 

 

Log.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

 

<hibernate-mapping package="com.jonsion.model">

<class name="Log" table="T_Log">

<id name="id">

<generator class="native"/>

</id>

<property name="type"/>

<property name="detial"/>

<property name="logDate"/>

</class>

</hibernate-mapping>

 

User.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

 

<hibernate-mapping package="com.jonsion.model">

<class name="User" table="T_User">

<id name="id">

<generator class="native"/>

</id>

<property name="username"/>

</class>

</hibernate-mapping>

 

package com.jonsion.manager;

 

import com.jonsion.model.Log;

 

public interface LogManage {

public void addLog(Log log);

}

 

package com.jonsion.manager;

 

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

import com.jonsion.model.Log;

 

public class LogManageImpl extends HibernateDaoSupport implements LogManage {

 

public void addLog(Log log) {

// HibernateUtils.getSessionFactory().getCurrentSession().save(log);

this.getHibernateTemplate().save(log);

}

 

}

 

 

package com.jonsion.manager;

 

 

public interface UserManage {

public void addUser();

}

 

 

package com.jonsion.manager;

 

import java.util.Date;

 

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

import com.jonsion.model.Log;

import com.jonsion.model.User;

 

public class UserManageImpl extends HibernateDaoSupport implements UserManage {

private LogManage logManage;

public void addUser() {

User user=new User();

user.setUsername("xxx");

this.getHibernateTemplate().save(user);

Log log=new Log();

log.setDetial("添加用户操作");

log.setType(1);

log.setLogDate(new Date());

logManage.addLog(log);

}

public void setLogManage(LogManage logManage) {

this.logManage = logManage;

}

 

}

 

 

package com.jonsion.client;

 

import org.springframework.beans.factory.BeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

import com.jonsion.manager.UserManage;

 

public class Client {

public static void main(String[] args) {

// UserManage userManage=new UserManageImpl();

// userManage.addUser();

BeanFactory beanFactory=new ClassPathXmlApplicationContext("applicationContext-*.xml");

UserManage userManage=(UserManage)beanFactory.getBean("userManage");

userManage.addUser();

}

 

}