spring03-整合mybatis、声明式事务

最新推荐文章于 2025-03-26 12:44:15 发布
最新推荐文章于 2025-03-26 12:44:15 发布
阅读量141 收藏
点赞数
分类专栏： 框架 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46596508/article/details/116991481
版权

1整合Mybatis

1.1回忆Mybatis

步骤：

  1. 编写实体类【和数据库的表对应】【com.kuang.pojo】

    首先连接好数据库【右边栏】

    public class User {
    private int id;
    private String mname;
    private String pwd;
}

  2. 编写核心配置文件

  3. 编写接口Mapper【com.kuang.Dao】写一个实体类们就要对应一个Mapper，对应一个Mapper.xml。

    public interface UserMapper {
  public List<User> queryUser();
}

  4. 编写Mapper.xml文件【com.kuang.Dao】【要注册到核心配置文件】

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.UserMapper">
    <select id="queryUser" resultType="User">
        select * from mybatis.user
    </select>
</mapper>

  5. 测试

public void queryUser() throws IOException {
    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = mapper.queryUser();
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

注意要在pom.xml配置这个配置Maven静态资源过滤问题！

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

1.2Mybatis-Spring

引入Spring之前需要了解mybatis-spring包中的一些重要类；

http://www.mybatis.org/spring/zh/index.html

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

MyBatis-SpringMyBatisSpring 框架Spring BatchJava
2.03.5+5.0+4.0+Java 8+
1.33.4+3.2.2+2.1+Java 6+

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类

1数据源–通过bean来配置

id，class，四个内容，任意的数据源，可以是jdbc。

2 SqlSessionFactoryBean

【需要一个数据源，需要连接到mybatis的核心配置文件，还可以对核心配置文件进行修改】

  1. 在 MyBatis-Spring 中，可使用SqlSessionFactoryBean来创建 SqlSessionFactory。要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

    < id=“sqlSessionFactory” class=“org.mybatis.spring.SqlSessionFactoryBean”>

    注意：SqlSessionFactory需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

    在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。
    在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。

    SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

  2. **SqlSessionFactoryBean中的property的一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是 < settings> 或 < typeAliases>元素。

需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

另一个常用的属性是 mapperLocations，指定mapper的注册

3.SqlSessionTemplate

SqlSessionTemplate是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。

模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

**可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。**只能利用构造器注入sqlSessionFactory，因为他没有set方法

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean【自己创建的接口的实现类】 中添加一个 SqlSession 属性并在spring的配置文件注册bean。详见整合mybatis方式一的1.3.2的步骤5和6

1.3整合Mybatis方式1

1.3.1步骤1导入相关jar包

  • junit

    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

  • mybatis

    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>

  • mysql

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

  • spring，spring-jdbc【spring操作数据库的话需要】

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

  • aop【aspectJ 织入】

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

  • mybatis-spring【新的】

    Mybatis3.5+，Spring5.0+，对应的mybatis-spring用2.0版本

    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

注意：配置Maven静态资源过滤问题！

1.3.2编写配置文件

  1. 创建spring的一个配置文件spring-dao.xml专门来写整合mybatis的一些配置，其他关于类的bean的配置还是在beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd ">
</beans>

  2. 在spring的配置文件spring-dao.xml中配置数据源替换mybatis中的数据源【mybatis-config.xml就可以去掉配置数据源这块】

    【 datasource:使用spring的数据源spring提供的JDBC替换mybatis的配置c3p0 dbcp druid】

    通过bean，也是配置4个内容，class就是spring-jdbc包下的

    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="password" value="123456"/>
    <property name="username" value="root"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3386/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
</bean>

  3. 在spring的配置文件spring-dao.xml中配置SqlSessionFactory，并关联MyBatis的核心配置文件**，而且还可以在这里对核心配置文件进行操作，例如mapper的注册，别名，在这里写了以后就可以在核心配置文件删掉相应的配置。

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="datasource"/>
    <!--关联Mybatis-->
   <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/kuang/Dao/UserMapper.xml"/>
</bean>

  4. 在spring的配置文件spring-dao…xml中注册sqlSessionTemplate**【sqlSession的模板】，**关联sqlSessionFactory；

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

    至此，spring的spring-dao.xml整合mybatis的配置文件有了三个内容

    数据源+SqlSessionFactory+sqlSessionTemplate【就是sqlsession】

  5. 增加Dao接口的实现类；私有化sqlSessionTemplate，并添加set方法

    【之前的通过连接调用getmapper，mapper在调用接口里面的方法都是在测试里面做的，现在整合是写在类里面】

    【和之前mybatis的区别就是多了这个是实现类，现在直接在这个类里写，要用什么方法return一下】

    public class UserMapperImpl implements UserMapper{
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> queryUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       return mapper.queryUser();
    }
}

  6. 在spring的配置文件application.xml【或beans.xml】中注册bean实现**【因为5】

    里面私有化了sqlsession，它的ref就是上面的sqlsessionTemplate的id

    <bean id="userMapper" class="com.kuang.Dao.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

1.3.3测试【利用spring的测试步骤】

public class Mytest2 {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = userMapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

测试成功

小结：写一个接口，原来mybatis是写这个接口的xml文件，然后去核心配置文件注册mapper，最后测试

现在：写一个接口，再把核心配置文件的一些东西都写到spring的配置文件，再写接口的实现类（用sqlsession去得到mapper，返回一个接口的方法），最后把实现类通过getbean丢到spring中，测试的时候调spring就好了。

现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.kuang.pojo"/>
    </typeAliases>
</configuration>

可利用import把spring的关于整合mybatis的配置文件导入到mybatis的核心配置文件，

1.4整合Mybatis方式2

mybatis-spring1.2.3版以上的才有这个 .

dao的实现类继承SqlSessionDaoSupport类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory . 比起方式1 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看

img

修改步骤1：接口的实现类继承SqlSessionDaoSuppor且不用私有化sqlSessionTemplate

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> queryUser() {
   SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       return mapper.queryUser();
    }
}

不需要在实现的方法里面写具体的，只需要返回接口调用这个方法

修改步骤2：注册实现类的bean，里面没有sqlsession了，但还是要注入一下sqlSessionFactory，注意是ref不是value

<bean id="userMapper2" class="com.kuang.Dao.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

测试：

public class Mytest2 {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper2");
        List<User> userList = userMapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

2声明式事务

2.1回顾事务

  • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！
  • 事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID

原子性（atomicity）

事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

一致性（consistency）

一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

隔离性（isolation）

可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

持久性（durability）

事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中【数据库】

2.2准备工作

1新建一个模块，先把依赖导入到pom.xml

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
</dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

2建包，建类

【com.kuang.pojo】----User

public class User {
    private int id;
    private String mname;
    private String pwd;
}

【com.kuang.mapper】----UserMapper

public interface UserMapper {
  public List<User> queryUser();
}

写接口的xml文件，注意命名空间，方法id，返回值都得写对

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">
    <select id="queryUser" resultType="User">
        select * from mybatis.user
    </select>
</mapper>

3写mybatis的核心配置文件mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.kuang.pojo"/>
    </typeAliases>
</configuration>

4整合Mybatis—spring-dao.xml三部分【数据源，sqlsessionfactory，sqlsession】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd ">
      <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="password" value="123456"/>
        <property name="username" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3386/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/kuang/mapper/UserMapper.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
</beans>

5编写实现类实现接口–UserMapperImpl

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> queryUser() {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return  mapper.queryUser();
    }
}

6把这个实现类注入到spring的配置文件applicationContext.xml

<bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
    <property name="sqlSessionFactory " ref="sqlSessionFactory"/>
</bean>

由于他们整合到一起了，需要把spring-dao.xml配进来，因为最后测试的时候只放进去一个配置文件。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dkPlYh1H-1621323358233)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518005329332.png)]

点飘绿的那行的蓝色的字configure application context

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s3xI9SUm-1621323358235)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518005513230.png)]

同时在applicationContext.xml中导入spring-dao.xml

所以最终的applicationContext.xml是这样的

    <import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
    <property name="sqlSessionFactory " value="sqlSessionFactory"/>
</bean>

7测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = mapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

2.2测试事务必要性

在接口UserMapper中添加两个方法，并在接口的xml文件中添加sql实现，这里故意将delete写成deletes

public interface UserMapper {
  public List<User> queryUser();
  public  int addUser(User user);
  public  int deteleUser(int id);
}

<insert id="addUser" parameterType="User">
    insert into mybatis.user(id, mname, pwd) values(#{id},#{mname},#{pwd})
</insert>
<delete id="deteleUser" parameterType="int">
    deletes from mybatis.user where id=#{id}
</delete>

因为在接口中又添加了方法，所以接口的实现类也要添加这两个方法。并在原来的方法queryUser里面添加这两个方法，构成一个事务。

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> queryUser() {
        User user = new User(6, "lilei", "4554");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deteleUser(6);
        return  mapper.queryUser();

    }

    public int addUser(User user) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return  mapper.addUser(user);
    }

    public int deteleUser(int id) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.deteleUser(id);
    }
}

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = mapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

结果：SQL: deletes from mybatis.user where id=?发现这里错误，所以没有delete，但是还是把id为6的插入成功了；但是这样的结果不是我们想要的，就应该先插入在删除再查询是一个整体，所以就要考虑事务。

以前我们都需要自己手动管理事务，十分麻烦！

但是Spring给我们提供了事务管理，我们只需要配置即可；

2.3Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

  • 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
  • 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

  • 一般情况下比编程式事务好用。
  • 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
  • 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

2.4声明式事务管理

方法步骤

  1. 配置声明式事务【spring-dao.xml】-----配置事务管理器

    事务管理器

    • 无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。
    • 就是 Spring的核心事务管理抽象，管理封装了一组独立于技术的方法。

    标准配置，要开启spring的事务处理功能，在spring的配置文件创建一个DataSourceTransactionManager对象

    传入的datasource可以是任何能够与spring兼容的JDBC DataSource

    注意：为事务管理器指定的DataSource必须和用来创建SqlSessionFactoryBean的是同一个数据源，否则事务管理器无法工作。【就是这里的ref要和恰尼昂数据源的id一致】这里是个JDBC事务。

      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource"/>
   </bean>

  2. 配置事务通知【配置好事务管理器就要配置事务通知了，配置哪些方法使用什么样的事务,配置事务的传播特性】

    使用Spring管理事务，注意头文件的约束导入 : tx

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

    然后就可以使用tx标签了。

    补充：spring事务传播特性：

    事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

    propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。

    propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。

    propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。

    propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。

    propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

    propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。

    propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

    Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

    假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

    就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！
    注意：增删改是需要事务的，查不需要设为只读。

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="query" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

  3. 配置事务切入【利用AOP实现事务的织入】

    导入aop的头文件，然后使用aop标签

    xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
 <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
    //表示com.kuang.mapper这个包下的所有类的所有方法都可以切入这个事务

  4. 进行测试，先将上面插入的id为6的删除，不改变其他的操作

    public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = mapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

    结果：发现sql语句有错，但是这次没有将id为6增加到表中

为什么需要配置事务？

  • 如果不配置，可能会存在数据提交不一致的情况
  • 如果不配置声明式事务，就需要我们手动提交控制事务；
  • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！

注意注意：不要乱打空格

Spring07--整合Mybatis和声明式事务
优快云_SHY的博客
05-21 367
一、整合Mybatis mybatis-spring新包 环境搭建 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope
MyBatis3源码深度解析(二十七)MyBatis整合Spring框架
挑灯日记 记录自己
03-29 1338
通常情况下，我们并不会单独使用MyBatis框架，而是与Spring、SpringBoot等框架进行整合。MyBatis框架与Spring框架整合需要使用mybatis-spring模块。整合后，MyBatis中的Mapper动态代理对象会作为Spring框架的Bean注册到Spring容器中。
spring+mybatis之声明式事务管理实例
IT丶小污的博客
10-30 638
spring+mybatis之声明式事务管理实例 (原文地址：http://www.cnblogs.com/geningchao/p/6628452.html) 1.事务管理 　　理解事务管理之前，先通过一个例子讲一下什么是事务管理：取钱。  比如你去ATM机取1000块钱，大体有两个步骤：首先输入密码金额，银行卡扣掉1000元钱；然后A
springboot整合mybatis
最新发布
qq_44721704的博客
03-26 926
如果有Invalid bean definition with name 'userMapper' defined in file [...]解决办法是将依赖项里的mybatis变为3.0.3，我最开始的用的是3.0.0 应该是版本不兼容，调试了好久终于解决了。在application.properties中编辑代码如下。注意：username和password一定要写你自己的。在pom文件中的dependency中导入所需要的依赖。3.新建一个springboot项目。6.按照图中文件格式建立文件。
Spring--整合Mybatis及声明式事务
Learn to value time
01-26 227
1、整合MyBatis mybatis-spring官方文档 1.1、什么是 MyBatis-Spring？ MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。 它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的DataAccessException。 可以做到应用代码不依赖于 MyBatis，Spring 或 My
Spring框架学习06：整合Mybatis和声明式事务
我爱小小怪的博客
07-03 214
十、整合MyBatis 1.步骤 导入jar包 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>org.mybatis</groupId>
Spring-03 (整合 MyBatis)
S_numb的博客
02-26 379
文章目录1、MyBatis1.1 MyBatis 框架设计1.2 MyBatis 的主要架构及相互关系2、Spring 整合 MyBatis2.1 创建数据库与表2.2 创建 Maven 项目并添加依赖包2.3 新建 pojo 实体层2.4 新建 MyBatis SQL 映射层2.4.1 用户数据访问映射接口如下2.4.2 创建 MyBatis 的映射文件 UserMapper.xml3. 完成...
Spring 整合mybatis(注解&xml版声明式事务).pdf
04-09
Spring与MyBatis的整合，一方面利用Spring管理MyBatis的SqlSessionFactory和SqlSession，另一方面Spring通过AOP提供声明式事务管理，进一步简化了数据库操作代码。在声明式事务管理中，我们可以在业务逻辑方法上添加...
spring-mybatis:spring 整合 mybatis
05-19
Spring提供了声明式事务管理，可以在配置文件中启用事务管理器，并在Service层的方法上添加@Transactional注解，以确保事务的ACID属性。 ```xml <bean id="transactionManager" class="org.springframework.jdbc....
spring-boot-starter-mybatis-spring-boot-1.3.4.zip
04-19
Spring Boot默认使用`DataSourceTransactionManager`作为事务管理器，通过`@Transactional`注解可以声明式地控制事务的边界。 7. **性能优化** `spring-boot-starter-mybatis`还提供了缓存支持，可以利用MyBatis...
spring-mybatis-spring-1.2.0.zip
04-19
Spring的声明式事务管理允许我们在不编写任何事务管理代码的情况下，通过配置控制事务的边界。 二、Spring与MyBatis整合步骤 1. 引入依赖：在项目pom.xml中添加MyBatis-Spring和MyBatis的依赖。 2. 配置数据源：...
Mybatis-Spring1.0.0与Mybatis-Spring3.0.0版本在与spring整合时的区别
m0_73556978的博客
02-22 1029
Failed to convert property value of type 'java.lang.String' to required type 'org.apache.ibatis.session.Configuration' for property 'configuration'; Cannot convert value of type 'java.lang.String' to required type 'org.apache.ibatis.session.Configuration'
Dependency ‘org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3‘ not found
qq_51541555的博客
11-29 1737
file -> Settings -> Build,Execution,Deployment -> Build Tools -> Maven -> Importing
spring3+ mybatis出现的问题
robinpipi的专栏
08-11 5960
用spring3+mybaitis3做一个项目。 发现每次启动的时候，总是报mybatis.xml文件错误。 Document root element "mapper", must match DOCTYPE root "configuration" 后来才发现，原来
spring+mybatis的实现+声明式事务
LongKai_G
12-18 817
依赖 <dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <depe
Spring声明式事务控制、MyBatis介绍、动态SQL、多表操作
weixin_43584531的博客
03-25 1282
编程式事务控制相关对象 设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。  ISOLATION_DEFAULT  ISOLATION_READ_UNCOMMITTED  ISOLATION_READ_COMMITTED  ISOLATION_REPEATABLE_READ  ISOLATION_SERIALIZABLE 声明式事务控制 Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声.
MyBatis——13用mybatis实现银行转账
Re_view的博客
08-15 1388
用mybatis实现银行转账 要求 转账时,账户和密码不匹配跳转到错误信息页面 转账时,余额不足时跳转到错误信息页面 转账时,收款人帐号和姓名不匹配跳转到错误信息页面 如果转账成功: 修改账户余额以外还需要把操作记录到日志表中,同时还需要记录到log日志文件中. 日志文件中只需要记录哪个账户给哪个账户在什么时间转了多少钱 跳转到转账记录页面 代码实现 为了方便阅读，对于代码中的导包，以及一些没有阅...
Propagation Propagation的七种事务属性 七种事务属性 NOT_SUPPORTED REQUIRED
qq_44043843的博客
10-09 6831
Propagation类的七种事务属性解释（REQUIRED，SUPPORTS，MANDATORY，REQUIRES_NEW，NOT_SUPPORTED，NESTED，NEVER） Spring中七种Propagation类的事务属性详解： REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 required SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 supports MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值