概述
MapperFactoryBean扩展SqlSessionDaoSupport
SqlSessionDaoSupport可以设置SqlSessionFactory或SqlSessionTemplate，对于设置SqlSessionFactory会包装成SqlSessionTemplate
SqlSessionTemplate实现了SqlSession接口，实例化SqlSessionTemplate时，会创建SqlSession代理实例，对于SqlSession接口的操作都委托给SqlSession代理，SqlSession代理主要是关于SqlSession的获取与释放。
一、基于XML注册MapperFactoryBean
<bean id=”userMapper” class=”org.mybatis.Spring.mapper.MapperFactoryBean”>
<property name= “mapper Interface” value=”test.mybatis.dao.UserMapper”>/property>
<property name=”sqlSessionFactory” ref=”sqlSessionFactory”></property>
</bean>
每一个Mapper接口都要配置一个MapperFactoryBean，如果有大量Mapper接口接口都要配置，将是一项繁琐而已出错的任务。有没有一种方式可以根据指定的注解/接口或者包路径，自动扫描出符合规则的Mapper接口注册为MapperFactoryBean。
Spring为我们预留了很多扩展点，参与到容器启动流程中。通过扩展BeanDefinitionRegistryPostProcessor可以注册自定义BeanDefinition。
二、基于XML自动注册MapperFactoryBean
以下两种方式均可自动扫描Mapper接口注册为MapperFactoryBean。
<mybatis:scan base-package=”com.lemon.mapper”/>
<bean class=”org.mybatis.spring.mapper.MapperScannerConfigurer”>
<property name=”basePackage” value=”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
// 从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();
}
}