Spring整合MyBatis详细分析

mybatis-spring官网
这里我们以传统的spring为例，因为配置更为直观，在spring中使用注解的效果是一样的。

我们在其它几篇文章中已经介绍了MyBatis的工作流程、核心模块和底层原理。了解了MyBatis的原生API里面有三个核心对象:
SqlSessionFactory、SqlSession和MapperProxy
大部分时候我们不会在项目中单独使用MyBatis的工程，而是集成到Spring中使用，但是却没有看到这三个对象在代码里面出现。我们都是直接注入一个Mapper接口，然后调用Mapper接口的方法。所以有下面几个问题，我们要弄清楚：

SqlSessionFactory是什么时候创建的
SqlSession去哪里了？为什么不用它来获取Mapper?
为什么@Autowired注入一个接口，在使用的时候却变成了一个代理对象？在IOC的容器里面我们注入的是什么？注入的时候发生了什么事情？

下面，先看一下把MyBatis集成到Spring中要做的几件事：

除了MyBatis的依赖之外，我们还需要在pom中添加MyBatis和Spring整合的依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.0</version>
</dependency>

在Spring的applicationContext.xml中配置SqlSessionFactoryBean，它是用来帮助我们创建会话的，其中还要指定全局配置文件和mapper映射器文件的路径

<!-- 在Spring启动时创建 sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    <property name="dataSource" ref="dataSource"/>
</bean>

然后在applicationContext.xml中配置需要扫描Mapper接口的路径：
在MyBatis中有几种方式，第一种是配置一个MapperScannerConfigurer，第二种是使用scan标签

<!--配置扫描器，将mybatis的接口实现加入到  IOC容器中  -->
<!--
    <mybatis-spring:scan #base-package="com.yrk.dao"/>
-->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.yrk.dao"/>
</bean>

还有一种是使用注解@MapperScan，比如我们在springboot的启动类上加上一个注解

@SpringBootApplication
@MapperScan("com.yrk.mybatis")
public class MyBatisAnnotationApplication {
    /**
     * @param args
     */
    public static void main(String[] args) {
        SpringApplication.run(MyBatisAnnotationApplication.class, args);
    }
}

创建会话工厂
Spring对MyBatis的对象进行管理，并不是替换MyBatis的核心对象，也就意味着MyBatis中SqlSessionFactory、SqlSession和MapperProxy这些类都会用到，而mybatis-spring.jar里面的类只是做了一些封装或者桥梁的工作。所以，第一步我们先看一下在spring里面是怎么创建工厂类的：
我们在Spring的配置文件中配置了一个SqlSessionFactoryBean，我们来看一下这个类

在这里插入图片描述

它实现了InitializingBean接口，所以要实现afterPropertiesSet()方法，这个方法会在Bean的属性值设置完成时被调用。另外，它实现了FactoryBean接口，所以在初始化的时候，实际上是调用getObject()方法，它里面调用的也是afterPropertiesSet()方法

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

    return this.sqlSessionFactory;
  }

在afterPropertiesSet方法中，调用了buildSqlSessionFactory()方法。

@Override
  public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
    state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
              "Property 'configuration' and 'configLocation' can not specified with together");

    this.sqlSessionFactory = buildSqlSessionFactory();
  }

在buildSqlSessionFactory()方法中，第一步我们定义了一个Configuration，叫做targetConfiguration；
426 行，判断Configuration 对象是否已经存在，也就是是否已经解析过。如果已经有对象，就覆盖一下属性。
433 行，如果Configuration 不存在，但是配置了configLocation 属性，就根据mybatis-config.xml 的文件路径，构建一个xmlConfigBuilder 对象。
436 行，否则，Configuration 对象不存在，configLocation 路径也没有，只能使用默认属性去构建去给configurationProperties 赋值。
后面就是基于当前factory 对象里面已有的属性，对targetConfiguration 对象里面属性的赋值。
在第498 行，如果xmlConfigBuilder 不为空，也就是上面的第二种情况，调用了xmlConfigBuilder.parse()去解析配置文件，最终会返回解析好的Configuration 对象，这里的parse()方法是MyBatis里面的方法，和我们单独使用MyBatis时候的解析全局配置文件的过程是一样的。
在第507 行，如果没有明确指定事务工厂，默认使用SpringManagedTransactionFactory 。它创建SpringManagedTransaction 也有getConnection()和close()方法。
在520 行，调用xmlMapperBuilder.parse()，这个步骤我们之前了解过了，它的作用是把接口和对应的MapperProxyFactory 注册到MapperRegistry 中。
最后调用sqlSessionFactoryBuilder.build() 返回了一个DefaultSqlSessionFactory。OK，在这里我们完成了编程式的案例里面的第一步，根据配置文件获得一个工厂类，它是单例的，会在后面用来创建SqlSession。

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
    final Configuration targetConfiguration;
    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configuration != null) {
      targetConfiguration = this.configuration;
      if (targetConfiguration.getVariables() == null) {
        targetConfiguration.setVariables(this.configurationProperties);
      } else if (this.configurationProperties != null) {
        targetConfiguration.getVariables().putAll(this.configurationProperties);
      }
    } else if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      targetConfiguration = xmlConfigBuilder.getConfiguration();
    } else {
      LOGGER.debug(() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
      targetConfiguration = new Configuration();
      Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
    }
    Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
    Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
    Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);

    if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      Stream.of(typeAliasPackageArray).forEach(packageToScan -> {
        targetConfiguration.getTypeAliasRegistry().registerAliases(packageToScan,
            typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
        LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for aliases");
      });
    }
    if (!isEmpty(this.typeAliases)) {
      Stream.of(this.typeAliases).forEach(typeAlias -> {
        targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
        LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
      });
    }
    if (!isEmpty(this.plugins)) {
      Stream.of(this.plugins).forEach(plugin -> {
        targetConfiguration.addInterceptor(plugin);
        LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
      });
    }
    if (hasLength(this.typeHandlersPackage)) {
      String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      Stream.of(typeHandlersPackageArray).forEach(packageToScan -> {
        targetConfiguration.getTypeHandlerRegistry().register(packageToScan);
        LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for type handlers");
      });
    }
    if (!isEmpty(this.typeHandlers)) {
      Stream.of(this.typeHandlers).forEach(typeHandler -> {
        targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
        LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
      });
    }
    if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls
      try {
        targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      } catch (SQLException e) {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }
    Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);
    if (xmlConfigBuilder != null) {
      try {
        xmlConfigBuilder.parse();
        LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");
      } catch (Exception ex) {
        throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
      } finally {
        ErrorContext.instance().reset();
      }
    }
    targetConfiguration.setEnvironment(new Environment(this.environment,
        this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,
        this.dataSource));
    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }
        try {
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }
        LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
      }
    } else {
      LOGGER.debug(() -> "Property 'mapperLocations' was not specified or no matching resources found");
    }
    return this.sqlSessionFactoryBuilder.build(targetConfiguration);
  }

创建SqlSession
Q1: 可以直接使用DefaultSqlSession吗？
通过上面一步，我们现在已经有一个DefaultSqlSessionFactory了，按照编程式的开发过程，接下来我们要创建一个SqlSession的实现类，但是在Spring中，我们不是直接使用DefaultSqlSession的，而是对它进行了一个封装，这个SqlSession的实现类就是SqlSessionTemplate。这个跟Spring封装其他的组件也是一样的，比如JdbcTemplate，RedisTemplate等等，也是Spring跟MyBatis整合最关键的一个类。

为什么不用DefaultSqlSession？因为它不是线程安全的，而SqlSessionTemplate是线程安全的。

/**
 * The default implementation for {@link SqlSession}.
 * Note that this class is not Thread-Safe.
 *
 * @author Clinton Begin
 */
public class DefaultSqlSession implements SqlSession {

/**
 * Thread safe, Spring managed, {@code SqlSession} that works with Spring
 * transaction management to ensure that that the actual SqlSession used is the
 * one associated with the current Spring transaction. In addition, it manages
 * the session life-cycle, including closing, committing or rolling back the
 * session as necessary based on the Spring transaction configuration.
 * <p>
 * The template needs a SqlSessionFactory to create SqlSessions, passed as a
 * constructor argument. It also can be constructed indicating the executor type
 * to be used, if not, the default executor type, defined in the session factory
 * will be used.
 * <p>
 * This template converts MyBatis PersistenceExceptions into unchecked
 * DataAccessExceptions, using, by default, a {@code MyBatisExceptionTranslator}.
 * <p>
 * Because SqlSessionTemplate is thread safe, a single instance can be shared
 * by all DAOs; there should also be a small memory savings by doing this. This
 * pattern can be used in Spring configuration files as follows:
 *
 * <pre class="code">
 * {@code
 * <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
 *   <constructor-arg ref="sqlSessionFactory" />
 * </bean>
 * }
 * </pre>
 *
 * @author Putthiphong Boonphong
 * @author Hunter Presnall
 * @author Eduardo Macarron
 *
 * @see SqlSessionFactory
 * @see MyBatisExceptionTranslator
 */
public class SqlSessionTemplate implements SqlSession, DisposableBean {

在编程式的开发中，SqlSession我们会在每次请求的时候创建一个，但是Spring里面只有一个SqlSessionTemplate(默认是单例的)，多个线程同时调用的时候如何保证线程安全？
SqlSessionTemplate里面有DefaultSqlSession中的所有方法，selectOne()、selectList()、insert()、update()、delete()，不过它都是通过一个代理对象实现的。这个代理对象在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中的所有方法都会先走到内部代理类SqlSessionInterceptor的invoke方法：

private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        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);
        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 {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

首先会使用工厂类、执行器类型、异常解析器创建一个sqlSession。

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
      return session;
    }
    LOGGER.debug(() -> "Creating a new SqlSession");
    session = sessionFactory.openSession(executorType);
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
    return session;
  }

在getSqlSession方法中，会先去从SqlSessionHolder中获取SqlSession，如果获取到就直接返回，如果没有就新创建一个，并把这个新创建的SqlSession注册到SqlSessionHolder中。SqlSessionHolder是通过TransactionSynchronizationManager.getResource()方法获取到的，实际上是从ThreadLocal中获取，所以SqlSessionTemplate是线程安全的。

private static final ThreadLocal<Map<Object, Object>> resources =
            new NamedThreadLocal<>("Transactional resources");
            
@Nullable
    public static Object getResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doGetResource(actualKey);
        if (value != null && logger.isTraceEnabled()) {
            logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" +
                    Thread.currentThread().getName() + "]");
        }
        return value;
    }

    /**
     * Actually check the value of the resource that is bound for the given key.
     */
    @Nullable
    private static Object doGetResource(Object actualKey) {
        Map<Object, Object> map = resources.get();
        if (map == null) {
            return null;
        }
        Object value = map.get(actualKey);
        // Transparently remove ResourceHolder that was marked as void...
        if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
            map.remove(actualKey);
            // Remove entire ThreadLocal if empty...
            if (map.isEmpty()) {
                resources.remove();
            }
            value = null;
        }
        return value;
    }

Q2: 怎么拿到一个SqlSessionTemplate?
我们知道在Spring里面会用SqlSessionTemplate替换DefaultSqlSession，那么接下来看一下怎么在DAO层拿到一个SqlSessionTemplate。
用过Hibernate的同学应该记得，如果不用注入式的方式，我们在DAO层注入一个HibernateTemplate的一种方式是让我们的DAO层的实现类去集成HibernateDaoSupport。MyBatis也是一样，它提供一个SqlSessionDaoSupport，里面持有SqlSessionTemplate对象，并且提供了一个getSqlSession()方法，让我们获得一个SqlSessionTemplate:

public abstract class SqlSessionDaoSupport extends DaoSupport {

  private SqlSessionTemplate sqlSessionTemplate;
  
  /**
   * Users should use this method to get a SqlSession to call its statement methods
   * This is SqlSession is managed by spring. Users should not commit/rollback/close it
   * because it will be automatically done.
   *
   * @return Spring managed thread safe SqlSession
   */
  public SqlSession getSqlSession() {
    return this.sqlSessionTemplate;
  }
  //省略部分代码

也就是说我们让DAO 层的实现类继承SqlSessionDaoSupport ，就可以获得SqlSessionTemplate，然后在里面封装SqlSessionTemplate 的方法。

public  class BaseDao extends SqlSessionDaoSupport {
    //使用sqlSessionFactory
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Autowired
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        super.setSqlSessionFactory(sqlSessionFactory);
    }

    /**
     * @param statement
     * @return
     */
    public Object selectOne(String statement) {
        return getSqlSession().selectOne(statement);
    }
 }

Q3: 有没有更好的方法可以拿到SqlSessionTemplate? Spring中我们的DAO层没有集成SqlSessionDaoSupport，那Spring中是怎么拿到SqlSessionTemplate的？
在真实项目中，我们只是在DAO层使用@Autowired注入Mapper对象，然后直接调用Mapper对象的方法区操作数据库，那Mapper对象的实例一定是在Spring启动的时候被Spring扫描并且注册了。那这个Mapper是什么时候扫描的？注册的时候又是注册成什么对象？

回顾一下，我们在applicationContext.xml中配置了一个MapperScannerConfigurer，MapperScannerConfigurer 实现了BeanDefinitionRegistryPostProcessor 接口，BeanDefinitionRegistryPostProcessor 是BeanFactoryPostProcessor 的子类，可以通过编码的方式修改、新增或者删除某些Bean 的定义。

在这里插入图片描述

我们只需要重写postProcessBeanDefinitionRegistry()方法，在这里面操作Bean就可以了。在这个方法中，scanner.scan() 方法是ClassPathBeanDefinitionScanner 中的，而它的子类ClassPathMapperScanner 覆盖了doScan() 方法，在doScan() 中调用了processBeanDefinitions，在processBeanDefinitions方法中，在注册beanDefinitions 的时候，BeanClass被改为MapperFactoryBean。

为什么要把beanClass改成MapperFactoryBean呢？因为MapperFactoryBean继承了SqlSessionDaoSupport，可以获取到SqlSessionTemplate

@Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }

    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.registerFilters();
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

@Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    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) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName()
          + "' and '" + beanClassName + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      definition.setBeanClass(this.mapperFactoryBean.getClass());

      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }

      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
        if (explicitFactoryUsed) {
          LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionTemplate != null) {
        if (explicitFactoryUsed) {
          LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
        explicitFactoryUsed = true;
      }

      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }
  }

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

  private Class<T> mapperInterface;

  private boolean addToConfig = true;

  public MapperFactoryBean() {
    //intentionally empty 
  }
  //省略部分代码
}

我们使用Mapper 的时候，只需要在加了Service 注解的类里面使用@Autowired注入Mapper 接口就好了。

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;
    public List<Employee> getAll() {
        return employeeMapper.selectByMap(null);
    }
    public void saveEmpsInfo(Employee employee) {
        employeeMapper.insertSelective(employee);
    }
}

Spring在启动的时候需要去实例化EmployeeService，EmployeeService又依赖了EmployeeMapper接口，Spring会根据Mapper的名字从BeanFactory中获取它的BeanDefinition，再从BeanDefinition中获取BeanClass，上面已经提到，Mapper的BeanClass已经被改成MapperFactoryBean，所以EmployeeMapper的beanClass是MapperFactoryBean。

接下来是创建MapperFactoryBean，因为MapperFactoryBean实现了FactoryBean接口，创建的时候会调用getObject()方法：

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

因为MapperFactoryBean继承了SqlSessionDaoSupport，所以getSqlSession()返回的就是SqlSessionTemplate。

@Override
  public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
  }

SqlSessionTemplate的getMapper()方法又是调用Configuration的getMapper()方法，跟编程式使用里面的getMapper 一样，通过工厂类MapperProxyFactory 获得一个MapperProxy 代理对象。

也就是说，我们注入到Service 层的接口，实际上还是一个MapperProxy 代理对象。所以最后调用Mapper 接口的方法，也是执行MapperProxy 的invoke()方法，后面的流程就跟编程式的工程里面一模一样了。