Mybatis集成Spring原理分析

概述

MapperFactoryBean扩展SqlSessionDaoSupport

SqlSessionDaoSupport可以设置SqlSessionFactory或SqlSessionTemplate,对于设置SqlSessionFactory会包装成SqlSessionTemplate

SqlSessionTemplate实现了SqlSession接口,实例化SqlSessionTemplate时,会创建SqlSession代理实例,对于SqlSession接口的操作都委托给SqlSession代理,SqlSession代理主要是关于SqlSession的获取与释放。

 

一、基于XML注册MapperFactoryBean

/property>

 

每一个Mapper接口都要配置一个MapperFactoryBean,如果有大量Mapper接口接口都要配置,将是一项繁琐而已出错的任务。有没有一种方式可以根据指定的注解/接口或者包路径,自动扫描出符合规则的Mapper接口注册为MapperFactoryBean。

Spring为我们预留了很多扩展点,参与到容器启动流程中。通过扩展BeanDefinitionRegistryPostProcessor可以注册自定义BeanDefinition。

 

二、基于XML自动注册MapperFactoryBean

以下两种方式均可自动扫描Mapper接口注册为MapperFactoryBean。

 

   

 

2.1 自定义名称空间注册解析器 NamespaceHandler

 

public class NamespaceHandler extends NamespaceHandlerSupport {

 @Override

 public void init() {

   registerBeanDefinitionParser("scan", new MapperScannerBeanDefinitionParser());

 }

}

 

2.2 注册类型为MapperScannerConfigurer的Bean MapperScannerBeanDefinitionParser

2.2.1 MapperScannerConfigurer类图

Mybatis集成Spring原理分析_第1张图片

 

由Spring启动加载流程(参考《容器刷新步骤五-调用注册的BeanFactoryPostProcessor》)可知BeanDefinitionRegistryPostProcessor比BeanFactoryPostProcessor先执行,PropertyResourceConfigurers是加载外部配置的,实现了BeanFactoryPostProcessor,在执行BeanDefinitionRegistryPostProcessor的

postProcessBeanDefinitionRegistry方法时,PropertyResourceConfigurers在其后执行是不会对使用到${propertyName}属性值替换占位符的,所以需要特殊处理。

PropertyPlaceholderConfigurer实现了PropertyResourceConfigurers,会对配置中使用到占位符的地方替换成配置值。

 

2.2.2 注册MapperScannerConfigurer

private static final String ATTRIBUTE_BASE_PACKAGE = "base-package";

 private static final String ATTRIBUTE_ANNOTATION = "annotation";

 private static final String ATTRIBUTE_MARKER_INTERFACE = "marker-interface";

 private static final String ATTRIBUTE_NAME_GENERATOR = "name-generator";

 private static final String ATTRIBUTE_TEMPLATE_REF = "template-ref";

 private static final String ATTRIBUTE_FACTORY_REF = "factory-ref";

 private static final String ATTRIBUTE_MAPPER_FACTORY_BEAN_CLASS = "mapper-factory-bean-class";

 private static final String ATTRIBUTE_LAZY_INITIALIZATION = "lazy-initialization";

 

 @Override

 protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {

// scan元素注册成类型为MapperScannerConfigurer.class的Bean

   BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);

 

   ClassLoader classLoader = ClassUtils.getDefaultClassLoader();

 

   // 这里设置这个参数有什么作用?继续往下看

   builder.addPropertyValue("processPropertyPlaceHolders", true);

   try {

     String annotationClassName = element.getAttribute(ATTRIBUTE_ANNOTATION);

     if (StringUtils.hasText(annotationClassName)) {

       @SuppressWarnings("unchecked")

       Class annotationClass = (Class) classLoader

           .loadClass(annotationClassName);

       builder.addPropertyValue("annotationClass", annotationClass);

     }

     String markerInterfaceClassName = element.getAttribute(ATTRIBUTE_MARKER_INTERFACE);

     if (StringUtils.hasText(markerInterfaceClassName)) {

       Class markerInterface = classLoader.loadClass(markerInterfaceClassName);

       builder.addPropertyValue("markerInterface", markerInterface);

     }

     String nameGeneratorClassName = element.getAttribute(ATTRIBUTE_NAME_GENERATOR);

     if (StringUtils.hasText(nameGeneratorClassName)) {

       Class nameGeneratorClass = classLoader.loadClass(nameGeneratorClassName);

       BeanNameGenerator nameGenerator = BeanUtils.instantiateClass(nameGeneratorClass, BeanNameGenerator.class);

       builder.addPropertyValue("nameGenerator", nameGenerator);

     }

     String mapperFactoryBeanClassName = element.getAttribute(ATTRIBUTE_MAPPER_FACTORY_BEAN_CLASS);

     if (StringUtils.hasText(mapperFactoryBeanClassName)) {

       @SuppressWarnings("unchecked")

       Class mapperFactoryBeanClass = (Class) classLoader

           .loadClass(mapperFactoryBeanClassName);

       builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);

     }

   } catch (Exception ex) {

     XmlReaderContext readerContext = parserContext.getReaderContext();

     readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());

   }

 

   builder.addPropertyValue("sqlSessionTemplateBeanName", element.getAttribute(ATTRIBUTE_TEMPLATE_REF));

   builder.addPropertyValue("sqlSessionFactoryBeanName", element.getAttribute(ATTRIBUTE_FACTORY_REF));

   builder.addPropertyValue("lazyInitialization", element.getAttribute(ATTRIBUTE_LAZY_INITIALIZATION));

   builder.addPropertyValue("basePackage", element.getAttribute(ATTRIBUTE_BASE_PACKAGE));

 

   return builder.getBeanDefinition();

 }

 

2.3 创建ClassPathMapperScanner自动扫描Mapper接口

2.3.1 创建ClassPathMapperScanner-postProcessBeanDefinitionRegistry

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {

   // 用到了1.2中设置的值,在这里会替换占位符

   if (this.processPropertyPlaceHolders) {

     processPropertyPlaceHolders();

   }

 

   // 创建ClassPathMapperScanner用来扫描basePackage指定包下的类,注册成MapperFactoryBean

   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.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);

   if (StringUtils.hasText(lazyInitialization)) {

     scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));

   }

   // 根据annotationClass、markerInterface生成过滤器,添加排除package-info类的过滤器

   scanner.registerFilters();

   scanner.scan(

       StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));

 }

 

 private void processPropertyPlaceHolders() {

   Map prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);

 

   if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) {

     BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext).getBeanFactory()

         .getBeanDefinition(beanName);

 

     // PropertyResourceConfigurer不会公开任何方法来显式执行属性占位符替换。 相反,创建一个仅包含此mapper scanner的BeanFactory并对工厂进行后处理。

     DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

     factory.registerBeanDefinition(beanName, mapperScannerBean);

 

// 属性占位符替换

     for (PropertyResourceConfigurer prc : prcs.values()) {

       prc.postProcessBeanFactory(factory);

     }

 

// 属性占位符已被替换

     PropertyValues values = mapperScannerBean.getPropertyValues();

     // 获取属性占位符被替换后的值

     this.basePackage = updatePropertyValue("basePackage", values);

     this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);

     this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);

     this.lazyInitialization = updatePropertyValue("lazyInitialization", values);

   }

 

   // 如果没有在外部配置文件中配置值,则使用Environment替换属性占位符

   this.basePackage = Optional.ofNullable(this.basePackage).map(getEnvironment()::resolvePlaceholders).orElse(null);

   this.sqlSessionFactoryBeanName = Optional.ofNullable(this.sqlSessionFactoryBeanName)

       .map(getEnvironment()::resolvePlaceholders).orElse(null);

   this.sqlSessionTemplateBeanName = Optional.ofNullable(this.sqlSessionTemplateBeanName)

       .map(getEnvironment()::resolvePlaceholders).orElse(null);

   this.lazyInitialization = Optional.ofNullable(this.lazyInitialization).map(getEnvironment()::resolvePlaceholders)

       .orElse(null);

 }

 

 // 属性占位符被替换后的值是NULL/String/TypedStringValue

 private String updatePropertyValue(String propertyName, PropertyValues values) {

   PropertyValue property = values.getPropertyValue(propertyName);

 

   if (property == null) {

     return null;

   }

 

   Object value = property.getValue();

 

   if (value == null) {

     return null;

   } else if (value instanceof String) {

     return value.toString();

   } else if (value instanceof TypedStringValue) {

     return ((TypedStringValue) value).getValue();

   } else {

     return null;

   }

 }

 

2.3.2 注册自动扫描时过滤器 ClassPathMapperScanner.registerFilters

Mybatis集成Spring原理分析_第2张图片

 

// 可以搜索所有接口,也可以仅搜索扩展markerInterface的接口或和带有annotationClass注释的接口

public void registerFilters() {

   boolean acceptAllInterfaces = true;

 

   // 如果指定,请使用给定的注释和/或标记接口

   if (this.annotationClass != null) {

     addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));

     acceptAllInterfaces = false;

   }

 

   // 覆盖AssignableTypeFilter以忽略实际标记接口上的匹配

   if (this.markerInterface != null) {

     addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {

       @Override

       protected boolean matchClassName(String className) {

         return false;

       }

     });

     acceptAllInterfaces = false;

   }

 

   if (acceptAllInterfaces) {

     // 默认包含所有类的过滤器

     addIncludeFilter((metadataReader, metadataReaderFactory) -> true);

   }

 

   // 排除ackage-info.java

   addExcludeFilter((metadataReader, metadataReaderFactory) -> {

     String className = metadataReader.getClassMetadata().getClassName();

     return className.endsWith("package-info");

   });

 }

 

2.4 接口注册成MapperFactoryBean ClassPathMapperScanner

2.4.1 扫描Mapper接口注册为MapperFactoryBean

@Override

public Set doScan(String... basePackages) {

   // 获取要注册成MapperFactoryBean的接口

   Set 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 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");

 

     // mapper接口是Bean的原始类,但是,该bean的实际类是MapperFactoryBean

     definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); 

     definition.setBeanClass(this.mapperFactoryBeanClass);

 

     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;

     }

 

     // 不能同时使用:sqlSessionTemplate和sqlSessionFactory。 sqlSessionFactory被忽略。

     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);

     }

     definition.setLazyInit(lazyInitialization);

   }

 }

 

三、基于注解注册MapperFactoryBean

3.1 @MapperScan

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

@Documented

@Import(MapperScannerRegistrar.class)

@Repeatable(MapperScans.class)

public @interface MapperScan

 

3.2 MapperScannerRegistrar

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

   AnnotationAttributes mapperScanAttrs = AnnotationAttributes

       .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));

   if (mapperScanAttrs != null) {

     registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry, generateBaseBeanName(importingClassMetadata, 0));

   }

 }

 

 void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry, String beanName) {

   // 注册类型为MapperScannerConfigurer.class的Bean,回到了2.2

   BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);

   builder.addPropertyValue("processPropertyPlaceHolders", true);

 

   Class annotationClass = annoAttrs.getClass("annotationClass");

   if (!Annotation.class.equals(annotationClass)) {

     builder.addPropertyValue("annotationClass", annotationClass);

   }

 

   Class markerInterface = annoAttrs.getClass("markerInterface");

   if (!Class.class.equals(markerInterface)) {

     builder.addPropertyValue("markerInterface", markerInterface);

   }

 

   Class generatorClass = annoAttrs.getClass("nameGenerator");

   if (!BeanNameGenerator.class.equals(generatorClass)) {

     builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));

   }

 

   Class mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");

   if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {

     builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);

   }

 

   String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");

   if (StringUtils.hasText(sqlSessionTemplateRef)) {

     builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));

   }

 

   String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");

   if (StringUtils.hasText(sqlSessionFactoryRef)) {

     builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));

   }

 

   List basePackages = new ArrayList<>();

   basePackages.addAll(

       Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));

 

   basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)

       .collect(Collectors.toList()));

 

   basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)

       .collect(Collectors.toList()));

 

   if (basePackages.isEmpty()) {

     basePackages.add(getDefaultBasePackage(annoMeta));

   }

 

   String lazyInitialization = annoAttrs.getString("lazyInitialization");

   if (StringUtils.hasText(lazyInitialization)) {

     builder.addPropertyValue("lazyInitialization", lazyInitialization);

   }

 

   builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));

 

   registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

 }

 

 private static String generateBaseBeanName(AnnotationMetadata importingClassMetadata, int index) {

   return importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;

 }

 

 private static String getDefaultBasePackage(AnnotationMetadata importingClassMetadata) {

   return ClassUtils.getPackageName(importingClassMetadata.getClassName());

 }

 

四、SqlSessionFactoryBean

4.1 创建SqlSessionFactory

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();

 }

 

 // 基于Mybatis Configuration配置或者XML配置文件

 protected SqlSessionFactory buildSqlSessionFactory() throws Exception {

 

   final Configuration targetConfiguration;

 

   XMLConfigBuilder xmlConfigBuilder = null;

   if (this.configuration != null) {

     targetConfiguration = this.configuration;

// Mybatis Properties设置

     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)) {

     scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()

         .filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())

         .filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);

   }

 

   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)) {

     scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass())

         .filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))

         .forEach(targetConfiguration.getTypeHandlerRegistry()::register);

   }

 

   if (!isEmpty(this.typeHandlers)) {

     Stream.of(this.typeHandlers).forEach(typeHandler -> {

       targetConfiguration.getTypeHandlerRegistry().register(typeHandler);

       LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");

     });

   }

 

   if (!isEmpty(this.scriptingLanguageDrivers)) {

     Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {

       targetConfiguration.getLanguageRegistry().register(languageDriver);

       LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");

     });

   }

   Optional.ofNullable(this.defaultScriptingLanguageDriver)

       .ifPresent(targetConfiguration::setDefaultScriptingLanguage);

 

   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 (this.mapperLocations != null) {

     if (this.mapperLocations.length == 0) {

       LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");

     } else {

       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.");

   }

 

   return this.sqlSessionFactoryBuilder.build(targetConfiguration);

 }

 

五、SqlSessionTemplate

5.1 创建SqlSession代理 SqlSessionTemplate

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {

   this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());

 }

 

 public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {

   this(sqlSessionFactory, executorType,

       new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));

 }

 

private final SqlSession sqlSessionProxy;

 

 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;

   // 创建SqlSession代理,从Spring事务管理器获取SqlSession或根据需要创建一个新的SqlSession。尝试从当前事务中获取SqlSession。如果没有,它将创建一个新的。

   this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),

       new Class[] { SqlSession.class }, new SqlSessionInterceptor());

 }

 

5.2 SqlSession代理拦截器 SqlSessionInterceptor

private class SqlSessionInterceptor implements InvocationHandler {

   @Override

   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    // 从Spring事务管理器获取SqlSession或根据需要创建一个新的SqlSession。尝试从当前事务中获取SqlSession。如果没有,它将创建一个新的。然后,如果Spring TX处于活动状态并且 SpringManagedTransactionFactory被配置为事务管理器,则它将SqlSession与事务同步。 SqlSessionUtils.getSqlSession

     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)) {

         // 即使在非脏会话上也强制提交,因为某些数据库在调用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);

       }

     }

   }

 }

 

六、MapperFactoryBean

6..1 MapperFactoryBean类图

Mybatis集成Spring原理分析_第3张图片

 

6.1.1 初始化时检测 checkDaoConfig

protected void checkDaoConfig() {

   super.checkDaoConfig();

 

   notNull(this.mapperInterface, "Property 'mapperInterface' is required");

 

   Configuration configuration = getSqlSession().getConfiguration();

   if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {

     try {

       // Mapper接口注册到Mybatis的Configuration里

       configuration.addMapper(this.mapperInterface);

     } catch (Exception e) {

       logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);

       throw new IllegalArgumentException(e);

     } finally {

       ErrorContext.instance().reset();

     }

   }

 }

 

 @Override

 public T getObject() throws Exception {

   // 调用父类SqlSessionDaoSupport的方法getSqlSession,获取到的是SqlSessionTemplate

   return getSqlSession().getMapper(this.mapperInterface);

 }

 

 @Override

 public Class getObjectType() {

   return this.mapperInterface;

 }

 

 @Override

 public boolean isSingleton() {

   return true;

 }

 

6.2 设置setSqlSessionFactory或setSqlSessionTemplate SqlSessionDaoSupport

  // 设置MyBatis的SqlSessionFactory供此DAO使用。将自动为给定 SqlSessionFactory创建SqlSessionTemplate。未设置sqlSessionTemplate或者已设置的sqlSessionTemplate所属的SqlSessionFactory和当前参数不是同一个,则以参数sqlSessionFactory创建新的sqlSessionTemplate

 public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {

   if (this.sqlSessionTemplate == null || sqlSessionFactory != this.sqlSessionTemplate.getSqlSessionFactory()) {

     this.sqlSessionTemplate = createSqlSessionTemplate(sqlSessionFactory);

   }

 }

 

 protected SqlSessionTemplate createSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {

   return new SqlSessionTemplate(sqlSessionFactory);

 }

 

7、SqlSessionUtils

7.1 获取SqlSession getSqlSession

// 从Spring事务管理器获取SqlSession或根据需要创建一个新的SqlSession。尝试从当前事务中获取SqlSession。如果没有,它将创建一个新的。然后,如果Spring TX处于活动状态并且 SpringManagedTransactionFactory被配置为事务管理器,则它将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

   SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

 

   // 获取SqlSession

   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;

 }

 

private static SqlSession sessionHolder(ExecutorType executorType, SqlSessionHolder holder) {

   SqlSession session = null;

   if (holder != null && holder.isSynchronizedWithTransaction()) {

     // 存在现有事务时无法更改ExecutorType

     if (holder.getExecutorType() != executorType) {

       throw new TransientDataAccessResourceException(

           "Cannot change the ExecutorType when there is an existing transaction");

     }

 

     holder.requested();

 

     LOGGER.debug(() -> "Fetched SqlSession [" + holder.getSqlSession() + "] from current transaction");

     session = holder.getSqlSession();

   }

   return session;

 }

 

7.2 注册SqlSessionHolder registerSessionHolder

// 如果同步处于活动状态(即Spring TX处于活动状态),则注册会话持有者。 应该通过DataSourceTxMgr或其他tx同步将环境使用的DataSource与事务同步。

private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,

     PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {

   SqlSessionHolder holder;

   if (TransactionSynchronizationManager.isSynchronizationActive()) {

     Environment environment = sessionFactory.getConfiguration().getEnvironment();

 

     if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {

       LOGGER.debug(() -> "Registering transaction synchronization for SqlSession [" + session + "]");

 

       holder = new SqlSessionHolder(session, executorType, exceptionTranslator);

       TransactionSynchronizationManager.bindResource(sessionFactory, holder);

       TransactionSynchronizationManager

           .registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));

       holder.setSynchronizedWithTransaction(true);

       holder.requested();

     } else {

       if (TransactionSynchronizationManager.getResource(environment.getDataSource()) == null) {

         LOGGER.debug(() -> "SqlSession [" + session

             + "] was not registered for synchronization because DataSource is not transactional");

       } else {

         throw new TransientDataAccessResourceException(

             "SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization");

       }

     }

   } else {

     LOGGER.debug(() -> "SqlSession [" + session

         + "] was not registered for synchronization because synchronization is not active");

   }

 

 }

 

7.3 关闭SqlSession closeSqlSession

public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {

   notNull(session, NO_SQL_SESSION_SPECIFIED);

   notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);

 

   SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

   if ((holder != null) && (holder.getSqlSession() == session)) {

     LOGGER.debug(() -> "Releasing transactional SqlSession [" + session + "]");

     holder.released();

   } else {

     LOGGER.debug(() -> "Closing non transactional SqlSession [" + session + "]");

     session.close();

   }

 }

你可能感兴趣的:(Spring5.x)