Mybatis-spring源码分析之注册Mapper Bean-阿里云开发者社区

「Mybatis源码分析之Mapper注册与绑定」讲到了 Mapper 如何注册到 Configuration 类中与 MapperProxyFactory 绑定的过程，我们平时的使用场景一般都配合着 Spring，使用 Spring 意味着需要注册 Bean，也就是说需要将 Mapper 的代理实现类注册到 Spring 容器中，成为 Spring 容器中的一个 Bean。

Mybatis 单独使用方式

如果是单独使用 Mybatis，需要手动创建 Mapper 代理实现类：

// 以下是半伪代码
// 创建 sqlSessionFactory 工厂类
SqlSessionFactory sqlSessionFactory = SqlSessionFactoryBuilder.build(configuration);
// 创建一个 sqlSession 客户端连接类
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
  // 获取 Mapper 代理实现类
  XXXMapper mapper = sqlSession.getMapper(XXXMapper.class);
  // 操作数据库
  mapper.insert(xxx);
  sqlSession.commit();
} finally {
  sqlSession.close();
}

很显然这样使用 Mybatis 是代码略显臃肿，且不美观，我们接下来看看 Spring 是如何优雅地用使用 Mybatis。

Spring 注册 Mapper Bean

mybatis-spring 提供了注册 Mapper Bean 的功能，这里涉及 Bean 的注册与加载过程，因此有很多接口需要在这里详细解析一下：

SqlSessionFactoryBean

「Mybatis源码分析之Mapper注册与绑定」中已经有提及到 SqlSessionFactory 的实例了，创建 SqlSessionFactory 实例包括了 Mapper 的注册和绑定过程：

@Bean
public SqlSessionFactory sqlSessionFactory() throws Exception {
  PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
  SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  // 此处省略部分代码
  bean.setMapperLocations(resolver.getResources("classpath*:com/**/*Mapper.xml"));//
  return bean.getObject();
}

这里我们主动创建 SqlSessionFactory 的实例并注册到 Bean 容器中。

SqlSessionFactory 是 Mybatis 应用的核心类，它是创建 SqlSesison 的工厂类，而 SqlSesison 是我们用 Mybatis 与数据库会话的顶层 API 类，所有与数据库会话都需要创建 SqlSesison。

SqlSessionFactoryBean 是 SqlSessionFactory 的具体实现，他实现了 FactoryBean 和 InitializingBean 接口：

FactoryBean：BeanFactory 定义了 Ioc 容器的最基本形式，并提供了 Ioc 容器应遵守的的最基本的接口，也就是 Spring Ioc 所遵守的最底层和最基本的编程规范，一旦某个 Bean 实现了该接口，Spring 的getBean方法其实是调用了 Bean 的 getObject() 方法，即是获取 Bean 实例是通过 getObject() 获取的，这规范很重要，后面会重点围绕着点来讲。

public interface FactoryBean<T> {
  // 返回一个由 FactoryBean 创建的 Bean 实例
  T getObject() throws Exception;
  // 返回一个由 FactoryBean 创建的 Bean 实例的类型
  Class<?> getObjectType();
  // FactoryBean 创建的 Bean 实例是否是单例
  boolean isSingleton();
}

InitializingBean：某个 Bean 若实现了该接口，那么 Spring 实例该 Bean 时首先会调用 afterPropertiesSet() 方法对 Bean 进行初始化动作。

SqlSessionFactoryBean 的初始化：

@Override
public void afterPropertiesSet() throws Exception {
  // 此处省略部分代码
  this.sqlSessionFactory = buildSqlSessionFactory();
}

获取 SqlSessionFactoryBean 实例：

@Override
public SqlSessionFactory getObject() throws Exception {
  if (this.sqlSessionFactory == null) {
    afterPropertiesSet();
  }
  return this.sqlSessionFactory;
}

MapperFactoryBean

Mapper的代理实现类都是有 MapperFactoryBean 来实现了的，它同样实现了 FactoryBean 和 InitializingBean 两个接口，它还继承了 SqlSessionDaoSupport，该类是 SqlSession 生成的支持帮助类，其中有两个关键的方法：

public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
  if (!this.externalSqlSession) {
    this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
  }
}
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
  this.sqlSession = sqlSessionTemplate;
  this.externalSqlSession = true;
}

在 Bean 加载的过程中，Spring 的 PropertyAccessor 实现类会自动设置 Bean 的属性值：

void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException;

不难看出，SqlSessionFactoryBean 被加载时，需要 SqlSessionFactory 或者 SqlSessionTemplate 的实现类，所以我们在 Mapper Bean 加载之前，需要需要手动生成其中的一个，上一篇我们特别介绍了主动生成了 SqlSessionFactory 实现类的过程分析。以下是 MybatisAutoConfiguration 自动话配置类 SqlSessionTemplate Bean 的创建方法：

@Bean
@ConditionalOnMissingBean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
  ExecutorType executorType = this.properties.getExecutorType();
  if (executorType != null) {
    return new SqlSessionTemplate(sqlSessionFactory, executorType);
  } else {
    return new SqlSessionTemplate(sqlSessionFactory);
  }
}

从 externalSqlSession 字段可知，如果 Spring 容器中 SqlSessionFactory 和 SqlSessionTemplate 同时存在，那么 SqlSessionDaoSupport 的这两个属性只会被设置一次。

如果是用标签方式，需要这样配置来注入属性值（不推荐标签配置 Bean 的方式，因为与时代严重脱轨了）：

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.objcoding.dao.UserMapper"></property>
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

获取 MapperFactoryBean 实例：

@Override
public T getObject() throws Exception {
  return getSqlSession().getMapper(this.mapperInterface);
}

该方法里面这段代码，就是我们单独使用 Mybatis 时的一个代码调用方式，这里 Spring 巧妙地在这里进行了封装，因为 MapperFactoryBean 实现了 FactoryBean 接口，Spring 加载 Bean 时，实际上是调用 FactoryBean 的getObject() 方法，到这里你似乎有点豁然开朗的感觉了是不是？

SqlSessionTemplate

SqlSessionTemplate 是 SqlSession 的一个实现类，也是 Mybatis-spring 的核心类，Spring 整合 Mybatis 的最终目的无非就是创建 SqlSessionTemplate 与数据进行会话动作，来看看 SqlSessionTemplate 的构造方法：

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
                          PersistenceExceptionTranslator exceptionTranslator) {
  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
  notNull(executorType, "Property 'executorType' is required");
  this.sqlSessionFactory = sqlSessionFactory;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
  this.sqlSessionProxy = (SqlSession) newProxyInstance(
    SqlSessionFactory.class.getClassLoader(),
    new Class[] { SqlSession.class },
    new SqlSessionInterceptor());
}

我们创建 SqlSessionTemplate 实例最终是调用该方法来实现的，sqlSessionFactoryBean 实例赋值给 SqlSessionTemplate 的 sqlSessionFactory 属性，而且还通过反射生成了一个 SqlSession 代理类，该代理类即是与数据会话的关键：

@Override
public <T> T selectOne(String statement, Object parameter) {
  return this.sqlSessionProxy.<T> selectOne(statement, parameter);
}

继续往下看：

private class SqlSessionInterceptor implements InvocationHandler {
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 创建 DefaultSqlSession 实现类（它不是线程安全的）
    SqlSession sqlSession = getSqlSession(
      SqlSessionTemplate.this.sqlSessionFactory,
      SqlSessionTemplate.this.executorType,
      SqlSessionTemplate.this.exceptionTranslator);
    try {
      // 通过反射调用 sqlSession 具体方法
      Object result = method.invoke(sqlSession, args);
      if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
        // force commit even on non-dirty sessions because some databases require
        // a commit/rollback before calling close()
        // 提交执行
        sqlSession.commit(true);
      }
      // 返回执行结果
      return result;
    } catch (Throwable t) {
      Throwable unwrapped = unwrapThrowable(t);
      //然后判断一下当前的sqlSession是否被Spring托管 如果未被Spring托管则自动commit
      if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
        // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
        closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        sqlSession = null;
        Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
        if (translated != null) {
          unwrapped = translated;
        }
      }
      throw unwrapped;
    } finally {
      //关闭sqlSession
      if (sqlSession != null) {
        closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
      }
    }
  }
}

getSqlSession 创建一个 SqlSession 实现类，这里是一个默认的实现类 DefaultSqlSession，从该反射具体执行类看出，我们调用代理类执行操作时，已经自动给执行了 commit、close 等操作了，当前的 sqlSession 是否被 Spring 托管，还有事务回滚功能，大大节省了代码量有木有！

MapperScan 注解扫描入口

接下来就是重头戏了，我们此时需要将 Mapper 接口类扫描并注册生成对应的 BeanDefinition 并添加到 BeanDefinitionRegistry 中。

BeanDefinition：它是 Spring 中用于包装 Bean 的数据结构，一个 BeanDefinition 描述了一个 bean 的实例，包括它的类名，具体的 class 对象等属性值。

MapperScan 注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
public @interface MapperScan {
  String[] value() default {};
  // 省略部分代码
  Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;
}

在这个注解里面包含了 @Import 注解，它的作用是导入资源，如果导入的是一个普通类，spring 还会将其注册成一个普通的 Bean，通过 @Import 注入了 Mapper 扫描注册类，通过该扫描类扫描 Mapper 目录，并将 Mapper 注册成一个 Bean。

MapperScannerRegistrar

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
  private ResourceLoader resourceLoader;
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    // 获取当前注解信息
    AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    // 创建 Mapper 扫描类，该类会自动扫描指定目录并将 Mapper 封装成 一个个 BeanDefinition 并添加到 BeanDefinitionRegistry 中
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    // 省略部分代码
    // 执行过滤
    scanner.registerFilters();
    // 开始扫描
    scanner.doScan(StringUtils.toStringArray(basePackages));
  }
  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }
}

MapperScannerRegistrar 类实现了 ImportBeanDefinitionRegistrar ，该 interface 是 Spring 动态注册 Bean 的方法，所有实现了该接口的类都会被 ConfigurationClassPostProcessor 处理。

ClassPathMapeerScanner

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
  // 省略部分代码
  @Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    // 调用父类方法对指定路径进行扫描并注册 BeanDefinition
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
      logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
      processBeanDefinitions(beanDefinitions);
    }
    return beanDefinitions;
  }
  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      // 省略部分代码
      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      //将其bean Class 类型设置为 mapperFactoryBean，放入 BeanDefinitions definition.
 definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
      definition.setBeanClass(this.mapperFactoryBean.getClass());
      // 省略部分代码
    }
  }
  // 省略部分代码
}

ClassPathMapeerScanner 继承了 ClassPathBeanDefinitionScanner 类，ClassPathBeanDefinitionScanner 会扫描base-package下的所有spring定义的注解标识类，也可以对扫描的机制进行配置，设置一些 Filter，只有满足Filter的类才能被注册为Bean。

这里实现并覆盖了 doScan 方法的，并将其 BeanDefinition 中的 beanClass 设置为 MapperFactoryBean，这一步特别关键啊，因为 MapperFactoryBean 实现了 BeanFactory 接口，spring 加载这类型的 Bean 会调用其 getObejct() 方法，上面也提到过 MapperFactoryBean 的 getObejct() 实则是调用 SqlSession 的 getMapper() 方法生成 Mapper 代理类，而该代理类底层操作的还是 SqlSession，绕了一大圈，终于搞明白 Spring 的「用心良苦」了吧。

在分析源码时习惯胡乱地画一下：