整体流程
创建扫描器实例
扫描器根据配置注册过滤器
扫描器进行扫描
扫描后获取bean定义交给Spring进行加载
spring通过MapperFactoryBean获取到Mapper的代理对象
结束
文本概括- 创建扫描器实例
- 如何使用的是@MapperScan，@MapperScan中配置了@import(MapperScannerRegistrar.class)注解 会使MapperScannerRegistrar类在启动时自动加载 （待-见spring学习）
- MapperScannerRegistrar 并加载 registerBeanDefinitions 方法
- 创建扫描器实例
- 设置resourceLoader属性（资源加载器）
- 设置Annotation属性（被修饰的注解）
- 设置markerInterface属性（继承的父类）
- 设置ameGenerator属性（名字生成器）
- 设置factoryBean属性 （工厂bean对象）
- 设置SqlSessionTemplateBeanName属性 （指定使用的SqlSessionTemplate、通常多个数据源使用）
- 设置basePackages属性 （要扫描的包）
- 创建扫描器实例
- MapperScannerRegistrar 并加载 registerBeanDefinitions 方法
- 如果在mapper接口上配置@Mapper注解后，MybatisAutoConfiguration中的内部类AutoConfiguredMapperScannerRegistrar
- 执行registerBeanDefinitions方法
- 创建扫描器实例
- 设置resourceLoader属性（资源加载器）
- 设置Annotation属性（被修饰的注解）设置值为Mapper.class
- 创建扫描器实例
- 执行registerBeanDefinitions方法
- 如何使用的是@MapperScan，@MapperScan中配置了@import(MapperScannerRegistrar.class)注解 会使MapperScannerRegistrar类在启动时自动加载 （待-见spring学习）
- 扫描器注册过滤器
- 判断是否设置了Annotation类型，如果设置了添加指定注解类型的过滤器
- 判断是否设置了markerInterface属性，如果设置了添加指定父类的过滤器
- 如果以上属性没有被设置，添加默认的过滤器（直接返回true - 不过滤）
- 添加 package-info.java 过滤器
- 扫描器进行扫描
- 将包路径交给父类扫描（org.springframework.context.annotation.ClassPathBeanDefinitionScanner）扫描
- 对扫描后得到的bean定义持有者们进行遍历
- 获取bean定义
- 设置bean定义的 原类型和bean类（mapperFactoryBean）
- bean定义中添加属性 addToConfig
- 如果设置了sqlSessionTemplate 或者 设置了sqlSessionFactory的话，将bean定义自定注入类型设置为 AUTOWIRE_BY_TYPE （根据类型）
- bean定义修改好后，将bean定义交给 springbean的注册实例方法 进行实例化
- 最终调用org.mybatis.spring.mapper.MapperFactoryBean#getObject获取mapper的代理实例
- 调用SqlSession获取Mapper实例
- 在SqlSession中获取configuration对象，通过configuration获取Mapper实例
- 在configuration中获取mapperRegistry对象，在mapperRegistry中获取Mapper实例
- 通过mapperRegistry中的knownMappers（Key（接口class），value该接口的代理工厂对象）获取到代理工厂对象 （在启动时解析mapper.xml中sql的时候存储的 方法 -> xmlMapperBuilder.parse()）
- 通过代理工厂对象获取代理实例
- 通过SqlSession创建代理对象
- 将代理对象交给代理，代理的类为mapper接口
- 最终调用org.mybatis.spring.mapper.MapperFactoryBean#getObject获取mapper的代理实例
@Override
public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry) {
// 获取MapperScan对象
AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassmetadata.getAnnotationAttributes(MapperScan.class.getName()));
// 通过bean注册表获取 mapper类路径扫描器
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
// 设置 资源加载器
if (resourceLoader != null) {
scanner.setResourceLoader(resourceLoader);
}
// 在MapperScan中获取annotationClass属性 如果不为Annotation类型 扫描器中设置 AnnotationClass
Class annotationClass = annoAttrs.getClass("annotationClass");
if (!Annotation.class.equals(annotationClass)) {
scanner.setAnnotationClass(annotationClass);
}
// 在MapperScan中获取markerInterface属性 如果不为Class类型 扫描器中配置markerInterface
Class markerInterface = annoAttrs.getClass("markerInterface");
if (!Class.class.equals(markerInterface)) {
scanner.setMarkerInterface(markerInterface);
}
// 在MapperScan中获取nameGenerator属性 如果不为BeanNameGenerator类型 扫描器中配置generatorClass
Class generatorClass = annoAttrs.getClass("nameGenerator");
if (!BeanNameGenerator.class.equals(generatorClass)) {
scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
}
// 在MapperScan中获取factoryBean属性 如果不为MapperFactoryBean类型 扫描器中配置mapperFactoryBeanClass
Class mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
}
// 扫描器中配置SqlSessionTemplateBeanName 和 SqlSessionFactoryBeanName
scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
// 设置要扫描的包
List basePackages = new ArrayList();
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();
scanner.doScan(StringUtils.toStringArray(basePackages));
}
接口上配置@mapper注解
源码解析（AutoConfiguredMapperScannerRegistrar#registerBeanDefinitions）在MybatisAutoConfiguration中有一个内部类：AutoConfiguredMapperScannerRegistrar,内部类AutoConfiguredMapperScannerRegistrar实现了importBeanDefinitionRegistrar接口，在spring项目启动时会执行registerBeanDefinitions方法
@Override
public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry) {
// 通过bean注册表获取 mapper类路径扫描器
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
try {
// 在类扫描器中中 设置 resourceLoader
if (this.resourceLoader != null) {
scanner.setResourceLoader(this.resourceLoader);
}
// 会获取到启动类所在的包，作为扫描包的根路径
List packages = AutoConfigurationPackages.get(this.beanFactory);
if (logger.isDebugEnabled()) {
for (String pkg : packages) {
logger.debug("Using auto-configuration base package '{}'", pkg);
}
}
// 设置要扫描的注解为 Mapper
scanner.setAnnotationClass(Mapper.class);
// 注册过滤器
scanner.registerFilters();
// 进行扫描
scanner.doScan(StringUtils.toStringArray(packages));
} catch (IllegalStateException ex) {
logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
}
}
通用方法
源码解析（registerFilters）
public void registerFilters() {
// 是否全接口注入标记
boolean acceptAllInterfaces = true;
// 如果配置了 annotationClass，新增一个注解过滤器，并且设置不全注入
if (this.annotationClass != null) {
addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
acceptAllInterfaces = false;
}
// 如果配置了 markerInterface，新增一个父类接口过滤器，并且设置不全注入
if (this.markerInterface != null) {
addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
@Override
protected boolean matchClassName(String className) {
return false;
}
});
acceptAllInterfaces = false;
}
// 如果全接口注入
if (acceptAllInterfaces) {
// 新增一个默认的过滤器，比较永远返回true
addIncludeFilter(new TypeFilter() {
@Override
public boolean match(metadataReader metadataReader, metadataReaderFactory metadataReaderFactory) throws IOException {
return true;
}
});
}
// 排除 package-info.java 类
addExcludeFilter(new TypeFilter() {
@Override
public boolean match(metadataReader metadataReader, metadataReaderFactory metadataReaderFactory) throws IOException {
String className = metadataReader.getClassmetadata().getClassName();
return className.endsWith("package-info");
}
});
}
源码解析（doScan）
@Override public Set获取代理BEAN 源码解析（MapperFactoryBean#getObject）doScan(String... basePackages) { // 使用spring的扫描器获取到 bean定义的持有者 Set beanDefinitions = super.doScan(basePackages); // 如果bean定义为空，打印警告日志 否则 处理bean的持有者定义 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 beanDefinitions) { // 声明一个 GenericBeanDefinition 实例 GenericBeanDefinition definition; // 循环所有的bean定义持有者 for (BeanDefinitionHolder holder : beanDefinitions) { // 获取持有者的bean定义 definition = (GenericBeanDefinition) holder.getBeanDefinition(); // 设置bean定义的 原类型和bean类（mapperFactoryBean） definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59 definition.setBeanClass(this.mapperFactoryBean.getClass()); // bean定义中添加属性 addToConfig definition.getPropertyValues().add("addToConfig", this.addToConfig); // 声明 是否有使用的bean工厂标识 默认 没有，当有设置SessionFactoryBeanName或者当前sqlSessionFactory不为空是 添加属性sqlSessionFactory 并将标识改为true 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; } // 如果设置了 SessionTemplateBeanName 或者 当前类有 sqlSessionTemplate 时添加属性 sqlSessionTemplate 并将 并将 是否有使用的bean工厂标识 改为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; } // 如果 有使用的bean工厂标识 设置自动装配模式为 根据类型装配 if (!explicitFactoryUsed) { if (logger.isDebugEnabled()) { logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'."); } definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE); } } }
@Override
public T getObject() throws Exception {
// 通过SqlSession获取Mapper实例
return getSqlSession().getMapper(this.mapperInterface);
}
@Override
public T getMapper(Class type) {
// 通过configuration获取Mapper实例
return configuration.getMapper(type, this);
}
public T getMapper(Class type, SqlSession sqlSession) {
// 调用mapper注册器获取mapper实例
return mapperRegistry.getMapper(type, sqlSession);
}
public T getMapper(Class type, SqlSession sqlSession) {
// knownMappers 为mybatis启动时扫描mapper接口，存放到mapperRegistry的knownMappers的mapperProxyFactory（代理工厂对象）
final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
// 如果代理工厂对象为空 标识该接口没有被注册
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
