Mybatis集成Spring原理分析

最新推荐文章于 2024-07-22 16:47:08 发布

只道当时是寻常

最新推荐文章于 2024-07-22 16:47:08 发布

阅读量1.5k

点赞数

分类专栏： Spring5.x

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/hjtlovelife/article/details/104600440

版权

Spring5.x 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

概述

MapperFactoryBean扩展SqlSessionDaoSupport

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

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

一、基于XML注册MapperFactoryBean

<property name= "mapper Interface" value="test.mybatis.dao.UserMapper">/property>

</bean>

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

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

二、基于XML自动注册MapperFactoryBean

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

<mybatis:scan base-package="com.lemon.mapper"/>

</bean>

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

<mybatis:scan base-package="com.lemon.mapper"/>

public class NamespaceHandler extends NamespaceHandlerSupport {

@Override

public void init() {

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

}

2.2 注册类型为MapperScannerConfigurer的Bean MapperScannerBeanDefinitionParser

2.2.1 MapperScannerConfigurer类图

由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<? extends Annotation> annotationClass = (Class<? extends Annotation>) 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<? extends MapperFactoryBean> mapperFactoryBeanClass = (Class<? extends MapperFactoryBean>) 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<String, PropertyResourceConfigurer> 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

// 可以搜索所有接口，也可以仅搜索扩展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<BeanDefinitionHolder> doScan(String... basePackages) {

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

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

// 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<? extends Annotation> 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<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");

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

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

}

Class<? extends MapperFactoryBean> 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<String> 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类图

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<T> 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

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

}

只道当时是寻常

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Mybatis集成Spring原理分析

概述MapperFactoryBean扩展SqlSessionDaoSupportSqlSessionDaoSupport可以设置SqlSessionFactory或SqlSessionTemplate，对于设置SqlSessionFactory会包装成SqlSessionTemplateSqlSessionTemplate实现了SqlSession接口，实例化SqlSessionTe...
复制链接

扫一扫

专栏目录