mybatis-spring整合详情介绍

ゝ一纸荒年。 2022-08-31 15:25 190阅读 0赞

官网文档：[mybatis-spring][]

# 【1】快速上手 #

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

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

@Configuration
    public class MyBatisConfig { 
      @Bean
      public SqlSessionFactory sqlSessionFactory() throws Exception { 
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        return factoryBean.getObject();
      }
    }

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

假设你定义了一个如下的 mapper 接口：

public interface UserMapper { 
      @Select("SELECT * FROM users WHERE id = #{userId}")
      User getUser(@Param("userId") String userId);
    }

那么可以通过 `MapperFactoryBean` 将接口加入到 Spring 中:

**需要注意的是**：所指定的映射器类必须是一个`接口`，而不是具体的实现类。在这个示例中，通过注解来指定 SQL 语句，但是也可以使用 MyBatis 映射器的 XML 配置文件。

配置好之后，你就可以像 Spring 中普通的 bean 注入方法那样，将映射器注入到你的业务或服务对象中`。MapperFactoryBean 将会负责 SqlSession 的创建和关闭`。 如果使用了 Spring 的事务功能，那么当事务完成时，session 将会被提交或回滚。最终任何异常都会被转换成 Spring 的 `DataAccessException` 异常。

使用 Java 代码来配置的方式如下：

@Configuration
    public class MyBatisConfig { 
      @Bean
      public UserMapper userMapper() throws Exception { 
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory());
        return sqlSessionTemplate.getMapper(UserMapper.class);
      }
    }

要调用 MyBatis 的数据方法，只需一行代码：

public class FooServiceImpl implements FooService { 
    
      private final UserMapper userMapper;
    
      public FooServiceImpl(UserMapper userMapper) { 
        this.userMapper = userMapper;
      }
    
      public User doSomeBusinessStuff(String userId) { 
        return this.userMapper.getUser(userId);
      }
    }

# 【2】SqlSessionFactoryBean #

用来创建一个mybatis的SqlSessionFactory，可以注入到MyBatis-based DAOs。类UML图如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]

> 这里可以看到`SqlSessionFactoryBean` 实现了`FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent>`等接口。

在基础的 MyBatis 用法中，是通过 `SqlSessionFactoryBuilder` 来创建 `SqlSessionFactory` 的。而在 `MyBatis-Spring` 中，则使用 `SqlSessionFactoryBean` 来创建。

## 设置 ##

要创建工厂 bean，将下面的代码放到 Spring 的 XML 配置文件中：

需要注意的是 `SqlSessionFactoryBean` 实现了 `Spring 的 FactoryBean` 接口（参见 Spring 官方文档 3.8 节 通过工厂 bean 自定义实例化逻辑 ）。 `这意味着由 Spring 最终创建的 bean 并不是 SqlSessionFactoryBean 本身，而是工厂类（SqlSessionFactoryBean）的 getObject() 方法的返回结果`。这种情况下，**Spring 将会在`应用启动`时为你创建 SqlSessionFactory，并使用 sqlSessionFactory 这个名字存储起来**。

等效的 Java 代码如下：

@Configuration
    public class MyBatisConfig { 
      @Bean
      public SqlSessionFactory sqlSessionFactory() { 
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        return factoryBean.getObject();
      }
    }

通常，在 MyBatis-Spring 中，你不需要直接使用 `SqlSessionFactoryBean` 或对应的 `SqlSessionFactory`。 相反，session 的工厂 bean 将会被注入到 `MapperFactoryBean` 或其它继承于 `SqlSessionDaoSupport 的 DAO`（Data Access Object，数据访问对象）中。

## **属性** ##

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

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

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

如果 MyBatis 在映射器类对应的路径下找不到与之相对应的映射器 XML 文件，那么也需要配置文件。这时有两种解决办法：

*  第一种是手动在 MyBatis 的 XML 配置文件中的 `<mappers>` 部分中指定 XML 文件的类路径；
 *  第二种是设置工厂 bean 的 mapperLocations 属性。

**mapperLocations 属性接受多个资源位置**。这个属性可以用来指定 MyBatis 的映射器 XML 配置文件的位置。属性的值是一个 Ant 风格的字符串，可以指定加载一个目录中的所有文件，或者从一个目录开始递归搜索所有目录。比如:

这会从类路径下加载所有在 `sample.config.mappers` 包和它的子包中的 MyBatis 映射器 XML 配置文件。

在容器管理事务的时候，你可能需要的一个属性是 `transactionFactoryClass`。请参考事务一章的相关章节。

如果你使用了多个数据库，那么需要设置 databaseIdProvider 属性：

<bean id="databaseIdProvider" class="org.apache.ibatis.mapping.VendorDatabaseIdProvider">
      <property name="properties">
        <props>
          <prop key="SQL Server">sqlserver</prop>
          <prop key="DB2">db2</prop>
          <prop key="Oracle">oracle</prop>
          <prop key="MySQL">mysql</prop>
        </props>
      </property>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
      <property name="databaseIdProvider" ref="databaseIdProvider"/>
    </bean>

提示 自 1.3.0 版本开始，新增的 configuration 属性能够在没有对应的 MyBatis XML 配置文件的情况下，直接设置 Configuration 实例。例如：

--------------------

# 【3】事务 #

一个使用 `MyBatis-Spring` 的其中一个主要原因是它允许 MyBatis 参与到 Spring 的事务管理中。而不是给 MyBatis 创建一个新的专用事务管理器，MyBatis-Spring 借助了 Spring 中的 `DataSourceTransactionManager` 来实现事务管理。

一旦配置好了 Spring 的事务管理器，你就可以在 Spring 中按你平时的方式来配置事务。并且支持 `@Transactional` 注解和 `AOP` 风格的配置。`在事务处理期间，一个单独的 SqlSession 对象将会被创建和使用`。当事务完成时，这个 session 会以合适的方式提交或回滚。

事务配置好了以后，MyBatis-Spring 将会透明地管理事务。这样在你的 DAO 类中就不需要额外的代码了。

## 标准配置 ##

要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 `DataSourceTransactionManager` 对象：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <constructor-arg ref="dataSource" />
    </bean>
    
    @Configuration
    public class DataSourceConfig {
      @Bean
      public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
      }
    }

传入的 DataSource 可以是任何能够与 Spring 兼容的 JDBC DataSource。包括连接池和通过 JNDI 查找获得的 DataSource。

> **注意**：为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的是同一个数据源，否则事务管理器就无法工作了。

## 交由容器管理事务 ##

如果你正使用一个 JEE 容器而且想让 Spring 参与到容器管理事务（`Container managed transactions，CMT`）的过程中，那么 Spring 应该被设置为使用 `JtaTransactionManager` 或由容器指定的一个子类作为事务管理器。最简单的方式是使用 Spring 的事务命名空间或使用 `JtaTransactionManagerFactoryBean`：

<tx:jta-transaction-manager />
    
    @Configuration
    public class DataSourceConfig { 
      @Bean
      public JtaTransactionManager transactionManager() { 
        return new JtaTransactionManagerFactoryBean().getObject();
      }
    }

在这个配置中，MyBatis 将会和其它由容器管理事务配置的 Spring 事务资源一样。Spring 会自动使用任何一个存在的容器事务管理器，并注入一个 `SqlSession`。 如果没有正在进行的事务，而基于事务配置需要一个新的事务的时候，Spring 会开启一个新的由容器管理的事务。

**注意**，如果你想使用由容器管理的事务，而不想使用 Spring 的事务管理，你就不能配置任何的 Spring 事务管理器。并必须配置 `SqlSessionFactoryBean` 以使用基本的 `MyBatis` 的 `ManagedTransactionFactory`：

对应的Java代码配置

## 编程式事务管理 ##

MyBatis 的 `SqlSession` 提供几个方法来在代码中处理事务。但是当使用 MyBatis-Spring 时，`你的 bean 将会注入由 Spring 管理的 SqlSession 或映射器`。也就是说，Spring 总是为你处理了事务。

你不能在 `Spring` 管理的 `SqlSession` 上调用 `SqlSession.commit()，SqlSession.rollback()` 或 `SqlSession.close()` 方法。如果这样做了，就会抛出 `UnsupportedOperationException` 异常。在使用注入的映射器时，这些方法也不会暴露出来。

无论 JDBC 连接是否设置为自动提交，调用 SqlSession 数据方法或在 Spring 事务之外调用任何在映射器中方法，事务都将会自动被提交。

如果你想编程式地控制事务，请参考[ the Spring reference document(Data Access -Programmatic transaction management-][the Spring reference document_Data Access -Programmatic transaction management-]) 。下面的代码展示了如何使用 `PlatformTransactionManager` 手工管理事务。

public class UserService { 
      private final PlatformTransactionManager transactionManager;
      public UserService(PlatformTransactionManager transactionManager) { 
        this.transactionManager = transactionManager;
      }
      public void createUser() { 
        TransactionStatus txStatus =
            transactionManager.getTransaction(new DefaultTransactionDefinition());
        try { 
          userMapper.insertUser(user);
        } catch (Exception e) { 
          transactionManager.rollback(txStatus);
          throw e;
        }
        transactionManager.commit(txStatus);
      }
    }

在使用 `TransactionTemplate` 的时候，可以省略对 `commit` 和 `rollback` 方法的调用。

public class UserService { 
      private final PlatformTransactionManager transactionManager;
      public UserService(PlatformTransactionManager transactionManager) { 
        this.transactionManager = transactionManager;
      }
      public void createUser() { 
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.execute(txStatus -> { 
          userMapper.insertUser(user);
          return null;
        });
      }
    }

**注意**：虽然这段代码使用的是一个映射器，但换成 SqlSession 也是可以工作的。

--------------------

# 【4】使用 SqlSession #

在 MyBatis 中，你可以使用 `SqlSessionFactory` 来创建 `SqlSession`。 一旦你获得一个 `session` 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。 使用 MyBatis-Spring 之后，你不再需要直接使用 SqlSessionFactory 了，因为`你的 bean 可以被注入一个线程安全的 SqlSession`，它能基于 Spring 的事务配置来自动提交、回滚、关闭 session。

## SqlSessionTemplate ##

`SqlSessionTemplate` 是 `MyBatis-Spring` 的核心。作为 `SqlSession 的一个实现`，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。 `SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用`。

当调用 SQL 方法时（包括由 getMapper() 方法返回的映射器中的方法），SqlSessionTemplate 将会保证使用的 SqlSession 与当前 Spring 的事务相关。 此外，它管理 session 的生命周期，包含必要的关闭、提交或回滚操作。另外，它也负责将 MyBatis 的异常翻译成 Spring 中的 `DataAccessExceptions`。

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

可以使用 `SqlSessionFactory` 作为构造方法的参数来创建 `SqlSessionTemplate` 对象。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
      <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>
    
    @Configuration
    public class MyBatisConfig { 
      @Bean
      public SqlSessionTemplate sqlSession() throws Exception { 
        return new SqlSessionTemplate(sqlSessionFactory());
      }
    }

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 `SqlSession` 属性，就像下面这样：

public class UserDaoImpl implements UserDao { 
    
      private SqlSession sqlSession;
    
      public void setSqlSession(SqlSession sqlSession) { 
        this.sqlSession = sqlSession;
      }
    
      public User getUser(String userId) { 
        return sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
      }
    }

按下面这样，注入 `SqlSessionTemplate`：

`SqlSessionTemplate` 还有一个接收 `ExecutorType` 参数的构造方法。这允许你使用如下 Spring 配置来批量创建对象，例如批量创建一些 SqlSession：

对应的java代码

@Configuration
    public class MyBatisConfig {
      @Bean
      public SqlSessionTemplate sqlSession() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory(), ExecutorType.BATCH);
      }
    }

现在所有的映射语句可以进行批量操作了，可以在 DAO 中编写如下的代码

public class UserService { 
      private final SqlSession sqlSession;
      public UserService(SqlSession sqlSession) { 
        this.sqlSession = sqlSession;
      }
      public void insertUsers(List<User> users) { 
        for (User user : users) { 
          sqlSession.insert("org.mybatis.spring.sample.mapper.UserMapper.insertUser", user);
        }
      }
    }

**注意**，只需要在希望语句执行的方法与 `SqlSessionTemplate` 中的默认设置不同时使用这种配置。

这种配置的弊端在于，当调用这个方法时，不能存在使用不同 ExecutorType 的进行中的事务。要么确保对不同 `ExecutorType` 的 `SqlSessionTemplate` 的调用处在不同的事务中，要么完全不使用事务。

## SqlSessionDaoSupport抽象类 ##

SqlSessionDaoSupport(MyBatis SqlSession数据访问对象的方便超类)的UML类图如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]

**`SqlSessionDaoSupport` 是一个抽象的支持类，用来为你提供 `SqlSession`**。调用 `getSqlSession`() 方法你会得到一个 `SqlSessionTemplate`，之后可以用于执行 SQL 方法，就像下面这样:

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao { 
      public User getUser(String userId) { 
        return getSqlSession().selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
      }
    }

在这个类里面，通常更倾向于使用 `MapperFactoryBean`，因为它不需要额外的代码。但是，如果你需要在 DAO 中做其它非 MyBatis 的工作或需要一个非抽象的实现类，那么这个类就很有用了。

`SqlSessionDaoSupport` 需要通过属性设置一个 `sqlSessionFactory` 或 `SqlSessionTemplate`。如果两个属性都被设置了，那么 `SqlSessionFactory` 将被忽略。

假设类 `UserMapperImpl` 是 `SqlSessionDaoSupport` 的子类，可以编写如下的 Spring 配置来执行设置：

--------------------

# 【5】注入映射器 #

与其在数据访问对象（DAO）中手工编写使用 `SqlSessionDaoSupport` 或 `SqlSessionTemplate` 的代码，还不如让 `Mybatis-Spring` 为你创建一个**线程安全的映射器**，这样你就可以直接注入到其它的 bean 中了：

注入完毕后，映射器就可以在你的应用逻辑代码中使用了：

注意代码中并没有任何的对 SqlSession 或 MyBatis 的引用。你也不需要担心创建、打开、关闭 session，MyBatis-Spring 将为你打理好一切。

## 注册映射器 ##

注册映射器的方法根据你的配置方法，即经典的 XML 配置或新的 3.0 以上版本的 Java 配置（也就是常说的 `@Configuration`），而有所不同。

### XML 配置 ###

在你的 XML 中加入 `MapperFactoryBean` 以便将映射器注册到 Spring 中。就像下面一样：

**如果映射器接口 `UserMapper` 在相同的类路径下有对应的 `MyBatis XML 映射器配置文件`，将会被 `MapperFactoryBean` 自动解析**。不需要在 MyBatis 配置文件中显式配置映射器，除非映射器配置文件与接口类不在同一个类路径下。 参考 `SqlSessionFactoryBean 的 configLocation` 属性以获取更多信息。

**注意** `MapperFactoryBean` 需要配置一个 `SqlSessionFactory` 或 `SqlSessionTemplate`。它们可以分别通过 `sqlSessionFactory` 和 `sqlSessionTemplate` 属性来进行设置。 如果两者都被设置，`SqlSessionFactory` 将被忽略。由于 `SqlSessionTemplate` 已经设置了一个 `session` `工厂`，`MapperFactoryBean` 将使用那个工厂。

### Java 配置 ###

@Configuration
    public class MyBatisConfig { 
      @Bean
      public MapperFactoryBean<UserMapper> userMapper() throws Exception { 
        MapperFactoryBean<UserMapper> factoryBean = new MapperFactoryBean<>(UserMapper.class);
        factoryBean.setSqlSessionFactory(sqlSessionFactory());
        return factoryBean;
      }
    }

## 发现映射器 ##

不需要一个个地注册你的所有映射器。你可以让 MyBatis-Spring 对类路径进行扫描来发现它们。

**有几种办法来发现映射器：**

*  使用 `<mybatis:scan/>` 元素
 *  使用 `@MapperScan` 注解
 *  在经典 Spring XML 配置文件中注册一个 `MapperScannerConfigurer`  
    `<mybatis:scan/>` 和 `@MapperScan` 都在 `MyBatis-Spring 1.2.0` 中被引入。`@MapperScan` 需要你使用 Spring 3.1+。

Since 2.0.2, mapper scanning feature support a option `(lazy-initialization`) that control lazy initialization enabled/disabled of mapper bean. The motivation for adding this option is supporting a lazy initialization control feature supported by Spring Boot 2.2. The default of this option is false (= not use lazy initialization). If developer want to use lazy initialization for mapper bean, it should be set to the true expressly.

**IMPORTANT** If use the lazy initialization feature, the developer need to understand following limitations. If any of following conditions are matches, usually the lazy initialization feature cannot use on your application.

*  When refers to the statement of other mapper using `<association>(@One) and <collection>(@Many)`
 *  When includes to the fragment of other mapper using `<include>`
 *  When refers to the cache of other mapper using `<cache-ref>(@CacheNamespaceRef)`
 *  When refers to the result mapping of other mapper using `<select resultMap="...">(@ResultMap)`

**NOTE** However, It become possible to use it by simultaneously initializing dependent beans using `@DependsOn`(Spring’s feature) as follow:

@DependsOn("vendorMapper")
    public interface GoodsMapper { 
      // ...
    }

Since 2.0.6, the develop become can specified scope of mapper using mapper scanning feature option(default-scope) and scope annotation(@Scope, @RefreshScope, etc …). The motivation for adding this option is supporting the refresh scope provided by the Spring Cloud. The default of this option is empty (`= equiv to specify the singleton scope`).

The default-scope apply to the mapper bean(MapperFactoryBean) when scope of scanned bean definition is singleton(default scope) and create a scoped proxy bean for scanned mapper when final scope is not singleton.

> 当扫描的bean定义的作用域为singleton（默认作用域）时，默认作用域应用于映射器工厂bean（MapperFactoryBean）。当最终作用域不是singleton时，为扫描的映射器创建一个作用域代理bean。

### `<mybatis:scan>` ###

`<mybatis:scan/>` 元素会发现映射器，它发现映射器的方法与 Spring 内建的 `<context:component-scan/>` 发现 bean 的方法非常类似。

下面是一个 XML 配置样例：

base-package 属性允许你设置映射器接口文件的基础包。通过使用逗号或分号分隔，你可以设置多个包。并且会在你所指定的包中递归搜索映射器。

**注意**，不需要为 `<mybatis:scan/>` 指定 `SqlSessionFactory` 或 `SqlSessionTemplate`，这是因为`它将使用能够被自动注入的 MapperFactoryBean`。但如果你正在使用多个数据源（DataSource），自动注入可能不适合你。 在这种情况下，你可以使用 `factory-ref` 或 `template-ref` 属性指定你想使用的 bean 名称。

`<mybatis:scan/>` **支持基于标记接口或注解的过滤操作**。在 `annotation` 属性中，可以指定映射器应该具有的特定注解。而在 `marker-interface` 属性中，可以指定映射器应该继承的父接口。当这两个属性都被设置的时候，被发现的映射器会满足这两个条件。 默认情况下，这两个属性为空，因此在基础包中的所有接口都会被作为映射器被发现。

**被发现的映射器会按照 Spring 对自动发现组件的默认命名策略进行命名**（参考[the Spring reference document(Core Technologies -Naming autodetected components-][the Spring reference document_Core Technologies -Naming autodetected components-] ) ）。 也就是说，如果没有使用注解显式指定名称，将会使用`映射器的首字母小写非全限定类名作为`名称。但如果发现映射器具有 `@Component` 或 `JSR-330` 标准中 `@Named` 注解，会使用注解中的名称作为名称。 提醒一下，你可以设置 `annotation` 属性为你自定义的注解，然后在你的注解上设置 `org.springframework.stereotype.Component` 或 `javax.inject.Name`d（需要使用 Java SE 6 以上）注解，这样你的注解既可以作为标记，也可以作为一个名字提供器来使用了。

**提示** `<context:component-scan/>` 无法发现并注册映射器。映射器的本质是接口，为了将它们注册到 Spring 中，发现器必须知道如何为找到的每个接口创建一个 `MapperFactoryBean`。

### `@MapperScan` ###

当你正在使用 Spring 的基于 Java 的配置时（也就是 `@Configuration`），相比于使用 `<mybatis:scan/>`，你会更喜欢用 `@MapperScan。`

**@MapperScan 注解的使用方法如下：**

@Configuration
    @MapperScan("org.mybatis.spring.sample.mapper")
    public class AppConfig { 
      // ...
    }

这个注解具有与之前见过的 `<mybatis:scan/>` 元素一样的工作方式。它也可以通过 `markerInterface` 和 `annotationClass` 属性设置标记接口或注解类。 通过配置 `sqlSessionFactory` 和 `sqlSessionTemplate` 属性，你还能指定一个 `SqlSessionFactory` 或 `SqlSessionTemplate`。

**`NOTE`** Since 2.0.4, If basePackageClasses or basePackages are not defined, scanning will occur from the package of the class that declares this annotation.

### MapperScannerConfigurer ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center 1]

`MapperScannerConfigurer` 是一个 `BeanDefinitionRegistryPostProcessor`，这样就可以作为一个 `bean`，包含在经典的 XML 应用上下文中。为了配置 `MapperScannerConfigurer`，使用下面的 Spring 配置：

如果你需要指定 `sqlSessionFactory` 或 `sqlSessionTemplate`，那你应该要指定的是 `bean` `名`而不是 `bean 的引用`，因此要使用 value 属性而不是通常的 `ref` 属性：

**提示** 在 `MyBatis-Spring 1.0.2` 之前，`sqlSessionFactoryBean` 和 `sqlSessionTemplateBean` 属性是唯一可用的属性。 但由于 `MapperScannerConfigurer` 在启动过程中比 `PropertyPlaceholderConfigurer` 运行得更早，经常会产生错误。基于这个原因，上述的属性已被废弃，现在建议使用 `sqlSessionFactoryBeanName` 和 `sqlSessionTemplateBeanName` 属性。

[mybatis-spring]: https://mybatis.org/spring/zh/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/9da63f2437044b22ab2c6321cb3f215c.png
[the Spring reference document_Data Access -Programmatic transaction management-]: https://docs.spring.io/spring-framework/docs/current/reference/html/data-access.html#transaction-programmatic
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]: /images/20220829/03f202ccd70943908eba6dee02ab6c37.png
[the Spring reference document_Core Technologies -Naming autodetected components-]: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-scanning-name-generator
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/b3eae6f243ac48b8844d1121ad326969.png