MyBatis 传统模式

  1. public static void main(String[] args) throws IOException {
  2.     InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
  3.     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  4.     SqlSession sqlSession = sqlSessionFactory.openSession();
  6.     // 通过 JDK 动态代理，生成代理对象
  7.     AdminMapper mapper = sqlSession.getMapper(AdminMapper.class);
  8.     List<Admin> admins = mapper.selectAll();
  9.     for (Admin admin : admins) {
  10.         System.out.println(admin.getId() + ", " + admin.getName());
  11.     }
  12. }

其中 AdminMapper mapper = sqlSession.getMapper(AdminMapper.class); 就是通过 JDK 动态代理生成的代理对象，我们可以往下跟源码发现

  1. protected T newInstance(MapperProxy<T> mapperProxy) {
  2.     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), 
  3.                                       new Class[] { mapperInterface }, mapperProxy);
  4. }

MyBatis 如何和 Spring 整合的（MyBatis-Spring 1.3.X 的实现）

一、演化一，FactoryBean

FactoryBean 的模式

  1. @Component
  2. public class MyFactoryBean implements FactoryBean<Object> {
  3.     @Override
  4.     public UserMapper getObject() throws Exception {
  5.         Object proxyInstance = Proxy.newProxyInstance(MyFactoryBean.class.getClassLoader(), new Class<?>[]{UserMapper.class}, new InvocationHandler() {
  6.             @Override
  7.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8.                 String select = method.getAnnotation(Select.class).value();
  9.                 System.out.println(method.getName() + " => " + select);
  10.                 return null;
  11.             }
  12.         });
  13.         return (UserMapper) proxyInstance;
  14.     }
  16.     @Override
  17.     public Class<?> getObjectType() {
  18.         return UserMapper.class;
  19.     }
  20. }

我们可以通过 FactoryBean 的模式来给 UserMapper 生成一个代理对象，这样虽然可以成功，但是，如果在还有其他的 Mapper 怎么处理呢？难道在写一个 FactoryBean 么？肯定不是

二、演化二，ImportBeanDefinitionRegistrar

通过 ImportBeanDefinitionRegistrar 接口，我们可以想容器中注册 BeanDefinition，这也是 MyBatis 与 Spring 整合的方式

  1. public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  3.     @Override
  4.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  5.         // 这里可以用 扫描 来实现
  6.         List<Class<?>> mapperClasses = new ArrayList<>();
  7.         mapperClasses.add(UserMapper.class);
  8.         mapperClasses.add(OrderMapper.class);
  10.         for (Class<?> mapperClass : mapperClasses) {
  11.             AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
  12.             beanDefinition.setBeanClass(MyFactoryBean.class);
  13.             beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(mapperClass);
  14.             // 注册到容器
  15.             registry.registerBeanDefinition(mapperClass.getSimpleName(), beanDefinition);
  16.         }
  17.     }
  18. }
  20. public class MyFactoryBean implements FactoryBean<Object> {
  22.     private Class<?> mapperInterface;
  24.     public MyFactoryBean(Class<?> mapperInterface) {
  25.         this.mapperInterface = mapperInterface;
  26.     }
  28.     @Override
  29.     public Object getObject() throws Exception {
  30.         return Proxy.newProxyInstance(MyFactoryBean.class.getClassLoader(), new Class<?>[]{mapperInterface}, new InvocationHandler() {
  31.             @Override
  32.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  33.                 String select = method.getAnnotation(Select.class).value();
  34.                 System.out.println(method.getName() + " => " + select);
  35.                 return null;
  36.             }
  37.         });
  38.     }
  40.     @Override
  41.     public Class<?> getObjectType() {
  42.         return mapperInterface;
  43.     }
  44. }
  46. @Configuration
  47. @ComponentScan("com.sourceflag.spring.mybatis")
  48. @Import(MyBeanDefinitionRegistrar.class)
  49. public static class Config {
  51. }

MyBatis 整合 Spring 源码

MapperScan 注解

我们可以看到 MapperScan 上面也有一个 @Import(MapperScannerRegistrar.class) 注解

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.TYPE)
  3. @Documented
  4. @Import(MapperScannerRegistrar.class)
  5. public @interface MapperScan {
  6. }

MapperScannerRegistrar 的实现

  1. public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
  3.   private ResourceLoader resourceLoader;
  5.   /**
  6.    * {@inheritDoc}
  7.    */
  8.   @Override
  9.   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  11.     // 获取 MapperScan 注解
  12.     AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
  13.     ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
  15.     // this check is needed in Spring 3.1
  16.     if (resourceLoader != null) {
  17.       scanner.setResourceLoader(resourceLoader);
  18.     }
  20.     Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
  21.     if (!Annotation.class.equals(annotationClass)) {
  22.       scanner.setAnnotationClass(annotationClass);
  23.     }
  25.     Class<?> markerInterface = annoAttrs.getClass("markerInterface");
  26.     if (!Class.class.equals(markerInterface)) {
  27.       scanner.setMarkerInterface(markerInterface);
  28.     }
  30.     Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
  31.     if (!BeanNameGenerator.class.equals(generatorClass)) {
  32.       scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
  33.     }
  35.     Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
  36.     if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
  37.       scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
  38.     }
  40.     scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
  41.     scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
  43.     List<String> basePackages = new ArrayList<String>();
  44.     for (String pkg : annoAttrs.getStringArray("value")) {
  45.       if (StringUtils.hasText(pkg)) {
  46.         basePackages.add(pkg);
  47.       }
  48.     }
  49.     for (String pkg : annoAttrs.getStringArray("basePackages")) {
  50.       if (StringUtils.hasText(pkg)) {
  51.         basePackages.add(pkg);
  52.       }
  53.     }
  54.     for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {
  55.       basePackages.add(ClassUtils.getPackageName(clazz));
  56.     }
  58.     // 注册 filters
  59.     scanner.registerFilters();
  61.     // 开始进行扫描
  62.     scanner.doScan(StringUtils.toStringArray(basePackages));
  63.   }
  65.   /**
  66.    * {@inheritDoc}
  67.    */
  68.   @Override
  69.   public void setResourceLoader(ResourceLoader resourceLoader) {
  70.     this.resourceLoader = resourceLoader;
  71.   }
  73. }

看下 MyBatis 是如果定义扫描器的
  1. public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
  3.     public ClassPathMapperScanner(BeanDefinitionRegistry registry) {
  4.         // 我们可以看到传递的 useDefaultFilters 属性为 false
  5.         super(registry, false);
  6.     }
  8.     @Override
  9.     protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
  10.         // 必须是接口
  11.         return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
  12.     }
  13. }

我们可以看到传递的 useDefaultFilters 属性为 false，表示不使用 Spring 中的默认过滤器，因为 Spring 默认不会使用接口来注册 BeanDefinition

我们继续看 MyBatis 注册的过滤器

从这里我们可以看出 MyBatis 会把所有的类（包括接口）都扫描出来

  1. addIncludeFilter(new TypeFilter() {
  2.     @Override
  3.     public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  4.         return true;
  5.     }
  6. });

doScan 的实现

经过 MyBatis 的过滤器和 isCandidateComponent 的判断，现在可以进行扫描了

  1. public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
  3.     @Override
  4.     public Set<BeanDefinitionHolder> doScan(String... basePackages) {
  5.         // 经过 MyBatis 的过滤器和 isCandidateComponent 的判断，这里扫描出来的都是接口了
  6.         Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
  8.         if (beanDefinitions.isEmpty()) {
  9.             logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
  10.         } else {
  11.             processBeanDefinitions(beanDefinitions);
  12.         }
  14.         return beanDefinitions;
  15.     }
  17.     private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
  18.         GenericBeanDefinition definition;
  19.         for (BeanDefinitionHolder holder : beanDefinitions) {
  20.             definition = (GenericBeanDefinition) holder.getBeanDefinition();
  22.             if (logger.isDebugEnabled()) {
  23.                 logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() 
  24.                              + "' and '" + definition.getBeanClassName() + "' mapperInterface");
  25.             }
  27.             // the mapper interface is the original class of the bean
  28.             // but, the actual class of the bean is MapperFactoryBean
  29.             // 将 beanClass 作为 MapperFactoryBean 的构造方法参数
  30.             definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
  31.             // 同时修改 beanClass 为 MapperFactoryBean
  32.             definition.setBeanClass(this.mapperFactoryBean.getClass());
  34.             definition.getPropertyValues().add("addToConfig", this.addToConfig);
  36.             boolean explicitFactoryUsed = false;
  37.             if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
  38.                 definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
  39.                 explicitFactoryUsed = true;
  40.             } else if (this.sqlSessionFactory != null) {
  41.                 definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
  42.                 explicitFactoryUsed = true;
  43.             }
  45.             if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
  46.                 if (explicitFactoryUsed) {
  47.                     logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  48.                 }
  49.                 definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
  50.                 explicitFactoryUsed = true;
  51.             } else if (this.sqlSessionTemplate != null) {
  52.                 if (explicitFactoryUsed) {
  53.                     logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  54.                 }
  55.                 definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
  56.                 explicitFactoryUsed = true;
  57.             }
  59.             if (!explicitFactoryUsed) {
  60.                 if (logger.isDebugEnabled()) {
  61.                     logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
  62.                 }
  63.                 definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  64.             }
  65.         }
  66.     }
  67. }

MyBatis-Spring 2.0.X 的实现

在 MyBatis-Spring-2.0.X 版本中并没有直接通过 registerBeanDefinitions 进行扫描，而是直接向容器中注册了一个 MapperScannerConfigurer 类，我们先看下这个类

  1. public class MapperScannerConfigurer
  2.     implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
  3. }

我们可以看到 MapperScannerConfigurer 这类实现了 BeanDefinitionRegistryPostProcessor 接口，那么 Spring 在启动后，会找到 MapperScannerConfigurer 类，然后执行 postProcessBeanDefinitionRegistry 方法来进行扫描和注册，其他并没有变动，只是多做了一层

  • 老版本：MapperScannerRegistrar => registerBeanDefinitions => scanner => 注册 BeanDefinition
  • 新版本：MapperScannerRegistrar => registerBeanDefinitions => 注册 MapperScannerConfigurer => Spring 调用 BeanDefinitionRegistryPostProcessor 的后置处理器 => scanner => 注册 BeanDefinition

乍一看新版本反而还多做了一步，反而麻烦了，为什么要多注册一个 MapperScannerConfigurer，然后通过后置处理器的方式来进行扫描呢？

其实这里 MyBatis 提供了一种扩展机制，也就是说，我们可以不需要写 @MapperScan 注解来进行扫描，而通过 @Bean 的方式注册 MapperScannerConfigurer 来替代 @MapperScan 注解

  1. @Bean
  2. public MapperScannerConfigurer mapperScannerConfigurer(){
  3.     MapperScannerConfigurer configurer = new MapperScannerConfigurer();
  4.     configurer.setBasePackage("com.sourceflag.spring.mybatis");
  5.     return configurer;
  6. }