声明式事务-整合Spring、Hibernate

光何

于 2021-01-07 14:20:58 发布

阅读量191

点赞数

分类专栏： M编程框架

本文链接：https://blog.csdn.net/GuangHEultimate/article/details/112308664

版权

M编程框架专栏收录该内容

24 篇文章 1 订阅

订阅专栏

编程式事务：通过编码的方式，让事务处理的代码侵入到核心的业务代码中。

声明式事务：完成了事务处理的代码和业务核心代码的解耦合。提供事务处理代码的复用性和降低维护成本。

声明式事务：aop最典型的应用。

使用动态代理实现事务的管理：

Jdk: 实现动态是通过实现某个特定的接口（代理类和目标类必须是相同的接口），产生一个虚拟的class文件(代理类的)。必须有接口的实现才能使用jdk完成动态代理

Cglib：动态代理，如果没有接口的实现使用cglib完成动态代理，使用了一个asm框架，完成某个类（目标类）的子类（虚拟的class文件）

Hibernate，spring 使用jdk的动态代理（默认情况），也可以使用cglig

1 新建java项目

进行spring+hibernate的集成：

使用IOC进行对象管理和注入

使用AOP进行事务的管理

2加入jar包

Spring的jar包

Hibernate的jar包

Dbcp的数据库连接池包（c3p0）

3 建立配置文件

在src目录下：

Hibernate.cfg.xml

applicationContext.xml

hibernate配置文件的内容：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库的运行环境 -->
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ssh
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- 数据库方言 -->
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <!-- hiberante 其他的属性 -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <!-- 加载映射文件 -->
        <mapping resource="org/guangsoft/pojo/Student.hbm.xml" />
    </session-factory>
</hibernate-configuration>

4建立Dao接口

package org.guangsoft.dao;
import org.guangsoft.pojo.Student;
/***
 * StudentDao接口
 * **/
public interface StudentDao
{
    public void addStudent(Student stu);
}

5建立Dao接口的实现类

package org.guangsoft.dao.impl;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.guangsoft.dao.StudentDao;
import org.guangsoft.pojo.Student;
/***
 * StudentDao接口的实现类，完成数据库的访问
 * HibernateDaoSupport：是spring完成对hibernate的支持
 * private HibernateTemplate hibernateTemplate;用来完成数据的crud操作
 * 给HibernateDaoSupport注入sessoinFactory
 * super.getSession();获得hibernate原始的session对象
 * ***/
public class StudentDaoImpl extends HibernateDaoSupport
implements StudentDao
{
    /***
     * 添加学生信息
     * ***/
    @Override
    public void addStudent(Student stu)
    {
        super.getHibernateTemplate().save(stu);
    }
}

6 建立service接口

package org.guangsoft.service;
import org.guangsoft.pojo.Student;
/** 建立用户service接口 ***/
public interface StudentService
{
    public void saveUser(Student stu);
}

7 建立service接口的实现类

package org.guangsoft.service.impl;
import org.guangsoft.dao.StudentDao;
import org.guangsoft.pojo.Student;
import org.guangsoft.service.StudentService;
public class StudentServiceImpl implements StudentService
{
    // 声明dao对象
    private StudentDao studentDao;
    public void setStudentDao(StudentDao studentDao)
    {
        this.studentDao = studentDao;
    }
    @Override
    public void saveUser(Student stu)
    {
        studentDao.addStudent(stu);
    }
}

8进行spring的配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- 到入xml文件的约束 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p"
    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-4.1.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-4.1.xsd
      http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
     ">
    <!-- 实例化一个SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 加载hibernate的配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
    </bean>
    <!-- 实例Dao对象 -->
    <bean id="studentDao" class="org.guangsoft.dao.impl.StudentDaoImpl">
        <!-- 注入sessionFactory -->
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 实例化service对象 -->
    <bean id="studentService" class="org.guangsoft.service.impl.StudentServiceImpl">
        <!-- 注入dao对象 -->
        <property name="studentDao" ref="studentDao"></property>
    </bean>
    <!-- 声明式事务：进行事务的配置 -->
    <!-- 1 实例化事务管理器对象 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <!-- 注入sessionFactory -->
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 2 进行事务特征的声明: 切面 id:用来完成切面在其他地方引用 transaction-manager：引用事务管理器对象 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- name:声明的是将哪些命名规范的方法，纳入事务管理 propagation：事务传播机制。 PROPAGATION_REQUIRED:
                如果存在一个事务，则支持当前事务。如果没有事务则开启 isolation：事务的隔离级别，是数据库平台默认的隔离级别 read-only:被刺事务操作的数据是只读的
                rollback-for=:异常的完全限定名，如果发生这样的异常进行回滚 -->
            <tx:method name="add*" propagation="REQUIRED" isolation="DEFAULT" />
            <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" />
            <tx:method name="update*" propagation="REQUIRED" isolation="DEFAULT" />
            <tx:method name="delete*" propagation="REQUIRED" isolation="DEFAULT" />
            <tx:method name="modf*" propagation="REQUIRED" isolation="DEFAULT" />
            <tx:method name="get*" propagation="REQUIRED" isolation="DEFAULT"
                read-only="true" />
            <tx:method name="select*" propagation="REQUIRED" isolation="DEFAULT"
                read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!-- 3进行AOP的配置 -->
    <aop:config>
        <!-- 声明切入点 -->
        <aop:pointcut expression="execution(* org.guangsoft.service.impl.*.*(..))"
            id="pc" />
        <!-- 进行织入 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc" />
    </aop:config>
</beans>

9添加事务的测试

package org.guangsoft.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.guangsoft.pojo.Student;
import org.guangsoft.service.StudentService;
public class TransactionTest
{
    @Test
    public void testTransaction()
    {
        // 加载spring的配置文件，获得bean容器
        ApplicationContext ac = new
        ClassPathXmlApplicationContext("applicationContext.xml");
        // 获得bean对象
        StudentService studentService = (StudentService) ac
                .getBean("studentService");
        Student stu = new Student();
        stu.setSname("小强");
        studentService.saveUser(stu);
    }
}

1 实例化事务管理器对象

2 声明事务切面（事务的特征）

3 进行aop的配置

光何

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
声明式事务-整合Spring、Hibernate

编程式事务：通过编码的方式，让事务处理的代码侵入到核心的业务代码中。声明式事务：完成了事务处理的代码和业务核心代码的解耦合。提供事务处理代码的复用性和降低维护成本。声明式事务：aop最典型的应用。使用动态代理实现事务的管理：Jdk: 实现动态是通过实现某个特定的接口（代理类和目标类必须是相同的接口），产生一个虚拟的class文件(代理类的)。必须有接口的实现才能使用jdk完成动态代理Cglib：动态代理，如果没有接口的实现使用cglib完成动态代理，使用了一个asm框架，完成某个类（目标
复制链接

扫一扫