Spring4.X 与 Hibrenate5.X整合

Spring4.X 与 Hibrenate5.X整合

配置数据源：

1. 通过JNDB
   位于jee命名空间下的的元素可以用于检索JNDI中的任何对象(包括数据源)并将其用于spring bean中。
   xml
<jee:jndi-lookup id="dataSource"
jndi-name="/jdbc/contactSource"
resource-ref="true" />

2. 使用数据源连接池
   使用Apache的开源数据连接池dbcp
   java
<bean id="datasource"
class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
<property name="initialSize" value="5" />
<property name="maxTotal" value="10" />
</bean>


池配置属性	所指的内容
initialSize	池启动时创建的连接数量
maxTatol	同一时间可从池中分配的最多连接数,如果为0 ,表示无限制
maxIdle	池中不会被释放的最多空闲连接数
minIdle	不创建新连接的情况，池中保持空闲的最小连 接数
maxWait	在抛出异常之前,池中等待连接回收的最大时间

3. 基于JDBC驱动注解


java
<bean id="dataSource"
class="org.springframework.jdbc.dataSource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
</bean>


整体的一个项目依赖 pom.xm

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.springDemos</groupId>
  <artifactId>springDemos</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springDemos</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjtools</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.9.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>6.0.6</version>
    </dependency>
    <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.1.1</version>
    </dependency>
<!--    <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>1.11.4.RELEASE</version>
    </dependency> -->
    <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.2.10.Final</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>4.3.9.RELEASE</version>
    </dependency>

  </dependencies>
</project>

一、使用Spring JDBC

---

springData.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 配置数据源,使用apache的连接池 -->
<bean id="dataSource" 
      class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
<property name="initialSize" value="5" />
<property name="maxTotal" value="10" />
</bean>

<!-- 配置一个JdbcTemplate来操作数据库 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="dataSource" />
</bean>
<!-- 扫描定义的包,对标注的类进行实例化 -->
<context:component-scan base-package="com.springData" />
<!-- 配置事务管理器 -->
<bean id="txManager" 
        class="org.springframework.jdbc.dataSource.DataSourceTransactionManager" />
</beans>

domain实体类

package com.springData;

import java.sql.Timestamp;

public class Contact {
    private int id;
    private String name;
    private String sex;
    private String phoneNumber;
    private String wechat;
    private Integer age;
    private String workAddress;
    private String homeAddress;
    private String description;
    private Timestamp createTime;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getPhoneNumber() {
        return phoneNumber;
    }
    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public String getWechat() {
        return wechat;
    }
    public void setWechat(String wechat) {
        this.wechat = wechat;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getWorkAddress() {
        return workAddress;
    }
    public void setWorkAddress(String workAddress) {
        this.workAddress = workAddress;
    }
    public String getHomeAddress() {
        return homeAddress;
    }
    public void setHomeAddress(String homeAddress) {
        this.homeAddress = homeAddress;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Timestamp getCreateTime(){
        return createTime;
    }
    public void setCreateTime(Timestamp createTime) {
        this.createTime = createTime;
    }
}

SpringDataService访问数据库的Dao服务类

package com.springData;

import java.sql.ResultSet;
import java.sql.SQLException;

import javax.inject.Inject;

import org.apache.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository
public class SpringDataService {
    public static final Logger logger = Logger.getLogger(SpringDataService.class);
    private JdbcTemplate jdbcTemplate;
    private static final String SQL_INSERT_COTACT = 
            "INSERT INTO contact (name, sex, age, phone_number,"
            + "wechat, work_address, home_address, description) values(?,?,?,?,?,?,?,?)";
    private static final String SQL_SELECT_COTACT =
            "SELECT * FROM contact WHERE name= ?";
    private static final String SQL_DELETE_COTACT =
            "DELETE FROM contact WHERE name= ?";
    private static final String SQL_UPDATE_COTACT =
            "UPDATE contact SET name = ?, sex = ?, age = ?, phone_number = ?, wechat = ?, "
                + "work_address = ?, home_address = ?, description = ? where name = ?";

    public void addContact(Contact contact) {
        if (logger.isInfoEnabled()) {
            logger.info("开始添加对象");
        }
        jdbcTemplate.update(SQL_INSERT_COTACT, contact.getName(), contact.getSex(), 
                contact.getAge(),contact.getPhoneNumber(), contact.getWechat(), 
                contact.getWorkAddress(),contact.getHomeAddress(), 
                contact.getDescription());
        if (logger.isInfoEnabled()) {
            logger.info("添加对象成功");
        }
    }

    public Contact getContact(String name) { 
        if (logger.isInfoEnabled()) {
            logger.info("开始查找对象");
        }
        return jdbcTemplate.queryForObject(SQL_SELECT_COTACT, 
                new RowMapper<Contact>() {
                    public Contact mapRow(ResultSet rs, int rowNum) throws SQLException {
                        Contact contact = new Contact();
                        contact.setId(rs.getInt(1));
                        contact.setName(rs.getString(2));
                        contact.setSex(rs.getString(3));
                        contact.setAge(rs.getInt(4));
                        contact.setPhoneNumber(rs.getString(5));
                        contact.setWechat(rs.getString(6));
                        contact.setWorkAddress(rs.getString(7));
                        contact.setHomeAddress(rs.getString(8));
                        contact.setDescription(rs.getString(9));
                        return contact;
                    }
                }, name);
    }

    public void deleteContact(String name) {
        if (logger.isInfoEnabled()) {
            logger.info("开始删除对象");
        }
        jdbcTemplate.update(SQL_DELETE_COTACT, name);
        if (logger.isInfoEnabled()) {
            logger.info("删除对象成功");
        }
    }

    public void updateContact(Contact contact, String name) {
        if (logger.isInfoEnabled()) {
            logger.info("开始更新对象");
        }
        jdbcTemplate.update(SQL_UPDATE_COTACT, contact.getName(), contact.getSex(), 
                contact.getAge(),contact.getPhoneNumber(), contact.getWechat(), 
                contact.getWorkAddress(),contact.getHomeAddress(), 
                contact.getDescription(), name);
        if (logger.isInfoEnabled()) {
            logger.info("更新对象成功");
        }
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    @Inject
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

}

SpringJdbcTest测试类

package com.springData;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringJDBCTest {
    @Test
    public void jdbcTest() {
        @SuppressWarnings("resource")
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("com/springData/springData.xml");
        SpringDataService service = 
                (SpringDataService)context.getBean("springDataService");
        Contact contact = new Contact();
        contact.setName("刘德华");
        contact.setSex("男");
        contact.setAge(58);
        contact.setPhoneNumber("13879681184");
        contact.setWechat("liudehua");
        contact.setWorkAddress("HongKong");
        contact.setHomeAddress("HongKong");
        contact.setDescription("Famouse Actor");
        //测试添加对象
        service.addContact(contact);

        //测试更改对象
        contact.setAge(60);
        service.updateContact(contact, "刘德华");

        //测试查找对象
        contact = service.getContact("龙涛");
        System.out.println(contact.getId() + contact.getName() + 
                    contact.getSex() + contact.getAge());

        /*//测试删除对象
        service.deleteContact("刘德华");*/

    }
}

二、在Spring4.X 中集成Hibernate5.X

通过SessionFactory负责HibrenaterSession的打开、关闭以及管理。而SessionFactory主要是通过Hibernate Session 工厂bean来获得。Session接口负责对数据库的增删查改操作。

session的三种状态:

• 瞬时状态(Transient):

实例化一个对象即通过new等获得一个对象，这个对象就处于临时状态，临时对象只是携带了属性的载体，并不与数据库中的任何数据相关联。
在Hibernate中可通过session的save() 或者 saveOrUpdate()方法将临时状态与数据库相关联，并将数据插入数据库中成为持久化对象。


- 持久状态(persistent)：

处于该状态的对象与数据是关联的，在数据库中有对应的记录，在数据库中也有唯一的标识，通过Sesson的get()、loat()方法获得都是持久状态的对象，持久状态对象若被更改，不会马上同步到数据库，而是要在commit()提交事物后，才会将对象数据同步到数据库。在提交事物之前的对象是脏对象。


- 脱管状态(detached):

当与持久状态对象关联的session被关闭后，该对象也就成为了游离状态的对象。游离状态对象通过session调用update()或者saveOrUpdate()方法,对象会从游离状态变回持久状态。若调用delete()则游离状态会变成瞬时状态，因为对象在数据库中的对应记录已经被删除了。
总结一下：通过new实例化一个类对象，然后设置对象的属性值，也就是将信息存储于对象的属性中，此时的对象属于瞬时对象，对象变量引用了对象所以对象不会被垃圾回收器回。我们通过Session对象的save()或者saveOrUpdate()方法可以将对象持久化到数据库中，此时的对象处于持久状态，也就是数据库中有该对象的相应记录，此时该对象与session和transaction是相关联的。session.close()后，关闭了session与对象的关联，此时的对象那个处于离线状态。也就是session中没有该对象了。离线状态可通过update()或者saveOrUpdate()方法变成持久状态,离线状态也可以通过delete()方法变成瞬时状态。另外离线状态通过update()方法变成持久状态后，若对象获得更改，对象不会马上被同步到数据库，而是存储在session缓存中，待commit()后才会得到同步。

一个spring + hibernate的实例:
hibernate.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation=
       "http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

<!-- 获得一个数据库连接池源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
<property name="initialSize" value="5" />
<property name="maxTotal" value="10" />
</bean>
<!-- 通过LocalSessionFactoryBean获得一个会话工厂 -->
<bean id="sessionFactory" 
    class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 通过扫描相应的包获得对象与数据库表的映射关系 -->
<property name="packagesToScan" value="com.spring_hibernate" />
<!-- 配置sessionFactory的相关属性 -->
<property name="hibernateProperties">
  <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop> 
    <prop key="hibernate.show_sql">true</prop>
  </props>
</property>
</bean>
<!-- 获得一个hibernate事务管理对象 -->
<bean id="txManager" 
    class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 获得一个事物模板对象，通过事物模板对象来管理事务 -->
<bean id="txTemplate" 
        class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="txManager" />
</bean>
<!-- <bean class="org.springframework.dao.annotation.PersistenceTranslationPostProcessor" /> -->
<context:component-scan base-package="com.spring_hibernate" />
</beans>

contact对象的注解配置:

package com.spring_hibernate;

import java.sql.Timestamp;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="contact")
public class Contact {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
    private String name;
    private String sex;
    @Column(name="phone_number")
    private String phoneNumber;
    private String wechat;
    private Integer age;
    @Column(name="work_address")
    private String workAddress;
    @Column(name="home_address")
    private String homeAddress;
    private String description;
    @Column(name="creat_time")
    private Timestamp createTime;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getPhoneNumber() {
        return phoneNumber;
    }
    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    public String getWechat() {
        return wechat;
    }
    public void setWechat(String wechat) {
        this.wechat = wechat;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getWorkAddress() {
        return workAddress;
    }
    public void setWorkAddress(String workAddress) {
        this.workAddress = workAddress;
    }
    public String getHomeAddress() {
        return homeAddress;
    }
    public void setHomeAddress(String homeAddress) {
        this.homeAddress = homeAddress;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Timestamp getCreateTime(){
        return createTime;
    }
    public void setCreateTime(Timestamp createTime) {
        this.createTime = createTime;
    }
}

SpringHibernateService操作数据库的Dao服务类

该服务类对数据库的操作的事物管理使用的是编码事物

package com.spring_hibernate;

import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;

@Repository
public class SpringHibernateService {
    public static final Logger logger = Logger.getLogger(SpringHibernateService.class);
    //注入SessionFactory依赖,通过sessionFactory的openSession()
    //或者getCurrentSession()方法来获得一个Session对象.
    @Autowired
    private SessionFactory sessionFactory;
    @Autowired
    private TransactionTemplate txTemplate;

    //获得一个Session对象
    public Session currentSession() {
        return sessionFactory.getCurrentSession();
    }

    //向数据库持久化一个对象那个
    public void addContact(final Contact contact) {
        txTemplate.execute(new TransactionCallback<Void>(){
            public Void doInTransaction(TransactionStatus txStatus){
                try {
                    currentSession().save(contact);
                } catch (RuntimeException e) {
                    txStatus.setRollbackOnly();
                    throw e;
                }
                return null;
            }
        });

    }

    //删除一个数据库的一条记录
    public void deleteContact(final Contact contact) {
        System.out.println("删除了吗？");
        txTemplate.execute(new TransactionCallback<Void>(){
            public Void doInTransaction(TransactionStatus txStatus){
                try {
                    currentSession().delete(contact);
                } catch (RuntimeException e) {
                    txStatus.setRollbackOnly();
                    throw e;
                }
                return null;
            }
        });
        System.out.println("删除了成功了吗？");
    }

    //更改一条数据库记录
    public void updateContact(final Contact contact) {
        System.out.println("到這裡了嗎");
        txTemplate.execute(new TransactionCallback<Void>(){
            public Void doInTransaction(TransactionStatus txStatus){
                try {
                    currentSession().update(contact);
                } catch (RuntimeException e) {
                    txStatus.setRollbackOnly();
                    throw e;
                }
                return null;
            }
        });
        System.out.println("结束了吗");
    }

    //获得一条数据库记录
    public Contact getContact(Contact contact, final int id) {
        return txTemplate.execute(new TransactionCallback<Contact>(){
            public Contact doInTransaction(TransactionStatus txStatus){
                try {
                    return (Contact)currentSession().get(Contact.class, id);
                } catch (RuntimeException e) {
                    txStatus.setRollbackOnly();
                    throw e;
                }
            }
        });

    }
    @SuppressWarnings("deprecation")
    public Contact getContactByName(Contact contact, String name) {
        return (Contact) currentSession().createCriteria(Contact.class)
                .add(Restrictions.eq("name", name)).list().get(0);
    }
}

测试类：SpringHibernateTest：

package com.spring_hibernate;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringHibernateTest {
    @Test
    public void test() {
        @SuppressWarnings("resource")
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("com/spring_hibernate/hibernate.xml");
        SpringHibernateService service = 
                (SpringHibernateService)context.getBean("springHibernateService");
        Contact contact = new Contact();
        contact.setName("刘德华");
        contact.setSex("男");
        contact.setAge(58);
        contact.setPhoneNumber("13879681184");
        contact.setWechat("liudehua");
        contact.setWorkAddress("HongKong");
        contact.setHomeAddress("HongKong");
        contact.setDescription("Famouse Actor");
        //测试添加对象
        service.addContact(contact);

        //测试更改对象
        contact.setAge(80);
        service.updateContact(contact);

        //测试删除对象
        service.deleteContact(contact);

        //测试查找对象
        contact = service.getContact(contact, 34);
        System.out.println(contact.getId() + contact.getName() + 
                    contact.getSex() + contact.getAge());
    }
}

声明事物管理：

a.通过在xml中配置通知与Aop配置通知器切面来声明事物管理
.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation=
       "http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<context:component-scan base-package="com.spring_hibernate" />
<!-- 获得一个数据库连接池源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
<property name="initialSize" value="5" />
<property name="maxTotal" value="10" />
</bean>
<!-- 通过LocalSessionFactoryBean获得一个会话工厂 -->
<bean id="sessionFactory" 
    class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 通过扫描相应的包获得对象与数据库表的映射关系 -->
<property name="packagesToScan" value="com.spring_hibernate" />
<!-- 配置sessionFactory的相关属性 -->
<property name="hibernateProperties">
  <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop> 
    <prop key="hibernate.show_sql">true</prop>
  </props>
</property>
</bean>
<!-- 获得一个事务管理器对象 -->
<bean id="txManager"
        class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes >
    <tx:method name="get*" read-only="true" />
    <tx:method name="*" /> 
</tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut id="pt" 
        expression="execution(* com.spring_hibernate.SpringHibernateService.*(..))" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config>
</beans>

操作数据库的Dao类 SpringHibernateService：

package com.spring_hibernate;

import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class SpringHibernateService {
    public static final Logger logger = Logger.getLogger(SpringHibernateService.class);
    //注入SessionFactory依赖,通过sessionFactory的openSession()
    //或者getCurrentSession()方法来获得一个Session对象.
    @Autowired
    private SessionFactory sessionFactory;

    //获得一个Session对象
    public Session currentSession() {
        return sessionFactory.getCurrentSession();
    }

    //向数据库持久化一个对象那个
    public void addContact(final Contact contact) {
        currentSession().save(contact);
    }

    //删除一个数据库的一条记录
    public void deleteContact(final Contact contact) {
        currentSession().delete(contact);
    }

    //更改一条数据库记录
    public void updateContact(final Contact contact) {
        currentSession().update(contact);
    }

    //获得一条数据库记录
    public Contact getContact(Contact contact, final int id) {
        return (Contact)currentSession().get(Contact.class, id);

    }
    @SuppressWarnings("deprecation")
    public Contact getContactByName(Contact contact, String name) {
        return (Contact) currentSession().createCriteria(Contact.class)
                .add(Restrictions.eq("name", name)).list().get(0);
    }
}

b. 声明式事务管理(通过注解来配置通知与事物属性)

.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation=
       "http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<context:component-scan base-package="com.spring_hibernate" />
<!-- 获得一个数据库连接池源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/tongxunlu?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="10550205" />
<property name="initialSize" value="5" />
<property name="maxTotal" value="10" />
</bean>
<!-- 通过LocalSessionFactoryBean获得一个会话工厂 -->
<bean id="sessionFactory" 
    class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 通过扫描相应的包获得对象与数据库表的映射关系 -->
<property name="packagesToScan" value="com.spring_hibernate" />
<!-- 配置sessionFactory的相关属性 -->
<property name="hibernateProperties">
  <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop> 
    <prop key="hibernate.show_sql">true</prop>
  </props>
</property>
</bean>
<!-- 获得一个事务管理器对象 -->
<bean id="txManager"
        class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 通过注解配置声明式事务管理的事物属性和通知的方法 -->
<tx:annotation-driven transaction-manager="txManager"/>
<!-- <tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes >
    <tx:method name="get*" read-only="true" />
    <tx:method name="*" /> 
</tx:attributes>
</tx:advice> -->
<!-- <aop:config>
    <aop:pointcut id="pt" 
        expression="execution(* com.spring_hibernate.SpringHibernateService.*(..))" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config> -->
</beans>

操作数据库的Dao类 SpringHibernateService：

package com.spring_hibernate;

import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository
public class SpringHibernateService {
    public static final Logger logger = Logger.getLogger(SpringHibernateService.class);
    //注入SessionFactory依赖,通过sessionFactory的openSession()
    //或者getCurrentSession()方法来获得一个Session对象.
    @Autowired
    private SessionFactory sessionFactory;

    //获得一个Session对象
    public Session currentSession() {
        return sessionFactory.getCurrentSession();
    }

    //向数据库持久化一个对象那个
    @Transactional
    public void addContact(final Contact contact) {
        currentSession().save(contact);
    }

    //删除一个数据库的一条记录
    @Transactional
    public void deleteContact(final Contact contact) {
        currentSession().delete(contact);
    }

    //更改一条数据库记录
    @Transactional
    public void updateContact(final Contact contact) {
        currentSession().update(contact);
    }

    //获得一条数据库记录
    @Transactional(readOnly=true)
    public Contact getContact(Contact contact, final int id) {
        return (Contact)currentSession().get(Contact.class, id);

    }
    @SuppressWarnings("deprecation")
    @Transactional(readOnly=true)
    public Contact getContactByName(Contact contact, String name) {
        return (Contact) currentSession().createCriteria(Contact.class)
                .add(Restrictions.eq("name", name)).list().get(0);
    }
}