【精选】Spring整合MyBatis，Junit 及Spring 事务Spring AOP面向切面详解

Spring整合MyBatis

在这里插入图片描述

搭建环境

我们知道使用MyBatis时需要写大量创建SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession等对象的代码，而Spring的作用是帮助我们创建和管理对象，所以我们可以使用Spring整合MyBatis，简化MyBatis开发。

创建maven项目，引入依赖。

<dependencies>
  <!--  mybatis  -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
  </dependency>
  <!--  mysql驱动包  -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
  </dependency>
  <!-- spring -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.13</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.13</version>
  </dependency>
  <!-- MyBatis与Spring的整合包，该包可以让Spring创建MyBatis的对象 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
  </dependency>
</dependencies>

编写配置文件

在这里插入图片描述

  1. 编写数据库配置文件db.properties

    jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///student
jdbc.username=root
jdbc.password=root

  2. 创建MyBatis配置文件SqlMapConfig.xml，数据源、扫描接口都交由Spring管理，不需要在MyBatis配置文件中设置。

    <?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>
    
</configuration>

  3. 创建Spring配置文件applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置扫描包-->
    <context:component-scan base-package="com.Spring"/>

    <!--读取配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--创建druid数据源对象-->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- Spring创建封装过的SqlSessionFactory -->
    <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- Spring创建封装过的SqlSession -->
    <bean name="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

准备数据库和实体类

准备数据库
CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) DEFAULT NULL,
 `sex` varchar(10) DEFAULT NULL,
 `address` varchar(255) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;


insert into `student`(`id`,`name`,`sex`,`address`) values (1,'李四','男','北京'),(2,'张三','女','北京');
准备实体类
public class Student {
  private int id;
  private String name;
  private String sex;
  private String address;
  
  // 省略构造方法/getter/setter/tostring
}

编写持久层接口和service类

编写持久层接口
@Repository
public interface StudentDao {
    //查询所有学生
    @Select("select * from student")
    List<Student> findAll();

    //添加学生
    @Insert("insert into student values (null,#{name},#{sex},#{address})")
    void add(Student student);
}
编写service类
@Service
public class StudentService {
    //SqlSession对象
    @Autowired
    private SqlSessionTemplate sqlSession;

    // 使用SqlSession获取代理对象
    public List<Student> findAllStudent(){
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        return studentDao.findAll();
    }
}

Spring整合Junit进行单元测试

之前进行单元测试时都需要手动创建Spring容器，能否在测试时让Spring自动创建容器呢？

  1. 引入Junit和Spring整合Junit依赖

    <!-- junit,如果Spring5整合junit，则junit版本至少在4.12以上 -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>
<!-- spring整合测试模块 -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.3.13</version>
</dependency>

  2. 编写测试类

    // JUnit使用Spring方式运行代码，即自动创建spring容器。
@RunWith(SpringJUnit4ClassRunner.class)
// 告知创建spring容器时读取哪个配置类或配置文件
// 配置类写法：@ContextConfiguration(classes=配置类.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest {
  @Autowired
  private StudentService studentService;
  
  @Test
  public void testFindAll(){
    List<Student> allStudent = studentService.findAllStudent();
    allStudent.forEach(System.out::println);
   }
}

注：使用SqlSessionTemplate创建代理对象还是需要注册接口或者映射文件的。

  1. 在MyBatis配置文件注册接口

    <configuration>
  <mappers>
    <mapper class="com.Spring.dao.StudentDao"></mapper>
  </mappers>
</configuration>

  2. 创建sqlSessionFactory时指定MyBatis配置文件

    <!-- 创建Spring封装过的SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource"></property>
  <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
</bean>

自动创建代理对象

Spring提供了MapperScannerConfigurer对象，该对象可以自动扫描包创建代理对象，并将代理对象放入容器中，此时不需要使用SqlSession手动创建代理对象。

  1. 创建MapperScannerConfigurer对象

    <!-- 该对象可以自动扫描持久层接口，并为接口创建代理对象 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <!-- 配置扫描的接口包 -->
  <property name="basePackage" value="com.Spring.dao"></property>
</bean>

  2. Service类直接使用代理对象即可

    @Service
public class StudentService {
  // 直接注入代理对象
  @Autowired
  private StudentDao studentDao;
 
  // 直接使用代理对象
  public void addStudent(Student student){
    studentDao.add(student);
   }
}

  3. 测试

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest {
  @Autowired
  private StudentService studentService;
  
   @Test
    public void testAddStudent(){
        Student student = new Student("郭家旗","男","上海");
        studentService.addStudent(student);
    }
}

SpringAOP

在这里插入图片描述

AOP简介

AOP的全称是Aspect Oriented Programming，即面向切面编程。是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

  • 作用：在不修改源码的基础上，对已有方法进行增强。
  • 实现原理：动态代理技术。
  • 优势：减少重复代码、提高开发效率、维护方便
  • 应用场景：事务处理、日志管理、权限控制、异常处理等方面。

AOP相关术语

为了更好地理解AOP，就需要对AOP的相关术语有一些了解

名称说明
Joinpoint（连接点）指能被拦截到的点，在Spring中只有方法能被拦截。
Pointcut（切点）指要对哪些连接点进行拦截，即被增强的方法。
Advice（通知）指拦截后要做的事情，即切点被拦截后执行的方法。
Aspect（切面）切点+通知称为切面
Target（目标）被代理的对象
Proxy（代理）代理对象
Weaving（织入）生成代理对象的过程

AOP入门

AspectJ是一个基于Java语言的AOP框架，在Spring框架中建议使用AspectJ实现AOP。

接下来我们写一个AOP入门案例：dao层的每个方法结束后都可以打印一条日志：

  1. 引入依赖

    <!-- spring -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.3.13</version>
</dependency>
<!-- AspectJ -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.7</version>
</dependency>
<!--  junit  -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

  2. 编写连接点

    @Repository
public class UserDao {
  public void add(){
    System.out.println("用户新增");
   }
  public void delete(){
    System.out.println("用户删除");
   }
  public void update(){
    System.out.println("用户修改");
   }
}

  3. 编写通知类

    public class MyAspectJAdvice {
  // 后置通知
  public void myAfterReturning() {
    System.out.println("打印日志...");
   }
}

  4. 配置切面

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    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
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop.xsd">


  <context:component-scan base-package="com.Spring"></context:component-scan>


  <!-- 通知对象 -->
  <bean id="myAspectJAdvice" class="com.Spring.advice.MyAspectAdvice"></bean>


  <!-- 配置AOP -->
  <aop:config>
    <!-- 配置切面 -->
    <aop:aspect ref="myAspectJAdvice">
      <!-- 配置切点 -->
      <aop:pointcut id="myPointcut" expression="execution(* com.Spring.dao.UserDao.*(..))"/>
      <!-- 配置通知 -->
      <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
    </aop:aspect>
  </aop:config>
</beans>

  5. 测试

    public class UserDaoTest {
  @Test
  public void testAdd(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    UserDao userDao = (UserDao) ac.getBean("userDao");
    userDao.add();
   }
  @Test
  public void testDelete(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    UserDao userDao = (UserDao) ac.getBean("userDao");
    userDao.delete();
   }
  @Test
  public void testUpdate(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    UserDao userDao = (UserDao) ac.getBean("userDao");
    userDao.update();
   }
}

通知类型

AOP有以下几种常用的通知类型：

通知类型描述
前置通知在方法执行前添加功能
后置通知在方法正常执行后添加功能
异常通知在方法抛出异常后添加功能
最终通知无论方法是否抛出异常，都会执行该通知
环绕通知在方法执行前后添加功能

  1. 编写通知方法

    // 通知类
public class MyAspectAdvice {
  // 后置通知
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println("切点方法名：" + joinPoint.getSignature().getName());
    System.out.println("目标对象：" + joinPoint.getTarget());
    System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
   }


  // 前置通知
  public void myBefore() {
    System.out.println("前置通知...");
   }


  // 异常通知
  public void myAfterThrowing(Exception ex) {
    System.out.println("异常通知...");
    System.err.println(ex.getMessage());
   }


  // 最终通知
  public void myAfter() {
    System.out.println("最终通知");
   }


  // 环绕通知
  public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕前");
    Object obj = proceedingJoinPoint.proceed(); // 执行方法
    System.out.println("环绕后");
    return obj;
   }
}

  2. 配置切面

    <!-- 配置AOP -->
<aop:config>
  <!-- 配置切面 -->
  <aop:aspect ref="myAspectJAdvice">
    <!-- 配置切点 -->
    <aop:pointcut id="myPointcut" expression="execution(* com.Spring.dao.UserDao.*(..))"/>
    <!-- 前置通知 -->
    <aop:before method="myBefore" pointcut-ref="myPointcut"></aop:before>
    <!-- 后置通知 -->
    <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
    <!-- 异常通知 -->
    <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointcut" throwing="ex"/>
    <!-- 最终通知 -->
    <aop:after method="myAfter" pointcut-ref="myPointcut"></aop:after>
    <!-- 环绕通知 -->
    <aop:around method="myAround" pointcut-ref="myPointcut"></aop:around>
  </aop:aspect>
</aop:config>

切点表达式

使用AspectJ需要使用切点表达式配置切点位置，写法如下：

  • 标准写法：访问修饰符 返回值 包名.类名.方法名(参数列表)
  • 访问修饰符可以省略。
  • 返回值使用*代表任意类型。
  • 包名使用*表示任意包，多级包结构要写多个*，使用*..表示任意包结构
  • 类名和方法名都可以用*实现通配。
  • 参数列表
    • 基本数据类型直接写类型
    • 引用类型写包名.类名
    • *表示匹配一个任意类型参数
    • ..表示匹配任意类型任意个数的参数
  • 全通配：* *..*.*(..)

多切面配置

我们可以为切点配置多个通知，形成多切面，比如希望dao层的每个方法结束后都可以打印日志并发送邮件：

  1. 编写发送邮件的通知：

    public class MyAspectJAdvice2 {
  // 后置通知
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println("发送邮件");
   }
}

  2. 配置切面：

    <!-- 通知对象 -->
<bean id="myAspectJAdvice" class="com.Spring.advice.MyAspectAdvice"></bean>
<bean id="myAspectJAdvice2" class="com.Spring.advice.MyAspectAdvice2"></bean>


<!-- 配置AOP -->
<aop:config>
  <!-- 配置切面 -->
  <aop:aspect ref="myAspectJAdvice">
    <!-- 配置切点 -->
    <aop:pointcut id="myPointcut" expression="execution(* *..*.*(..))"/>
    <!-- 后置通知 -->
    <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
  </aop:aspect>
  
  <aop:aspect ref="myAspectJAdvice2">
    <aop:pointcut id="myPointcut2" expression="execution(* com.Spring.dao.UserDao.*(..))"/>
    <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut2"/>
  </aop:aspect>
</aop:config>

注解配置AOP

Spring可以使用注解代替配置文件配置切面：

  1. 在xml中开启AOP注解支持

    <!-- 开启注解配置Aop -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  2. 在通知类上方加入注解@Aspect

  3. 在通知方法上方加入注解@Before/@AfterReturning/@AfterThrowing/@After/@Around

    @Aspect
@Component
public class MyAspectAdvice {
  // 后置通知
  @AfterReturning("execution(* com.Spring.dao.UserDao.*(..))")
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println("切点方法名：" + joinPoint.getSignature().getName());
    System.out.println("目标对象：" + joinPoint.getTarget());
    System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
   }


  // 前置通知
  @Before("execution(* com.Spring.dao.UserDao.*(..))")
  public void myBefore() {
    System.out.println("前置通知...");
   }


  // 异常通知
  @AfterThrowing(value = "execution(* com.Spring.dao.UserDao.*(..))",throwing = "ex")
  public void myAfterThrowing(Exception ex) {
    System.out.println("异常通知...");
    System.err.println(ex.getMessage());
   }


  // 最终通知
  @After("execution(* com.Spring.dao.UserDao.*(..))")
  public void myAfter() {
    System.out.println("最终通知");
   }


  // 环绕通知
  @Around("execution(* com.Spring.dao.UserDao.*(..))")
  public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕前");
    Object obj = proceedingJoinPoint.proceed(); // 执行方法
    System.out.println("环绕后");
    return obj;
   }
}

  4. 测试：

    @Test
public void testAdd2(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
  UserDao userDao = (UserDao) ac.getBean("userDao");
  userDao.update();
}

如何为一个类下的所有方法统一配置切点：

  1. 在通知类中添加方法配置切点

    @Pointcut("execution(* com.Spring.dao.UserDao.*(..))")
public void pointCut(){}

  2. 在通知方法上使用定义好的切点

    @Before("pointCut()")
public void myBefore(JoinPoint joinPoint) {
  System.out.println("前置通知...");
}

    @AfterReturning(“pointCut()”)
    public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println(“后置通知…”);
    }

配置类如何代替xml中AOP注解支持？

在配置类上方添加@EnableAspectJAutoProxy即可

@Configuration
@ComponentScan("com.Spring")
@EnableAspectJAutoProxy
public class SpringConfig {

}

原生Spring实现AOP

除了AspectJ，Spring支持原生方式实现AOP。

  1. 引入依赖

    <!-- AOP -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.3.13</version>
</dependency>

  2. 编写通知类

    // Spring原生Aop的通知类
public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice, ThrowsAdvice, MethodInterceptor {
  /**
   * 前置通知
   * @param method 目标方法
   * @param args 目标方法的参数列表
   * @param target 目标对象
   * @throws Throwable
   */
  @Override
  public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println("前置通知");
   }


  /**
   * 后置通知
   * @param returnValue 目标方法的返回值
   * @param method 目标方法
   * @param args 目标方法的参数列表
   * @param target 目标对象
   * @throws Throwable
   */
  @Override
  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("后置通知");
   }


  /**
   * 环绕通知
   * @param invocation 目标方法
   * @return
   * @throws Throwable
   */
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    System.out.println("环绕前");
    Object proceed = invocation.proceed();
    System.out.println("环绕后");
    return proceed;
   }


  /**
   * 异常通知
   * @param ex 异常对象
   */
  public void afterThrowing(Exception ex){
    System.out.println("发生异常了！");
   }
}

    Spring原生方式实现AOP时，只支持四种通知类型：

    通知类型实现接口
    前置通知MethodBeforeAdvice
    后置通知AfterReturningAdvice
    异常通知ThrowsAdvice
    环绕通知MethodInterceptor

  3. 编写配置类

    <!-- 通知对象 -->
<bean id="springAop" class="com.Spring.advice.SpringAop"></bean>


<!-- 配置代理对象 -->
<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  <!-- 配置目标对象 -->
  <property name="target" ref="userDao"></property>
  <!-- 配置通知 -->
  <property name="interceptorNames">
    <list>
      <value>springAop</value>
    </list>
  </property>
  <!-- 代理对象的生成方式  true：使用CGLib false：使用原生JDK生成-->
  <property name="proxyTargetClass" value="true"></property>
</bean>

  4. 编写测试类

    public class UserDaoTest2 {
  @Test
  public void testAdd(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean2.xml");
    UserDao userDao = (UserDao) ac.getBean("userDaoProxy"); // 获取的是代理对象
    userDao.update();
   }
}

SchemaBased实现AOP

SchemaBased(基础模式)配置方式是指使用Spring原生方式定义通知，而使用AspectJ框架配置切面。

  1. 编写通知类

    public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice, ThrowsAdvice, MethodInterceptor {
  /**
   * 前置通知
   * @param method 目标方法
   * @param args 目标方法的参数列表
   * @param target 目标对象
   * @throws Throwable
   */
  @Override
  public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println("前置通知");
   }


  /**
   * 后置通知
   * @param returnValue 目标方法的返回值
   * @param method 目标方法
   * @param args 目标方法的参数列表
   * @param target 目标对象
   * @throws Throwable
   */
  @Override
  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("后置通知");
   }


  /**
   * 环绕通知
   * @param invocation 目标方法
   * @return
   * @throws Throwable
   */
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    System.out.println("环绕前");
    Object proceed = invocation.proceed();
    System.out.println("环绕后");
    return proceed;
   }


  /**
   * 异常通知
   * @param ex 异常对象
   */
  public void afterThrowing(Exception ex){
    System.out.println("发生异常了！");
   }
}

  2. 配置切面

    <!-- 通知对象 -->
<bean id="springAop2" class="com.Spring.aop.SpringAop2"/>


<!-- 配置切面 -->
<aop:config>
  <!-- 配置切点-->
  <aop:pointcut id="myPointcut" expression="execution(* com.Spring.dao.UserDao.*(..))"/>
  <!-- 配置切面：advice-ref：通知对象 pointcut-ref：切点 -->
  <aop:advisor advice-ref="springAop2" pointcut-ref="myPointcut"/>
</aop:config>

  3. 测试

    @Test
public void t6(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("aop3.xml");
  UserDao userDao = (UserDao) ac.getBean("userDao");
  userDao.add();
}

Spring事务

在这里插入图片描述

事务简介

事务：不可分割的原子操作。即一系列的操作要么同时成功，要么同时失败。

开发过程中，事务管理一般在service层，service层中可能会操作多次数据库，这些操作是不可分割的。否则当程序报错时，可能会造成数据异常。

如：张三给李四转账时，需要两次操作数据库：张三存款减少、李四存款增加。如果这两次数据库操作间出现异常，则会造成数据错误。

  1. 准备数据库

    CREATE DATABASE `spring` ;
USE `spring`;
DROP TABLE IF EXISTS `account`;


CREATE TABLE `account` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `username` varchar(255) DEFAULT NULL,
 `balance` double DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;


insert into `account`(`id`,`username`,`balance`) values (1,'张三',1000),(2,'李四',1000);

  2. 创建maven项目，引入依赖

    <dependencies>
  <!--  mybatis  -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
  </dependency>
  <!--  mysql驱动包  -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
  </dependency>
  <!--  druid连接池  -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
  </dependency>
  <!-- spring -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.13</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.13</version>
  </dependency>
  <!-- MyBatis与Spring的整合包，该包可以让Spring创建MyBatis的对象 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
  </dependency>


  <!-- junit,如果Spring5整合junit，则junit版本至少在4.12以上 -->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
  <!-- spring整合测试模块 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.13</version>
    <scope>test</scope>
  </dependency>
</dependencies>

  3. 创建配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    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
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd">
  <!-- 包扫描 -->
  <context:component-scan base-package="com.Spring"></context:component-scan>
  <!-- 创建druid数据源对象 -->
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
  </bean>


  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
  </bean>


  <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.Spring.dao"></property>
  </bean>
</beans>

  4. 编写Java代码

    // 账户
public class Account {
  private int id; // 账号
  private String username; // 用户名
  private double balance; // 余额
  
  // 省略getter/setter/tostring/构造方法
}


@Repository
public interface AccountDao {
  // 根据id查找用户
  @Select("select * from account where id = #{id}")
  Account findById(int id);


  // 修改用户
  @Update("update account set balance = #{balance} where id = #{id}")
  void update(Account account);
}


@Service
public class AccountService {
  @Autowired
  private AccountDao accountDao;


  /**
   * 转账
   * @param id1 转出人id
   * @param id2 转入人id
   * @param price 金额
   */
  public void transfer(int id1, int id2, double price) {
    // 转出人减少余额
    Account account1 = accountDao.findById(id1);
    account1.setBalance(account1.getBalance()-price);
    accountDao.update(account1);


    int i = 1/0; // 模拟程序出错


    // 转入人增加余额
    Account account2 = accountDao.findById(id2);
    account2.setBalance(account2.getBalance()+price);
    accountDao.update(account2);
   }
}

  5. 测试转账

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class AccountServiceTest {
  @Autowired
  private AccountService accountService;


  @Test
  public void testTransfer(){
    accountService.transfer(1,2,500);
   }
}

此时没有事务管理，会造成张三的余额减少，而李四的余额并没有增加。所以事务处理位于业务层，即一个service方法是不能分割的。

Spring事务管理方案

在service层手动添加事务可以解决该问题：

@Autowired
private SqlSessionTemplate sqlSession;


public void transfer(int id1, int id2, double price) {
  try{
    // account1修改余额
    Account account1 = accountDao.findById(id1);
    account1.setBalance(account1.getBalance()-price);
    accountDao.update(account1);


    int i = 1/0; // 模拟转账出错


    // account2修改余额
    Account account2 = accountDao.findById(id2);
    account2.setBalance(account2.getBalance()+price);
    accountDao.update(account2); 
    sqlSession.commit();
   }catch(Exception ex){
    sqlSession.rollback();
   }
}

但在Spring管理下不允许手动提交和回滚事务。此时我们需要使用Spring的事务管理方案，在Spring框架中提供了两种事务管理方案：

  1. 编程式事务：通过编写代码实现事务管理。
  2. 声明式事务：基于AOP技术实现事务管理。

在Spring框架中，编程式事务管理很少使用，我们对声明式事务管理进行详细学习。

Spring的声明式事务管理在底层采用了AOP技术，其最大的优点在于无需通过编程的方式管理事务，只需要在配置文件中进行相关的规则声明，就可以将事务规则应用到业务逻辑中。

使用AOP技术为service方法添加如下通知：

Spring事务管理器

Spring依赖事务管理器进行事务管理，事务管理器即一个通知类，我们为该通知类设置切点为service层方法即可完成事务自动管理。由于不同技术操作数据库，进行事务操作的方法不同。如：JDBC提交事务是connection.commit()，MyBatis提交事务是sqlSession.commit()，所以Spring提供了多个事务管理器。

事务管理器名称作用
org.springframework.jdbc.datasource.DataSourceTransactionManager针对JDBC技术提供的事务管理器。适用于JDBC和MyBatis。
org.springframework.orm.hibernate3.HibernateTransactionManager针对于Hibernate框架提供的事务管理器。适用于Hibernate框架。
org.springframework.orm.jpa.JpaTransactionManager针对于JPA技术提供的事务管理器。适用于JPA技术。
org.springframework.transaction.jta.JtaTransactionManager跨越了多个事务管理源。适用在两个或者是多个不同的数据源中实现事务控制。

我们使用MyBatis操作数据库，接下来使用DataSourceTransactionManager进行事务管理。

  1. 引入依赖

    <!-- 事务管理 -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.3.13</version>
</dependency>
<!-- AspectJ -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.7</version>
</dependency>

  2. 在配置文件中引入约束

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


http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd

  3. 进行事务配置

    <!-- 事务管理器  -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"></property>
</bean>


<!-- 进行事务相关配置 -->
<tx:advice id = "txAdvice">
  <tx:attributes>
    <tx:method name="*"/>
  </tx:attributes>
</tx:advice>


<!-- 配置切面 -->
<aop:config>
  <!-- 配置切点 -->
  <aop:pointcut id="pointcut" expression="execution(* com.Spring.service.*.*(..))"/>
  <!-- 配置通知 -->
  <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
</aop:config>

事务控制的API

Spring进行事务控制的功能是由三个接口提供的，这三个接口是Spring实现的，在开发中我们很少使用到，只需要了解他们的作用即可：

PlatformTransactionManager接口

PlatformTransactionManager是Spring提供的事务管理器接口，所有事务管理器都实现了该接口。该接口中提供了三个事务操作方法：

  • TransactionStatus getTransaction（TransactionDefinition definition）：获取事务状态信息。
  • void commit（TransactionStatus status）：事务提交
  • void rollback（TransactionStatus status）：事务回滚
TransactionDefinition接口

TransactionDefinition是事务的定义信息对象，它有如下方法：

  • String getName()：获取事务对象名称。
  • int getIsolationLevel()：获取事务的隔离级别。
  • int getPropagationBehavior()：获取事务的传播行为。
  • int getTimeout()：获取事务的超时时间。
  • boolean isReadOnly()：获取事务是否只读。
TransactionStatus接口

TransactionStatus是事务的状态接口，它描述了某一时间点上事务的状态信息。它有如下方法：

  • void flush() 刷新事务
  • boolean hasSavepoint() 获取是否存在保存点
  • boolean isCompleted() 获取事务是否完成
  • boolean isNewTransaction() 获取是否是新事务
  • boolean isRollbackOnly() 获取是否回滚
  • void setRollbackOnly() 设置事务回滚

事务的相关配置

在<tx:advice>中可以进行事务的相关配置：

<tx:advice id="txAdvice">
  <tx:attributes>
    <tx:method name="*"/>
    <tx:method name="find*" read-only="true"/>
  </tx:attributes>
</tx:advice>

<tx:method>中的属性：

  • name：指定配置的方法。*表示所有方法，find*表示所有以find开头的方法。
  • read-only：是否是只读事务，只读事务不存在数据的修改，数据库将会为只读事务提供一些优化手段，会对性能有一定提升，建议在查询中开启只读事务。
  • timeout：指定超时时间，在限定的时间内不能完成所有操作就会抛异常。默认永不超时
  • rollback-for：指定某个异常事务回滚，其他异常不回滚。默认所有异常回滚。
  • no-rollback-for：指定某个异常不回滚，其他异常回滚。默认所有异常回滚。
  • propagation：事务的传播行为
  • isolation：事务的隔离级别

事务的传播行为

事务传播行为是指多个含有事务的方法相互调用时，事务如何在这些方法间传播。

如果在service层的方法中调用了其他的service方法，假设每次执行service方法都要开启事务，此时就无法保证外层方法和内层方法处于同一个事务当中。

// method1的所有方法在同一个事务中
public void method1(){
  // 此时会开启一个新事务，这就无法保证method1()中所有的代码是在同一个事务中
  method2();
  System.out.println("method1");
}


public void method2(){
  System.out.println("method2");
}

事务的传播特性就是解决这个问题的，Spring帮助我们将外层方法和内层方法放入同一事务中。

传播行为介绍
REQUIRED默认。支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。
MANDATORY支持当前事务，如果当前没有事务，就抛出异常。
REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED必须在事务状态下执行，如果没有事务则新建事务，如果当前有事务则创建一个嵌套事务

事务的隔离级别

事务隔离级别反映事务提交并发访问时的处理态度，隔离级别越高，数据出问题的可能性越低，但效率也会越低。

隔离级别脏读不可重复读幻读
READ_UNCOMMITTED（读取未提交内容）YesYesYes
READ_COMMITTED（读取提交内容）NoYesYes
REPEATABLE_READ（重复读）NoNoYes
SERIALIZABLE（可串行化）NoNoNo

如果设置为DEFAULT会使用数据库的隔离级别。

  • SqlServer , Oracle默认的事务隔离级别是READ_COMMITTED
  • Mysql的默认隔离级别是REPEATABLE_READ

注解配置声明式事务

Spring支持使用注解配置声明式事务。用法如下：

  1. 注册事务注解驱动

    <!-- 注册事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

  2. 在需要事务支持的方法或类上加@Transactional

    @Service
// 作用于类上时，该类的所有public方法将都具有该类型的事务属性
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
public class AccountService {
  @Autowired
  private AccountDao accountDao;


  /**
   * 转账
   * @param id1 转出人id
   * @param id2 转入人id
   * @param price 金额
   */
  // 作用于方法上时，该方法将都具有该类型的事务属性
  @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
  public void transfer(int id1, int id2, double price) {
    // account1修改余额
    Account account1 = accountDao.findById(id1);
    account1.setBalance(account1.getBalance()-price);
    accountDao.update(account1);


    int i = 1/0; // 模拟转账出错


    // account2修改余额
    Account account2 = accountDao.findById(id2);
    account2.setBalance(account2.getBalance()+price);
    accountDao.update(account2);
   }
}

  3. 配置类代替xml中的注解事务支持：在配置类上方写@EnableTranscationManagement

    @Configuration
@ComponentScan("com.Spring")
@EnableTransactionManagement
public class SpringConfig {


  @Bean
  public DataSource getDataSource(){
    DruidDataSource druidDataSource = new DruidDataSource();
    druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
    druidDataSource.setUrl("jdbc:mysql:///spring");
    druidDataSource.setUsername("root");
    druidDataSource.setPassword("root");
    return druidDataSource;
   }


  @Bean
  public SqlSessionFactoryBean getSqlSession(DataSource dataSource){
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);
    return sqlSessionFactoryBean;
   }


  @Bean
  public MapperScannerConfigurer getMapperScanner(){
    MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
    mapperScannerConfigurer.setBasePackage("com.Spring.dao");
    return mapperScannerConfigurer;
   }


  @Bean
  public DataSourceTransactionManager getTransactionManager(DataSource dataSource){
    DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
    dataSourceTransactionManager.setDataSource(dataSource);
    return dataSourceTransactionManager;
   }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/202747.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Web端CAD/CAE文字标注】webgl+canvas 2d实现文字标注功能

【Web端CAD/CAE文字标注】webgl+canvas 2d实现文字标注功能

一、需求背景 在CAD/CAE领域经常会遇到显示节点编号这种需求&#xff0c;效果如下图&#xff1a; 本文介绍如何在WebGL中实现文字的显示&#xff0c;对于如何在OpenGL中实现请绕路。 二、实现原理 Canvas是HTML5提供的元素&#xff0c;用于在网页上绘制图形&#xff0c;其支…
阅读更多...
elasticsearch DSL语句

elasticsearch DSL语句

目录 一、DSL查询文档1.1 DSL查询分类1.2 全文检索查询1.3 精确查询1.4 地理坐标查询1.5 复合查询1.5.1 相关性算分1.5.2 算分函数查询1.5.3 布尔查询 二、搜索结果处理2.1 排序2.2 分页2.3 高亮2.4 总结 三、RestClient查询文档3.1 查询所有3.2 match查询3.3 精确查询3.4 布尔…
阅读更多...
PyMuPDF---Python处理PDF的宝藏库详解

PyMuPDF---Python处理PDF的宝藏库详解

1、PyMuPDF简介 1.1 介绍 在介绍PyMuPDF之前&#xff0c;先来了解一下MuPDF&#xff0c;从命名形式中就可以看出&#xff0c;PyMuPDF是MuPDF的Python接口形式。 MuPDF MuPDF 是一个轻量级的 PDF、XPS和电子书查看器。MuPDF 由软件库、命令行工具和各种平台的查看器组成。 …
阅读更多...
C语言进阶之笔试题详解（2）

C语言进阶之笔试题详解（2）

前言 这里的内容包括二维数组笔试题和指针笔试题&#xff0c;供给读者对这部分知识进行加深和巩固。 ✨ 猪巴戒&#xff1a;个人主页✨ 所属专栏&#xff1a;《C语言进阶》 &#x1f388;跟着猪巴戒&#xff0c;一起学习C语言&#x1f388; 目录 前言 笔试题 二维数组 题目…
阅读更多...
借助文档控件Aspose.Words，在 C# 中比较两个 PDF 文件

借助文档控件Aspose.Words，在 C# 中比较两个 PDF 文件

在当今的数字世界中&#xff0c;管理和比较文档是一项至关重要的任务&#xff0c;尤其是在商业和法律领域。在 C# 中处理 PDF 文档时&#xff0c;Aspose.Words for .NET 提供了用于比较 PDF 文档的强大解决方案。在这篇博文中&#xff0c;我们将探讨如何在 C# 应用程序中比较 P…
阅读更多...
MySQL进阶-读写分离

MySQL进阶-读写分离

✨作者&#xff1a;猫十二懿 ❤️‍&#x1f525;账号&#xff1a;CSDN 、掘金 、语雀 、Github &#x1f389;公众号&#xff1a;猫十二懿 一、MySQL 读写分离介绍 读写分离,简单地说是把对数据库的读和写操作分开&#xff0c;以对应不同的数据库服务器。主数据库提供写操作&…
阅读更多...
从零开始的c语言日记day38——数组参数，指针参数

从零开始的c语言日记day38——数组参数，指针参数

一维数组传参 要把数组或者指针传给函数&#xff0c;那函数参数如何设计&#xff1f; 上面各写法有问题嘛&#xff1f; 第一个没问题 第二个没问题 第三个没问题 第四个没问题 第五个解析&#xff1a;定义int*arr2[20]为20个int*类型的数组&#xff0c;test2之后用的是ar…
阅读更多...
Kubernetes（K8s）资源管理-03

Kubernetes（K8s）资源管理-03

资源管理 资源管理介绍 在kubernetes中&#xff0c;所有的内容都抽象为资源&#xff0c;用户需要通过操作资源来管理kubernetes。 kubernetes的本质上就是一个集群系统&#xff0c;用户可以在集群中部署各种服务&#xff0c;所谓的部署服务&#xff0c;其实就是在kubernetes集…
阅读更多...
NoSQL大数据存储技术思考题及参考答案

NoSQL大数据存储技术思考题及参考答案

思考题及参考答案 第1章 绪论 1. NoSQL和关系型数据库在设计目标上有何主要区别&#xff1f; (1)关系数据库 优势&#xff1a;以完善的关系代数理论作为基础&#xff0c;具有数据模型、完整性约束和事务的强一致性等特点&#xff0c;借助索引机制可以实现高效的查询&#xf…
阅读更多...
Clickhouse Join

Clickhouse Join

ClickHouse中的Hash Join, Parallel Hash Join, Grace Hash Join https://www.cnblogs.com/abclife/p/17579883.html 总结 本文描述并比较了ClickHouse中基于内存哈希表的3种连接算法。 哈希连接算法速度快&#xff0c;是最通用的算法&#xff0c;支持所有连接类型和严格性设…
阅读更多...
TCP/IP封装

TCP/IP封装

数据如何通过网络发送&#xff1f;为什么 OSI 模型需要这么多层&#xff1f; 下图显示了数据在网络传输时如何封装和解封装。 步骤1&#xff1a;当设备A通过HTTP协议通过网络向设备B发送数据时&#xff0c;首先在应用层添加HTTP头。 步骤2&#xff1a;然后将TCP或UDP标头添加…
阅读更多...
Hadoop入门学习笔记

Hadoop入门学习笔记

视频课程地址&#xff1a;https://www.bilibili.com/video/BV1WY4y197g7 课程资料链接&#xff1a;https://pan.baidu.com/s/15KpnWeKpvExpKmOC8xjmtQ?pwd5ay8 这里写目录标题 一、VMware准备Linux虚拟机1.1. VMware安装Linux虚拟机1.1.1. 修改虚拟机子网IP和网关1.1.2. 安装…
阅读更多...
Modbus TCP工业RFID读写器的选型要点

Modbus TCP工业RFID读写器的选型要点

Modbus TCP工业RFID读写器是一种采用Modbus TCP通信协议的RFID读写器。它可以通过TCP/IP网络与计算机或其它设备进行通信&#xff0c;实现远程读取和写入RFID标签数据的目的。 与传统的RFID读写器相比&#xff0c;Modbus TCP工业RFID读写器具有更远的读写距离、更高的读写灵敏度…
阅读更多...
uniapp如何与原生应用进行混合开发？

uniapp如何与原生应用进行混合开发？

目录 前言 1.集成Uniapp 2.与原生应用进行通信 3.实现原生功能 4.使用原生UI组件 结论: 前言 随着移动应用市场的不断发展&#xff0c;使用原生开发的应用已经不能满足用户的需求&#xff0c;而混合开发成为了越来越流行的选择。其中&#xff0c;Uniapp作为一种跨平台的开…
阅读更多...
系统设计概念：生产 Web 应用的架构

系统设计概念：生产 Web 应用的架构

在你使用的每个完美应用程序背后&#xff0c;都有一整套的架构、测试、监控和安全措施。今天&#xff0c;让我们来看看一个生产就绪应用程序的非常高层次的架构。 CI/CD 管道 我们的第一个关键领域是持续集成和持续部署——CI/CD 管道。 这确保我们的代码从存储库经过一系列测试…
阅读更多...
开发知识点-Maven包管理工具

开发知识点-Maven包管理工具

Maven包管理工具 SpringBootSpringSecuritydubbo图书电商后台实战-环境设置&#xff08;JDK8, STS, Maven, Spring IO, Springboot&#xff09;点餐小程序Java版本的选择和maven仓库的配置视频管理系统&&使用maven-tomcat7插件运行web工程SpringTool suite——maven项目…
阅读更多...
promis.all的异步使用

promis.all的异步使用

基础 参考 https://blog.csdn.net/qq_52855464/article/details/125376557 简单来说 Promise.all是处理接口返回方法异步的&#xff0c;能够使得接口的获取顺序得到控制&#xff0c;不会出现数据为空的情况 使用 先执行jianshigetGroups->groupIds-> const promises2 …
阅读更多...
RNN-T Training，RNN-T模型训练详解——语音信号处理学习（三）（选修三）

RNN-T Training，RNN-T模型训练详解——语音信号处理学习（三）（选修三）

参考文献&#xff1a; Speech Recognition (option) - RNN-T Training哔哩哔哩bilibili 2020 年 3月 新番 李宏毅 人类语言处理 独家笔记 Alignment Train - 8 - 知乎 (zhihu.com) 本次省略所有引用论文 目录 一、如何将 Alignment 概率加和 对齐方式概率如何计算 概率加和计…
阅读更多...
什么是PDM图纸管理系统？PDM图纸管理系统主要功能有哪些？

什么是PDM图纸管理系统？PDM图纸管理系统主要功能有哪些？

PDM (Product Data Management) 图纸管理系统 是用于管理企业内部图纸和相关文件的软件系统。它提供了一个集中存储、组织和跟踪图纸和文件的平台&#xff0c;以确保团队成员能够轻松访问、共享和更新所需的工程设计和制造数据。 彩虹PDM系统|PDM产品数据管理系统|BOM管理|工艺…
阅读更多...
代码浅析DLIO(三)---子图构建

代码浅析DLIO(三)---子图构建

0. 简介 我们刚刚了解过DLIO的整个流程&#xff0c;我们发现相比于Point-LIO而言&#xff0c;这个方法更适合我们去学习理解&#xff0c;同时官方给出的结果来看DLIO的结果明显好于现在的主流方法&#xff0c;当然指的一提的是&#xff0c;这个DLIO是必须需要六轴IMU的&#x…
阅读更多...
最新文章

Copyright @ 2022~2023