前言

我们使用Spring+Mybatis做开发时，一般都会引入spring-mybatis这个包，这个包是mybatis自己开发的，它利用Spring的扩展接口将自己很好的整合在Spring中，下面就来说一下，我们定义的mapper接口，是怎么把它变成一个实际的对象然后存储在容器中的

前期准备

我们先来准备下环境

配置Spring环境

引入Spring包，引入mybatis包，引入Spring跟Mybatis整合的包，引入数据库连接驱动的包

AppConfig.java，该类只是简单的配置了Bean的扫描包

package com.demo.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.demo")
public class AppConfig {

}

MybatisConfig.java，该类配置了数据库连接池和SQLSessionFactory，以及Mapper接口的扫描

package com.demo.config;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import javax.sql.DataSource;
@Configuration
@MapperScan("com.demo.dao")
public class MybatisConfig {
    @Bean
    public DataSource dataSource(){
        System.out.println("config datasoutce------");
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/classsystem");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    @Bean
    @Autowired
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        System.out.println("config SessionFactory-------");
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
}

UserDao.java，写一个简单的接口，用于查询数据库

package com.demo.dao;
import org.apache.ibatis.annotations.Select;
import java.util.List;
import java.util.Map;
public interface UserDao {
    @Select("select * from stu_info where id=1")
    public List<Map<String,Object>> selectOne();
}

Test.java最后写一个测试启动类

Test.java

package com.demo.test;

import com.demo.config.AppConfig;
import com.demo.dao.UserDao;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext =
                new AnnotationConfigApplicationContext(AppConfig.class);
        annotationConfigApplicationContext.start();
        //以下是测试Mybatis的代码
        UserDao dao = annotationConfigApplicationContext.getBean(UserDao.class);
        System.out.println(dao.selectOne());
        System.out.println("---over----");
    }
}

这样一来项目即可运行并输出

问题

通过上面的小demo，我们可以通过UserDao的selectOne方法查询数据库，但是我有一个问题，为什么一个UserDao可以实例化？
我们输出从容器中得到的UserDao的类看下

1 2	UserDao dao = annotationConfigApplicationContext.getBean(UserDao.class); System.out.println(annotationConfigApplicationContext.getBean("&userDao"));

输出结果为

1	org.mybatis.spring.mapper.MapperFactoryBean@6913c1fb

看来，一个Mapper接口变成了一个MapperFactoryBean了
这里提出几个问题？
1、MapperFactoryBean是什么东西？
2、它是怎么进入容器，然后被Spring锁管理的？

MapperFactoryBean是什么东西

我们看下MapperFactoryBean的源码，发现它实现了Spring的FactoryBean

FactoryBean

FactoryBean是Spring中特殊的Bean，它可以通过getObject方法生成指定的Bean属性。
当我们手动向Spring容器中注册BeanDefinition（简称BD）时，可以设置BD为FactoryBean类型，这样在Spring中获取这个Bean时，就会使用FactoryBean的getObject创建Bean

如何手动向Spring容器中注入BeanDefinition

何为BeanDefinition？
BeanDefinition是Bean的描述，如果把Bean比作一道菜的话，那么BeanDefinition就是做这道菜的原料。在Spring中，Bean的创建是通过BeanDefinition来创建的，所有属性都包含在BeanDefinition中，比如单例模式，懒加载，类名，方法….
如何手动的向Spring中注册BD？
在Spring中，只要配置类实现了ImportBeanDefinitionRegistrar接口，就可直接向Spring中注册BD
org.springframework.context.annotation.ImportBeanDefinitionRegistrar
比如

package com.lnw.config;
import com.lnw.dao.Pear;
import com.lnw.test.MyFactoryBean2;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.Configuration;
/**
 * 实现了该接口，就可参与Spring的Factory的建设
 * 可以调用接口的实现方法直接添加BeanDefinition
 */
 @Configuration
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		BeanDefinition pear = BeanDefinitionBuilder.genericBeanDefinition(Pear.class).getBeanDefinition();
		registry.registerBeanDefinition("pear", pear);
	}
}

这样的话就可以自己手动的在Spring容器中添加一个Pear（梨）的Bean了

继续刚才FactoryBean的话题

如果我有两个类，Apple和Pear
我手动先容器中注册了Pear，我可以通过FactoryBean来改变Pear从而获取Apple
先编写一个类实现FactoryBean接口

package com.lnw.test;
import com.lnw.dao.Apple;
import org.springframework.beans.factory.FactoryBean;
public class MyFactoryBean2 implements FactoryBean {
	Class clazz;
	MyFactoryBean2(){
	}
	MyFactoryBean2(Class clazz){
		this.clazz = clazz;
	}
	public Class getClazz() {
		return clazz;
	}
	public void setClazz(Class clazz) {
		this.clazz = clazz;
	}
	@Override
	public Object getObject() throws Exception {
		return  new Apple();
	}
	@Override
	public Class<?> getObjectType() {
		return clazz;
	}
}

重点就是getObject方法，它返回一个Apple对象

然后，我们手动注册一个Pear的BD，把它的类型改为我们规定的FactoryBean类

package com.lnw.config;
import com.lnw.dao.Pear;
import com.lnw.test.MyFactoryBean2;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.Configuration;
/**
 * 实现了该接口，就可参与Spring的Factory的建设
 * 可以调用接口的实现方法直接添加BeanDefinition
 */
 @Configuration
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		BeanDefinition pear = BeanDefinitionBuilder.genericBeanDefinition(Pear.class).getBeanDefinition();
        // 将Bean的类型改为我们的FactoryBean，这样返回的就是Apple
		((AbstractBeanDefinition) pear).setBeanClass(MyFactoryBean2.class);
		registry.registerBeanDefinition("pear", pear);
	}
}

然后我们从容器中获取

1	System.out.println(ac.getBean("pear").getClass());

结果输出

1	class com.lnw.dao.Apple

这就是FactoryBean的功能和作用

@MapperScan注解

通过上面我们可以大概知道，spring-mybatis就是通过设置MapperFactoryBean解决从一个Mapper接口变成一个可实际操作的对象的过程
那MapperFactoryBean在哪里设置进去的呢？
答案就在我们的@MapperScan注解中
我们打开注解
@MapperScan

发现它引入了一个类：MapperScannerRegistrar
MapperScannerRegistrar.java

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
  private ResourceLoader resourceLoader;
  /**
   * {@inheritDoc}
   */
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

    // this check is needed in Spring 3.1
    if (resourceLoader != null) {
      scanner.setResourceLoader(resourceLoader);
    }
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      scanner.setAnnotationClass(annotationClass);
    }
    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      scanner.setMarkerInterface(markerInterface);
    }
    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
    }
    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
    }
    scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
    scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));

    List<String> basePackages = new ArrayList<String>();
    for (String pkg : annoAttrs.getStringArray("value")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    for (String pkg : annoAttrs.getStringArray("basePackages")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
    }
    scanner.registerFilters();
    // 扫描包并注册BD
    scanner.doScan(StringUtils.toStringArray(basePackages));
  }
  /**
   * {@inheritDoc}
   */
  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }
}

它实现了ImportBeanDefinitionRegistrar，代表它手动的向Spring中注册了BD
它里面还有一个扫描器，通过扫描器把mapper接口扫描出来，并设置为MapperFactoryBean类型我们直接看源码
org.mybatis.spring.mapper.ClassPathMapperScanner#doScan

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 {
        // 处理扫描出来的BD
      processBeanDefinitions(beanDefinitions);
    }
    return beanDefinitions;
  }

org.mybatis.spring.mapper.ClassPathMapperScanner#processBeanDefinitions

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();

      if (logger.isDebugEnabled()) {
        logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() 
          + "' and '" + definition.getBeanClassName() + "' mapperInterface");
      }

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      /**
      下面两句是核心
          1、设置构造方法中的Class属性为接口的类属性，这样的话最后生成的Bean是Mapper接口的实现类
          2、设置Bean的类型为MapperFactoryBean的类型，这样创建Bean的时候就会调用MapperFactoryBean的getObject方法创建对象
      */
      definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // 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) {
        if (logger.isDebugEnabled()) {
          logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        }
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }
  }

代码很长，但是主要的就是中间那两句代码！第一句是设置产生的Bean的类型，通过构造方法传入；第二句是设置BD的类型为FactoryBean，这样才能在创建Bean的时候调用getObject方法
这样一来，Spring-Mybatis在getObject方法中，通过动态代理为Mapper接口创建代理对象，产生一个可操作的Bean，创建代理对象的过程以后再讨论。

总结

我们的@MapperScan注解，会引入MapperScannerRegistrar类，这个类实现了ImportBeanDefinitionRegistrar的底层Spring接口，这个接口可以手动的向Spring注册BD，Spring使用这个BD创建Bean。
但是在注册BD之前mybatis把BD的属性设置为MapperFactoryBean，MapperFactoryBean实现了Spring底层的FactoryBean，FactoryBean可以指定生成什么样的Bean。所以MapperFactoryBean的getObject方法中，通过传入接口的属性，使用动态代理技术创建一个实现了Mapper接口的代理对象