spring整合mybatis原理,SpringBoot整合Mybatis自定义拦截器不起作用解决方案！！！

spring整合mybatis原理,SpringBoot整合Mybatis自定义拦截器不起作用解决方案！！！详细介绍

本文目录一览： SpringBoot整合ORM开发框架MyBatis和JPA

1、在使用Spring整合ORM组件的过程中，为了达到简化的目的，往往会进行大量的配置。利用SpringBoot可以进一步实现配置的简化。SpringBoot整合MyBatis开发框架，MyBatis是一款常用并且配置极为简单的ORM开发框架。其与Spring结合后，可以利用Spring的特征实现DAO接口的自动配置。在SpringBoot中，又对MyBatis框架的整合进行了进一步简化。

修改pom.xml配置文件，在项目中引入mybatis-spring-boot- starter依赖支持库，切记也需要数据库链接池的支持的哦。

数据表结构，如下所示：

注意：如果数据表字段两个英文单词之间是下划线连接的，但是你的实体类是驼峰命名法，此时就需要进行配置，数据库字段是你下划线分隔，但是bean中的字段是驼峰命名的，如user_name和userName，导致无法匹配。如果是通过xml文件来配置的话，只需要开启驼峰命名转换，setting name="mapUnderscoreToCamelCase" value="true"/>，在/src/main/resources/mybatis/mybatis.cfg.xml里面配置即可。

创建一个po实体类，方便数据传输，如下所示：

在src/main/resources目录中创建mybatis/mybatis.cfg.xml配置文件。如果要开启驼峰命名转换，在这里开启即可，如下所示：

如果在application.properties中开启转换的话，使用mybatis.configuration.map-underscore-to-camel-case=true配置即可。

或者搞个配置类，如果数据库表字段Column无法自动映射到相对应的实体类属性上，我们可以在config包下新建一个自动配置类MybatisConfig，开始驼峰命名规则。

MyBatis配置文件开启驼峰命名映射

修改application.yml配置文件，追加MyBatis配置，如下所示：

搞几个Dao层、Service层、Controller层的接口或者类，如下所示：

注意：如果不想每次都在mapper接口上添加@Mapper注解，可以在主启动类上通过添加@MapperScan注解来批量扫描指定包下的所有mapper接口。

Service层的接口和实现类代码，如下所示：

控制层的代码，如下所示：

项目启动类，如下所示：

通过Postman测试一下，自己写的接口，看看好使不，如下所示：

项目结构，如下所示：

2、JPA是官方推出的Java持久层操作标准（现主要使用Hibernate实现），使用SpringData技术和JpaRepository接口技术，也可以达到简化数据层的目的。要在SpringBoot中使用SpringDataJPA，需要spring-boot-starter-data-jpa依赖库的支持。

修改pom.xml配置文件，引入相关依赖包，如下所示：

创建UserInfo实体类，如下所示：

创建UserDao，然后继承JpaRepository ，此时就可以使用写好的方法了，不用自己再额外写接口和实现，如下所示：

然后定义Service接口和Service接口实现，如下所示：

然后搞一个Controller，作为接口访问的入口，如下所示：

修改程序启动主类，追加Repository扫描配置。如果使用JpaRepository实现了DAO接口的自动实现。需要注意的是，如果想启用Repository配置，则需要在程序启动主类时使用@EnableJpaRepositories注解配置扫描包，而后才可以正常使用。

修改application.properties，使用Druid作为数据源连接池，如下所示：

使用postman进行接口调用，如下所示：

最主要的是给自己增加知识的储备，有备无患。最后给大家分享Spring系列的学习笔记和面试题，包含spring面试题、spring cloud面试题、spring boot面试题、spring教程笔记、spring boot教程笔记、最新阿里巴巴开发手册（63页PDF总结）、2022年Java面试手册。一共整理了1184页PDF文档。私信博主（666）领取，祝大家更上一层楼！！！

ssm框架是什么意思

ssm框架的意思为：spring MVC ，spring和mybatis框架的整合，是标准的MVC模式。
SSM框架的使用方法：
先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。
写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进行的那些操作，比如 insert、selectAll、selectByKey、delete、update等。
写Mapper.java，将Mapper.xml中的操作按照id映射成Java函数。
写Service.java，为控制层提供服务，接受控制层的参数，完成相应的功能，并返回给控制层。
写Controller.java，连接页面请求和服务层，获取页面请求的参数，通过自动装配，映射不同的URL到相应的处理函数，并获取参数，对参数进行处理，之后传给服务层。
SSM框架的原理：
SpringMVC：
1.客户端发送请求到DispacherServlet（分发器）。
2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller。
3.Controller调用业务逻辑处理后，返回ModelAndView。
4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图。
5.视图负责将结果显示到客户端。
我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们Java中的类，当然也包括service dao里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字new。另外spring的aop，事务管理等等都是我们经常用到的。

SpringBoot整合MyBatisPlus配置动态数据源

MybatisPlus特性

快速开始
初始化测试数据表：
父工程依赖
该工程用于依赖管理，pom如下：
创建MyBaitsPlus工程
依赖如下：
properties配置
在这里配置数据库连接，以及数据连接池与mybatisplus的配置等
常规增删改查实现
创建实体类：
该lombok插件省去getset方法。
创建UserMapper接口，并且实现BaseMapper

这里我们指定实体类为user可直接使用接口中的方法。

UserMapper.xml，如下：

执行SQL：

在SpringBoot中使用MybatisPlus分页需要注入Bean，并且在启动类上使用@MapperScan("com.simple.spring.boot.mapper")扫描mapper文件路径如下：

使用MyBatisPlus可以为我们减少很多很多的代码，不过需要编写实体类，有失必有得。

配置动态数据源

dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器。

优势

网上关于动态数据源的切换的文档有很多，核心只有两种。

如果你的数据源较少，场景不复杂，选择以上任意一种都可以。如果你需要更多特性，请尝试本动态数据源。

劣势

不能使用多数据源事务（同一个数据源下能使用事务），网上其他方案也都不能提供。

如果你需要使用到分布式事务，那么你的架构应该到了微服务化的时候了。

如果呼声强烈，项目达到800 star，作者考虑集成分布式事务。

PS: 如果您只是几个数据库但是有强烈的需求分布式事务，建议还是使用传统方式自己构建多套环境集成atomic这类，网上百度很多。

约定

建议

强烈建议在 主从模式 下遵循普遍的规则，以便他人能更轻易理解你的代码。

主数据库 建议 只执行 INSERT UPDATE DELETE 操作。

从数据库 建议 只执行 SELECT 操作。

快速开始

加入依赖：

注释掉原来的数据库配置，加入：

使用 @DS 切换数据源。

@DS 可以注解在方法上和类上， 同时存在方法注解优先于类上注解 。

注解在service实现或mapper接口方法上，但强烈不建议同时在service和mapper注解。 (可能会有问题)

如果不加入主键则使用默认数据源。

DruidDataSourceAutoConfigure会注入一个DataSourceWrapper，其会在原生的spring.datasource下找url,username,password等。而我们动态数据源的配置路径是变化的,所以需要排除：

或者在类上排除：

然后更换properties配置信息：

本篇代码案例地址：

https://github.com/450255266/open-doubi

作者：SimpleWu

出处：https://www.cnblogs.com/SimpleWu/p/10930388.html

ssm框架原理及流程是什么？

SSM全称是Spring+SpringMVC+MyBatis。
SSM框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。常作为数据源较简单的web项目的框架。
1、Spring
Spring就像是整个项目中装配bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。也可以称之为项目中的粘合剂。
2、SpringMVC
SpringMVC在项目中拦截用户请求，它的核心Servlet即DispatcherServlet承担中介或是前台这样的职责。
3、mybatis
mybatis是对jdbc的封装，它让数据库底层操作变的透明。
SSM框架集是软件架构的一个部分。以下是软件架构的种类：
1、逻辑架构
软件系统系统当中的各个元件之间所存在的关系，比如外部系统接口、用户界面、商业逻辑元件、数据库等。
2、物理架构
究竟是怎样做到在硬件当中放置软件元件。例如处于上海与北京进行分布的分布式系统的物理架构，这也就是说全部的元件都是属于物理设备，主要的有主机、整合服务器、应用服务器、代理服务器、存储服务器、报表服务器、Web服务器、网络分流器等。

为什么springMVC和Mybatis逐渐流行起来了

因为springMVC和Mybatis组合，逐渐代替了SSH中的hibernate和Struts，hibernate入门起来比较难与繁琐。
一般，现在的新公司使用的框架就是SpringMVC+MyBatis，没办法只能硬着头皮去做，但是像这种MVC结构的框架都有一个共同的模式就是：
前台（View）会将参数传递到控制层（controller），然后控制层将请求分发到业务层（service），然后业务层再调用相应的持久层（Dao）来进行数据的持久化操作。
所以写一套业务基本上是Jsp→Action→service→serviceImpl→Dao→DaoImpl→sql，最后在Dao层再调用一个通用的方法，比方说你想保存一条数据，可能会有一个通用的Dao类（BaseDao），然后不同的Dao去继承这个BaseDao，然后调用父类的通用方法，然后这个BaseDao再通过sql来进行数据持久化就好了。
总之感觉，这样一套写下来，真的有点繁琐与麻烦，但是MyBatis来了，它的到来真的给我有一种小清新的感觉。
现在MyBatis有一套更简便的玩法，因为MyBatis的Mapper（sql）有一个叫namespace（mapper的名字）这个属性，它有两种使用方式：
1，
比方说你把namespace定义为Teacher：顾名思义，这个Mapper里面所有的sql语句都是对Teacher进行操作的，然后在这个Mapper中有一个叫addTeacherInfo的语句
这个时候在程序中需要通过一个BaseDao来调用：方式大致为super.insert("Teacher.addTeacherInfo",Teacher)
//解释一下，继承了BaseDao类，然后调用父类中的update这个通用方法，第一个参数就是namespace.sql名，然后第二个参数就是要进行持久化的数据，这样就可以进行持久化了，是不是感觉被骗了，然并卵？？ 哈哈 稍等，看下面
2.说到namespace顾名思义，就是命名空间的意思，在.Net中引用一个其他的类就需要引入对应类所在的命名空间，而java就叫包，要导包。
所以Mapper就能通过namespace进行映射一个类
比方说，你定义一个Dao接口，然后这个接口里面有一个方法叫addTeacherInfo，然后你将Mapper的namespace定义为这个Dao接口的完整类名，然后在Mapper里面也有一个叫addTeacherInfo的sql语句，这时候你在程序里面直接调用这个接口时就会直接调用mapper中的sql语句，然后得到返回值了，这样就不必要将参数传递到dao中，然后在dao中再将参数传递到sql中然后再进行操作，是不是有那么一点不一样啊。

MyBatis-Plus 使用这么方便，底层是如何处理的呢？

MyBatis-plus是完全基于MyBatis开发的一个增强工具，是在MyBatis的基础上做增强的框架，为简化开发、提高效率而生。

它在MyBatis原本的框架上增加了很多实用性功能，比如乐观锁插件、字段自动填充功能、分页插件、条件构造器、sql 注入器等等。使用 MyBatis-plus 可以完全不写任何 XML 文件，直接使用继承了BaseMapper 接口的类对象完成对数据库的映射操作

基于映射的原理，MyBatis-plus 必然要实现 Mapper中的方法与 SQL 语句的对应转化，以下即为 MyBatis-plus 重要流程图例

1.在 MyBatis-plus 中， MybatisPlusAutoConfiguration 自动配置类的 sqlSessionFactory() 方法为 Spring提供创建 sqlSession 的工厂类对象，对 sqlSessionFactory 进行定义的定义类变为了 MybatisSqlSessionFactoryBean 。

在 sqlSessionFactory() 方法中，除了注入 MyBatis本身的组件，还会注入MyBatis-plus 的 主键生成器、SQL 注入器等组件，最后通过 MybatisSqlSessionFactoryBean#getObject() 方法获取到 sqlSessionFactory 对象

2. MybatisSqlSessionFactoryBean#getObject() 执行懒加载策略，最后通过 buildSqlSessionFactory() 方法创建 SqlSessionFactory 工厂类对象。这个方法的流程很长，不过大致可以分为两个步骤：

3. MybatisXMLConfigBuilder#parse() 会去解析配置文件，最后会调用到其内部方法 mapperElement() 。这个方法完成解析 Mapper工作，并将其添加到配置类 MybatisConfiguration 中

4. MybatisConfiguration#addMapper() 方法其实是去调用 MybatisMapperRegistry#addMapper() 方法，其核心是 MybatisMapperAnnotationBuilder#parse()

5. MybatisMapperAnnotationBuilder#parse() 方法真正开始完成 Mapper 接口中的方法与 SQL 语句的映射，其中 parseStatement() 方法是解析 @Select/@Update 等注解写入的 SQL语句，而代码 GlobalConfigUtils.getSqlInjector(configuration).inspectInject(assistant, type ) 通过 MaBatis-plus的 SQL 注入器完成 Mapper 方法与 SQL 语句的转化

6. AbstractSqlInjector#inspectInject() 会完成 BaseMapper 接口中提供的通用方法对应的 SQL 语句准备，这部分主要通过 AbstractMethod#inject() 方法完成

7. AbstractMethod#inject() 方法并没有什么特别的操作，只是调用其子类实现 injectMappedStatement() 方法。以 SelectOne#injectMappedStatement() 为例，其 SQL 语句的核心在于 SqlMethod 类，这个枚举类中缓存了可以动态拼接的 SQL 语句脚本，只需要填上参数 format 就可以得到 SQL 语句的执行脚本。

以上过程结束，只需要将所有信息通过 addInsertMappedStatement() 方法封装成 MappedStatement 对象并将其加入到容器中，这样 Mapper接口方法调用时，就可以通过 动态代理 的方式找到其对应执行的 SQL 脚本，至此 SQL 语句准备及配置解析就完成了。

最后拼接的 SQL 语句 脚本形式如下示例，实际执行数据库操作时会解析这个脚本完成变量替换，从而得到可执行的 SQL 语句

8. SqlSessionFactory 对象的创建需要回到 MybatisSqlSessionFactoryBean#buildSqlSessionFactory() 方法中，很容易追踪到 MybatisSqlSessionFactoryBuilder#build() 方法，最后其实是通过 SqlSessionFactoryBuilder#build() 方法创建了一个 DefaultSqlSessionFactory 对象返回

1. @MapperScan 注解通过 @Import(MapperScannerRegistrar.class) 引入扫描注册的类 MapperScannerRegistrar ，该类实现了 ImportBeanDefinitionRegistrar 接口并重写 registerBeanDefinitions() 方法，在该方法中注册了 MapperScannerConfigurer 类

2. MapperScannerConfigurer 是 Mapper接口的扫描配置类，实现了 BeanDefinitionRegistryPostProcessor 接口，其 postProcessBeanDefinitionRegistry() 方法会在容器启动过程中被回调，通过 ClassPathMapperScanner#scan() 方法完成 Mapper 的扫描注册

3. ClassPathMapperScanner#processBeanDefinitions() 将扫描到的 Mapper接口生成的对应 BeanDefinition 的 beanClass 属性替换为 MapperFactoryBean ，这样每次获取 Mapper 实例实际是通过 MapperFactoryBean 的实例去获取

此处体现了 FactoryBean 的定位，即用于获取同一类 bean 的工厂 bean。

4. @Autowired 自动注入 Mapper 触发容器获取 bean 的方法，调用到 MapperFactoryBean#getObject() 方法，最终调用到 sqlSessionTemplate#getMapper() 方法

5.MyBatis-plus 使用的配置类是 MybatisConfiguration ，最终调用到 MybatisMapperRegistry#getMapper() 方法，这里就进入了动态代理获取 MapperProxy 实例的流程

6. MybatisMapperProxyFactory#newInstance() 方法给自动注入返回一个 MybatisMapperProxy 代理对象

7.调用 Mapper 接口的方法触发代理对象的 MybatisMapperProxy#invoke() ，此时根据 Mapper 对象被调用的方法生成 MybatisMapperMethod 对象，通过 MybatisMapperMethod#execute() 去真正地执行 SQL 语句，从而完成数据库操作。

Mybatis Mapper接口是如何找到实现类的-源码分析

KeyWords: Mybatis 原理，源码，Mybatis Mapper 接口实现类，代理模式，动态代理，Java动态代理，Proxy.newProxyInstance，Mapper 映射，Mapper 实现
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。我们在使用 Mybaits 进行 ，通常只需要定义几个 Mapper 接口，然后在编写一个 xml 文件，我们在配置文件中写好 sql , Mybatis 帮我们完成 Mapper 接口道具体实现的调用。以及将结果映射到 model bean 中。
我们在项目中所编写的众多的 Mapper 类只是一个接口(interface )，根据 Java 的多态性我们知道，可以使用接口接口作为形参，进而在运行时确定具体实现的对象是什么。但是，对于 Mapper 接口，我们并没有编写其实现类！Mybatis是如何找到其实现类，进而完成具体的 CRUD 方法调用的呢？原理何在？
为了弄清楚 Mapper 接口是如何找到实现类的，我们先回忆一下 Mybatis 是怎么使用的，根据实际的例子，进而一点点的去分析。这里的使用指的是Mybatis 单独使用，而不是整合 spring , 因为整合 spring 的话，还需要涉及 Mapper dao 装载到 spring 容器的问题，spring 帮忙创建数据源配置等问题。
通常我们使用 Mybatis 的主要步骤是：
从一段代码看起
上面我们概括了使用 Mybatis 的4个步骤。这4个步骤看起来很简单，但是用代码写出来就很多。我们不妨先记着这4个步骤，再去看代码，会容易点。
在这块代码中，第 1 部分我们使用了 Java 编码的形式来实现 SqlSessionFactory ，也可以使用 xml 。如果使用xml的话，上面的第一部分代码就是这样的：
我们本次的目标是弄清楚 “ Mapper 是如何找到实现类的 ”，我们注意上面代码 3 , 4 的位置：
这里 mapper 可以调用selectBlog(1) 这个方法，说明 mapper 是个对象，因为对象才具有方法行为实现啊。BlogMapper接口是不能实例化的，更没有具体方法实现。我们并没有定义一个类，让它实现BlogMapper接口，而在这里它只是通过调用session.getMapper() 所得到的。由此，我们可以推断：肯定是session.getMapper() 方法内部产生了BlogMapper的实现类。有什么技术可以根据BlogMapper 接口生成了一个实现类呢？想到这里，对于有动态代理 使用经验的程序员来说，很容易想到，这背后肯定是基于动态代理技术，具体怎么实现的呢？下面我们来根据源码一探究竟。
Mapper 接口的注册
从上面的代码中，我们知道 BlogMapper 接口的实现类是从session.getMapper中得来的，大概是基于动态代理技术实现。我们既然能够从SqlSession中得到BlogMapper接口的，那么我们肯定需要先在哪里把它放进去了，然后 SqlSession 才能生成我们想要的代理类啊。上面代码中有这么一行：
跟着这个 addMapper 方法的代码实现是这样的：
我们看到这里 mapper 实际上被添加到 mapperRegissry 中。继续跟进代码：
看到这里我们知道上面所执行的configuration.addMapper(BlogMapper.class); 其实最终被放到了HashMap中，其名为knownMappers ，knowMappers是MapperRegistry 类的一个私有属性，它是一个HashMap 。其Key 为当前Class对象，value 为一个MapperProxyFactory 实例。
这里我们总结一下： 诸如BlogMapper 之类的Mapper接口被添加到了MapperRegistry 中的一个HashMap中。并以 Mapper 接口的 Class 对象作为 Key , 以一个携带Mapper接口作为属性的MapperProxyFactory 实例作为value 。MapperProxyFacory从名字来看，好像是一个工厂，用来创建Mapper Proxy的工厂。我们继续往下看。
Mapper接口的动态代理类的生成
上面我们已经知道，Mapper 接口被到注册到了MapperRegistry中——放在其名为knowMappers 的HashMap属性中，我们在调用Mapper接口的方法的时候，是这样的：
这里，我们跟踪一下session.getMapper() 方法的代码实现，这里 SqlSession 是一个接口，他有两个实现类，一个是DefaultSqlSession,另外一个是SqlSessionManager,这里我们用的是DefaultSqlSession. 为什么是DefaultSqlSession呢？因为我们在初始化SqlSessionFactory的时候所调用的SqlSessionFactoryBuilder的build()方法里边配置的就是DefaultSqlSession, 所以，我们进入到DefaultSession类中，看看它对session.getMapper(BlogMapper.class)是怎么实现的：
如代码所示，这里的 getMapper 调用了 configuration.getMapper , 这一步操作其实最终是调用了MapperRegistry,而此前我们已经知道，MapperRegistry是存放了一个HashMap的，我们继续跟踪进去看看，那么这里的get，肯定是从这个hashMap中取数据。我们来看看代码：
我们调用的session.getMapper(BlogMapper.class);最终会到达上面这个方法，这个方法，根据BlogMapper的class对象,以它为key在knowMappers 中找到了对应的value —— MapperProxyFactory(BlogMapper) 对象，然后调用这个对象的newInstance()方法。根据这个名字，我们就能猜到这个方法是创建了一个对象，代码是这样的：
看到这里，就清楚了，最终是通过Proxy.newProxyInstance产生了一个BlogMapper的代理对象。Mybatis 为了完成 Mapper 接口的实现，运用了代理模式。具体是使用了JDK动态代理，这个Proxy.newProxyInstance方法生成代理类的三个要素是：
代理模式中，代理类(MapperProxy)中才真正的完成了方法调用的逻辑。我们贴出MapperProxy的代码，如下：
我们调用的 Blog blog = mapper.selectBlog(1); 实际上最后是会调用这个MapperProxy的invoke方法。这段代码中，if 语句先判断，我们想要调用的方法是否来自Object类，这里的意思就是，如果我们调用toString()方法，那么是不需要做代理增强的，直接还调用原来的method.invoke()就行了。只有调用selectBlog()之类的方法的时候，才执行增强的调用——即mapperMethod.execute(sqlSession, args);这一句代码逻辑。
而mapperMethod.execute(sqlSession, args);这句最终就会执行增删改查了，代码如下：
再往下一层，就是执行JDBC那一套了，获取链接，执行，得到ResultSet，解析ResultSet映射成JavaBean。
至此，我们已经摸清楚了Blog blog = mapper.selectBlog(1); 中，BlogMapper接口调用到得到数据库数据过程中，Mybaitis 是如何为接口生成实现类的，以及在哪里出发了最终的CRUD调用。实际上，如果我们在调用Blog blog = mapper.selectBlog(1);之前，把从slqSession中得到的 mapper 对象打印出来就会看到，输出大概是这样的：
动态代理没错吧，Java动态代理实在是太美妙了。
上面我们用层层深入的方式摸清楚了 Mapper接口是如何找到实现类的。我们分析了 Mapper接口是如何注册的，Mapper接口是如何产生动态代理对象的，Maper接口方法最终是如何执行的。总结起来主要就是这几个点：

SpringBoot整合Mybatis自定义拦截器不起作用解决方案！！！

该方式和Spring无关，是通过反射的形式创建插件对象，此时会执行 org.apache.ibatis.plugin.Interceptor#setProperties 方法，以读取配置参数。
在resource目录下配置mybatis的全局配置：
然后找到了 springboot配置多数据源后mybatis拦截器失效 文章，说是自定义配置了数据源导致了拦截器失效。
源码位置： org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
上面源码中：自动注入了 Interceptor[] 数组（我们只需将mybatis的自定义拦截器对象放入到Spring容器中）。后续放入了 sqlSessionFactory 中。
但是项目中虽然自定义配置了 sqlSessionFactory 类，但却未设置 factory.setPlugins(this.interceptors); 。导致即使将自定义拦截器放入到Spring容器，但却不生效。
这种情况下，mybatis自定义拦截器会被执行两次。即在mybatis-config.xml配置的拦截器会通过反射的方式创建拦截器，放入Spring容器的拦截器也会被初始化。
源码位置： org.mybatis.spring.SqlSessionFactoryBean#buildSqlSessionFactory
最终会执行到：

springboot整合mybatis怎么实现结果集的封装

这里用到spring-boot-starter基础和spring-boot-starter-test用来做单元测试验证数据访问
引入连接mysql的必要依赖mysql-connector-java
引入整合MyBatis的核心依赖mybatis-spring-boot-starter
这里不引入spring-boot-starter-jdbc依赖，是由于mybatis-spring-boot-starter中已经包含了此依赖
123456789101112138008138004252627282930313233

org.springframework.boot

spring-boot-starter-parent

1.3.2.RELEASE

org.springframework.boot

spring-boot-starter