• Spring修炼之路（5）整合MyBatis和事务

    一、整合MyBatis

    1.1相关jar包

    1.  <dependencies>
    2.         <dependency>
    3.             <groupId>org.springframeworkgroupId>
    4.             <artifactId>spring-webmvcartifactId>
    5.             <version>5.2.5.RELEASEversion>
    6.         dependency>
    7.         <dependency>
    8.             <groupId>org.springframeworkgroupId>
    9.             <artifactId>spring-jdbcartifactId>
    10.             <version>5.1.10.RELEASEversion>
    11.         dependency>
    12.         <dependency>
    13.             <groupId>org.mybatisgroupId>
    14.             <artifactId>mybatis-springartifactId>
    15.             <version>2.0.2version>
    16.         dependency>
    17.         <dependency>
    18.             <groupId>org.mybatisgroupId>
    19.             <artifactId>mybatisartifactId>
    20.             <version>3.5.2version>
    21.         dependency>
    22.         <dependency>
    23.             <groupId>mysqlgroupId>
    24.             <artifactId>mysql-connector-javaartifactId>
    25.             <version>5.1.47version>
    26.         dependency>
    27.         <dependency>
    28.             <groupId>junitgroupId>
    29.             <artifactId>junitartifactId>
    30.             <version>4.13.1version>
    31.             <scope>testscope>
    32.         dependency>
    33.         <dependency>
    34.             <groupId>org.projectlombokgroupId>
    35.             <artifactId>lombokartifactId>
    36.             <version>1.18.18version>
    37.             <scope>compilescope>
    38.         dependency>
    39.         
    40.         <dependency>
    41.             <groupId>org.aspectjgroupId>
    42.             <artifactId>aspectjweaverartifactId>
    43.             <version>1.9.4version>
    44.         dependency>
    45. <dependency>
    46.             <groupId>log4jgroupId>
    47.             <artifactId>log4jartifactId>
    48.             <version>1.2.17version>
    49.         dependency>
    50.     dependencies>

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

    1.   <build>
    2.         <resources>
    3.             <resource>
    4.                 <directory>src/main/resourcesdirectory>
    5.                 <includes>
    6.                     <include>**/*.propertiesinclude>
    7.                     <include>**/*.xmlinclude>
    8.                 includes>
    9.                 <filtering>truefiltering>
    10.             resource>
    11.             <resource>
    12.                 <directory>src/main/javadirectory>
    13.                 <includes>
    14.                     <include>**/*.propertiesinclude>
    15.                     <include>**/*.xmlinclude>
    16.                 includes>
    17.                 <filtering>truefiltering>
    18.             resource>
    19.         resources>
    20.     build>

    1.2编写环境

    pojo实体类

    1. package com.yanyu.pojo;
    2.  
    3. import lombok.Data;
    4.  
    5. @Data
    6. public class User {
    7.     private int id;  //id
    8.     private String name;   //姓名
    9.     private String pwd;   //密码
    10. }

    实现mybatis的配置文件 

    1. "1.0" encoding="UTF-8" ?>
    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     <properties resource="db.properties">
    7.  
    8.     properties>
    9.  
    10.     <settings>
    11.         <setting name="logImpl" value="LOG4J"/>
    12.         <setting name="mapUnderscoreToCamelCase" value="true"/>
    13.     settings>
    14.     <typeAliases>
    15.         <package name="com.yanyu.pojo"/>
    16.     typeAliases>
    17.     <environments default="development">
    18.         <environment id="development">
    19.             <transactionManager type="JDBC"/>
    20.             <dataSource type="POOLED">
    21.                 <property name="driver" value="${driver}"/>
    22.                 <property name="url" value="${url}"/>
    23.                 <property name="username" value="${username}"/>
    24.                 <property name="password" value="${password}"/>
    25.             dataSource>
    26.         environment>
    27.     environments>
    28.     <mappers>
    29.         <mapper class="com.yanyu.mapper.UserMapper"/>
    30.     mappers>
    31. configuration>
    1. #????DEBUG????????console?file???????console?file?????????
    2. log4j.rootLogger=DEBUG,console,file
    3.  
    4. #??????????
    5. log4j.appender.console = org.apache.log4j.ConsoleAppender
    6. log4j.appender.console.Target = System.out
    7. log4j.appender.console.Threshold=DEBUG
    8. log4j.appender.console.layout = org.apache.log4j.PatternLayout
    9. log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
    10.  
    11. #?????????
    12. log4j.appender.file = org.apache.log4j.RollingFileAppender
    13. log4j.appender.file.File=./log/kuang.log
    14. log4j.appender.file.MaxFileSize=10mb
    15. log4j.appender.file.Threshold=DEBUG
    16. log4j.appender.file.layout=org.apache.log4j.PatternLayout
    17. log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
    18.  
    19. #??????
    20. log4j.logger.org.mybatis=DEBUG
    21. log4j.logger.java.sql=DEBUG
    22. log4j.logger.java.sql.Statement=DEBUG
    23. log4j.logger.java.sql.ResultSet=DEBUG
    24. log4j.logger.java.sql.PreparedStatement=DEBUG
    1. driver=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
    3. username=root
    4. password=123456

    UserDao接口编写

    1. package com.yanyu.mapper;
    2.  
    3. import com.yanyu.pojo.User;
    4.  
    5. import java.util.List;
    6.  
    7. public interface UserMapper {
    8.     public List selectUser();
    9. }

    接口对应的Mapper映射文件

    1. "1.0" encoding="UTF-8" ?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.yanyu.mapper.UserMapper">
    6.  
    7.     <select id="selectUser" resultType="User">
    8.         select * from user1
    9.     select>
    10.  
    11. mapper>

    测试

    1. import com.yanyu.mapper.UserMapper;
    2. import com.yanyu.pojo.User;
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSession;
    5. import org.apache.ibatis.session.SqlSessionFactory;
    6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    7. import org.junit.Test;
    8.  
    9. import java.io.IOException;
    10. import java.io.InputStream;
    11. import java.util.List;
    12.  
    13. public class Mytest {
    14.     @Test
    15.     public void selectUser() throws IOException {
    16.  
    17.         String resource = "mybatis-config.xml";
    18.         InputStream inputStream = Resources.getResourceAsStream(resource);
    19.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    20.         SqlSession sqlSession = sqlSessionFactory.openSession();
    21.  
    22.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    23.  
    24.         List userList = mapper.selectUser();
    25.         for (User user: userList){
    26.             System.out.println(user);
    27.         }
    28.  
    29.         sqlSession.close();
    30.     }
    31. }

    1.3整合实现一

    • 定义 mybatis-config.xml 配置文件
    1. "1.0" encoding="UTF-8" ?>
    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    7.  
    9.  
    10.     <settings>
    11.         <setting name="logImpl" value="LOG4J"/>
    12.         <setting name="mapUnderscoreToCamelCase" value="true"/>
    13.     settings>
    14.     <typeAliases>
    15.         <package name="com.yanyu.pojo"/>
    16.     typeAliases>
    17.  
    18. configuration>
    • 定义 db.properties配置文件 
      1. jdbc.driver=com.mysql.jdbc.Driver
      2. jdbc.url=jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
      3. jdbc.username=root
      4. jdbc.password=b123456

    • 定义 spring- mybatis.xml 配置文件 [重 要！]
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:aop="http://www.springframework.org/schema/aop"
    5.        xmlns:context="http://www.springframework.org/schema/context"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.        http://www.springframework.org/schema/beans/spring-beans.xsd
    8.        http://www.springframework.org/schema/aop
    9.        http://www.springframework.org/schema/aop/spring-aop.xsd
    10.        http://www.springframework.org/schema/context
    11.        http://www.springframework.org/schema/context/spring-context.xsd">
    12.     <context:property-placeholder location="classpath:db.properties"/>
    13.     
    14.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    15.  
    16.         <property name="driverClassName" value="${jdbc.driver}"/>
    17.         <property name="url" value="${jdbc.url}"/>
    18.         <property name="username" value="${jdbc.username}"/>
    19.         <property name="password" value="${jdbc.password}"/>
    20.  
    21.     bean>
    22.  
    23.  
    24.  
    25.     
    26.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    27.         <property name="dataSource" ref="dataSource" />
    28.         
    29.         <property name="configLocation" value="classpath:mybatis-config.xml" />
    30.         <property name="mapperLocations" value="classpath:com/yanyu/mapper/*.xml" />
    31.     bean>
    32.  
    33.     
    34.     <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    35.         
    36.         <constructor-arg index="0" ref="sqlSessionFactory" />
    37.     bean>
    38.  
    39.     <bean id="userDao" class="com.yanyu.mapper.UserDaoImpl">
    40.         <property name="sqlSession" ref="sqlSession" />
    41.     bean>
    42. beans>

    测试

    1. import com.yanyu.mapper.UserMapper;
    2. import com.yanyu.pojo.User;
    3.  
    4. import org.junit.Test;
    5. import org.springframework.context.ApplicationContext;
    6. import org.springframework.context.support.ClassPathXmlApplicationContext;
    7.  
    8. import java.util.List;
    9.  
    10. public class Mytest {
    11.     @Test
    12.     public void test2(){
    13.         ApplicationContext context = new ClassPathXmlApplicationContext("mybatis-mapper.xml");
    14.         UserMapper mapper = (UserMapper) context.getBean("userDao");
    15.         List user = mapper.selectUser();
    16.         System.out.println(user);
    17.     }
    18. }

    1.4整合实现二

    UserDaoImpl修改一下

    1. public class UserDaoImpl2 extends SqlSessionDaoSupport implements UserMapper {
    2.     public List selectUser() {
    3.         UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
    4.         return mapper.selectUser();
    5.     }
    6. }

    修改bean的配置

    1. <bean id="userDao" class="com.yanyu.mapper.UserDaoImpl">
    2.         <property name="sqlSession" ref="sqlSession" />
    3.     bean>

    二、声明式事务

    事务四个属性ACID

    1. 原子性（atomicity）

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

    2. 一致性（consistency）

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

    3. 隔离性（isolation）

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

    4. 持久性（durability）

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

    测试

    1. //添加一个用户
    2. int addUser(User user);
    3.  
    4. //根据id删除用户
    5. int deleteUser(int id);

     mapper文件，我们故意把 deletes 写错，测试！

    1.  <insert id="addUser" parameterType="com.yanyu.pojo.User">
    2.         insert into user1 (id,name,pwd) values (#{id},#{name},#{pwd})
    3.     insert>
    4.  
    5.     <delete id="deleteUser" parameterType="int">
    6.         deletes from user1 where id = #{id}
    7.     delete>

    编写接口的实现类，在实现类中，我们去操作一波

    1.   public List selectUser() {
    2.         User user = new User(5,"小明","123456");
    3.         UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
    4.         mapper.addUser(user);
    5.         mapper.deleteUser(4);
    6.         return mapper.selectUser();
    7.     }
    8.  
    9.     //新增
    10.     public int addUser(User user) {
    11.         UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
    12.         return mapper.addUser(user);
    13.     }
    14.     //删除
    15.     public int deleteUser(int id) {
    16.         UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
    17.         return mapper.deleteUser(id);
    18.     }

    测试

    1. import com.yanyu.mapper.UserMapper;
    2. import com.yanyu.pojo.User;
    3.  
    4. import org.junit.Test;
    5. import org.springframework.context.ApplicationContext;
    6. import org.springframework.context.support.ClassPathXmlApplicationContext;
    7.  
    8. import java.util.List;
    9.  
    10. public class Mytest {
    11.  
    12.     @Test
    13.     public void test2(){
    14.         ApplicationContext context = new ClassPathXmlApplicationContext("mybatis-mapper.xml");
    15.         UserMapper mapper = (UserMapper) context.getBean("userDao");
    16.         List user = mapper.selectUser();
    17.         System.out.println(user);
    18.     }
    19. }

    Spring中的事务管理

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

    编程式事务管理

    • 将事务管理代码嵌到业务方法中来控制事务的提交和回滚

    • 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

    声明式事务管理

    • 一般情况下比编程式事务好用。

    • 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。

    • 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

    JDBC事务

    1. "transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    2.        "dataSource" ref="dataSource" />

    配置好事务管理器后我们需要去配置事务的通知

    2. <tx:advice id="txAdvice" transaction-manager="transactionManager">
    3.    <tx:attributes>
    4.        
    5.        <tx:method name="add" propagation="REQUIRED"/>
    6.        <tx:method name="delete" propagation="REQUIRED"/>
    7.        <tx:method name="update" propagation="REQUIRED"/>
    8.        <tx:method name="search*" propagation="REQUIRED"/>
    9.        <tx:method name="get" read-only="true"/>
    10.        <tx:method name="*" propagation="REQUIRED"/>
    11.    tx:attributes>
    12. tx:advice>

    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 的事务传播机制都工作在同一个事务中。

    就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！

    配置AOP

    导入aop的头文件！

    2. <aop:config>
    3.    <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>
    4.    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    5. aop:config>

    为什么需要配置事务？

    • 如果不配置，就需要我们手动提交控制事务；

    • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎

  • 相关阅读:
    elementui图片上传转为base64字符串
    单利润1680，月入3万+，拆解旅游卡源头批发的5种方式！
    GaN器件的工作原理
    Redis - 利用lua脚本控制密码错误次数超限，锁定账号
    【UNIAPP】踩坑问题记录（持续更新）
    Shell学习--Shell变量
    Java中String对象的replaceAll方法调用性能优化小技巧
    【英语：基础高阶_全场景覆盖表达】K6.口语主题陈述——人物类
    JAVA:实现Matrix Graphs矩阵图算法(附完整源码)
    腾讯视频共享设备ip会不会出现错误
  • 原文地址：https://blog.csdn.net/qq_62377885/article/details/133496250