Mybatis如何根据mapper接口生成其实现类

╰+哭是因爲堅強的太久メ 2022-01-22 09:17 246阅读 0赞

# Mybatis如何根据mapper接口生成其实现类  #

## 一、序 ##

mybatis里头给sqlSession指定执行哪条sql的时候，有两种方式，一种是写mapper的xml的namespace+statementId，如下：

1.  `public Student findStudentById(Integer studId) {`
2.  `logger.debug("Select Student By ID :{}", studId);`
3.  `SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();`
4.  `try {`
5.  `return sqlSession.selectOne("com.mybatis3.StudentMapper.findStudentById", studId);`
6.  `} finally {`
7.  `sqlSession.close();`
8.  `}`
9.  `}`

另外一种方法是指定mapper的接口：

1.  `public Student findStudentById(Integer studId) {`
2.  `logger.debug("Select Student By ID :{}", studId);`
3.  `SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();`
4.  `try {`
5.  `StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class); //接口`
6.  `return studentMapper.findStudentById(studId);`
7.  `} finally {`
8.  `sqlSession.close();`
9.  `}`
10. `}`

一般的话，比较推荐第二种方法，因为手工写namespace和statementId极大增加了犯错误的概率，而且也降低了开发的效率。

##  二、问题 ##

###  2.1 mapper的实现类如何生成 ###

如果使用mapper接口的方式，问题来了，这个是个接口，通过sqlSession对象get出来的一定是个实现类，问题是，我们并没有手工去写 实现类，那么谁去干了这件事情呢？

答案是mybatis通过JDK的动态代理方式，在启动加载配置文件时，根据配置mapper的xml去生成。

###  2.2 mybatis-spring帮忙做了什么 ###

自动open和close session.

##  三、mapper代理类是如何生成的 ##

3.1 启动时加载解析mapper的xml

如果不是集成spring的，会去读取<mappers>节点，去加载mapper的xml配置：

\[html\] [view plain][] [copy][view plain]

1.  <?xml version="1.0" encoding="UTF-8" ?>  
2.  <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  
3.  <configuration>  
4.      <settings>  
5.          <setting name="cacheEnabled" value="true"/>  
6.          <setting name="lazyLoadingEnabled" value="true"/>  
7.          <setting name="multipleResultSetsEnabled" value="true"/>  
8.          <setting name="useColumnLabel" value="true"/>  
9.          <setting name="useGeneratedKeys" value="false"/>  
10.         <setting name="defaultExecutorType" value="SIMPLE"/>  
11.         <setting name="defaultStatementTimeout" value="2"/>  
12.     </settings>  
13.     <typeAliases>  
14.         <typeAlias alias="CommentInfo" type="com.xixicat.domain.CommentInfo"/>  
15.     </typeAliases>  
16.     <environments default="development">  
17.         <environment id="development">  
18.             <transactionManager type="JDBC"/>  
19.             <dataSource type="POOLED">  
20.                 <property name="driver" value="com.mysql.jdbc.Driver"/>  
21.                 <property name="url" value="jdbc:mysql://localhost:3306/demo"/>  
22.                 <property name="username" value="root"/>  
23.                 <property name="password" value=""/>  
24.             </dataSource>  
25.         </environment>  
26.     </environments>  
27.     <mappers>  
28.         <mapper resource="com/xixicat/dao/CommentMapper.xml"/>  
29.     </mappers>  
30. </configuration>

如果是集成spring的，会去读spring的sqlSessionFactory的xml配置中的mapperLocations，然后去解析mapper的xml：

\[html\] [view plain][] [copy][view plain]

1.  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
2.          <property name="dataSource" ref="dataSource"/>  
3.            
4.          <property name="configLocation" value="classpath:mybatis-config.xml"/>  
5.          <property name="typeAliasesPackage" value="com.xixicat.domain"/>  
6.            
7.          <property name="mapperLocations" value="classpath:com/xixicat/dao/\*.xml"/>  
8.  </bean>

3.2 绑定namespace(`XMLMapperBuilder`)

1.  `private void bindMapperForNamespace() {`
2.  `String namespace = builderAssistant.getCurrentNamespace();`
3.  `if (namespace != null) {`
4.  `Class<?> boundType = null;`
5.  `try {`
6.  `boundType = Resources.classForName(namespace);`
7.  `} catch (ClassNotFoundException e) {`
8.  `//ignore, bound type is not required`
9.  `}`
10. `if (boundType != null) {`
11. `if (!configuration.hasMapper(boundType)) {`
12. `// Spring may not know the real resource name so we set a flag`
13. `// to prevent loading again this resource from the mapper interface`
14. `// look at MapperAnnotationBuilder#loadXmlResource`
15. `configuration.addLoadedResource("namespace:" + namespace);`
16. `configuration.addMapper(boundType);`
17. `}`
18. `}`
19. `}`
20. `}`

这里先去判断该namespace能不能找到对应的class，若可以则调用 configuration.addMapper(boundType);

configuration又委托给MapperRegistry:

1.  `public <T> void addMapper(Class<T> type) {`
2.  `mapperRegistry.addMapper(type);`
3.  `}`

3.3 生成该mapper的代理工厂(`MapperRegistry`)

1.  `public <T> void addMapper(Class<T> type) {`
2.  `if (type.isInterface()) {`
3.  `if (hasMapper(type)) {`
4.  `throw new BindingException("Type " + type + " is already known to the MapperRegistry.");`
5.  `}`
6.  `boolean loadCompleted = false;`
7.  `try {`
8.  `knownMappers.put(type, new MapperProxyFactory<T>(type));`
9.  `// It's important that the type is added before the parser is run`
10. `// otherwise the binding may automatically be attempted by the`
11. `// mapper parser. If the type is already known, it won't try.`
12. `MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);`
13. `parser.parse();`
14. `loadCompleted = true;`
15. `} finally {`
16. `if (!loadCompleted) {`
17. `knownMappers.remove(type);`
18. `}`
19. `}`
20. `}`
21. `}`

这里的重点就是MapperProxyFactory类：

1.  `public class MapperProxyFactory<T> {`
2.   
3.  `private final Class<T> mapperInterface;`
4.  `private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();`
5.   
6.  `public MapperProxyFactory(Class<T> mapperInterface) {`
7.  `this.mapperInterface = mapperInterface;`
8.  `}`
9.   
10. `public Class<T> getMapperInterface() {`
11. `return mapperInterface;`
12. `}`
13.  
14. `public Map<Method, MapperMethod> getMethodCache() {`
15. `return methodCache;`
16. `}`
17.  
18. `@SuppressWarnings("unchecked")`
19. `protected T newInstance(MapperProxy<T> mapperProxy) {`
20. `return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);`
21. `}`
22.  
23. `public T newInstance(SqlSession sqlSession) {`
24. `final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);`
25. `return newInstance(mapperProxy);`
26. `}`
27.  
28. `}`

3.4 getMapper的时候生成mapper代理类

1.  `@SuppressWarnings("unchecked")`
2.  `public <T> T getMapper(Class<T> type, SqlSession sqlSession) {`
3.  `final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);`
4.  `if (mapperProxyFactory == null) {`
5.  `throw new BindingException("Type " + type + " is not known to the MapperRegistry.");`
6.  `}`
7.  `try {`
8.  `return mapperProxyFactory.newInstance(sqlSession);`
9.  `} catch (Exception e) {`
10. `throw new BindingException("Error getting mapper instance. Cause: " + e, e);`
11. `}`
12. `}`

3.5 new出来MapperProxy

1.  `public T newInstance(SqlSession sqlSession) {`
2.  `final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);`
3.  `return newInstance(mapperProxy);`
4.  `}`
5.

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

这里给代理类注入了sqlSession

3.6 MapperProxy实现InvocationHandler接口进行拦截代理

1.  `public class MapperProxy<T> implements InvocationHandler, Serializable {`
2.   
3.  `private static final long serialVersionUID = -6424540398559729838L;`
4.  `private final SqlSession sqlSession;`
5.  `private final Class<T> mapperInterface;`
6.  `private final Map<Method, MapperMethod> methodCache;`
7.   
8.  `public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {`
9.  `this.sqlSession = sqlSession;`
10. `this.mapperInterface = mapperInterface;`
11. `this.methodCache = methodCache;`
12. `}`
13.  
14. `@Override`
15. `public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {`
16. `if (Object.class.equals(method.getDeclaringClass())) {`
17. `try {`
18. `return method.invoke(this, args);`
19. `} catch (Throwable t) {`
20. `throw ExceptionUtil.unwrapThrowable(t);`
21. `}`
22. `}`
23. `final MapperMethod mapperMethod = cachedMapperMethod(method);`
24. `return mapperMethod.execute(sqlSession, args);`
25. `}`
26.  
27. `private MapperMethod cachedMapperMethod(Method method) {`
28. `MapperMethod mapperMethod = methodCache.get(method);`
29. `if (mapperMethod == null) {`
30. `mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());`
31. `methodCache.put(method, mapperMethod);`
32. `}`
33. `return mapperMethod;`
34. `}`
35. `}`

这里的代理拦截，主要是寻找到MapperMethod，通过它去执行SQL。

3.7 MapperMethod委托给SqlSession去执行sql

1.  `public Object execute(SqlSession sqlSession, Object[] args) {`
2.  `Object result;`
3.  `if (SqlCommandType.INSERT == command.getType()) {`
4.  `Object param = method.convertArgsToSqlCommandParam(args);`
5.  `result = rowCountResult(sqlSession.insert(command.getName(), param));`
6.  `} else if (SqlCommandType.UPDATE == command.getType()) {`
7.  `Object param = method.convertArgsToSqlCommandParam(args);`
8.  `result = rowCountResult(sqlSession.update(command.getName(), param));`
9.  `} else if (SqlCommandType.DELETE == command.getType()) {`
10. `Object param = method.convertArgsToSqlCommandParam(args);`
11. `result = rowCountResult(sqlSession.delete(command.getName(), param));`
12. `} else if (SqlCommandType.SELECT == command.getType()) {`
13. `if (method.returnsVoid() && method.hasResultHandler()) {`
14. `executeWithResultHandler(sqlSession, args);`
15. `result = null;`
16. `} else if (method.returnsMany()) {`
17. `result = executeForMany(sqlSession, args);`
18. `} else if (method.returnsMap()) {`
19. `result = executeForMap(sqlSession, args);`
20. `} else {`
21. `Object param = method.convertArgsToSqlCommandParam(args);`
22. `result = sqlSession.selectOne(command.getName(), param);`
23. `}`
24. `} else if (SqlCommandType.FLUSH == command.getType()) {`
25. `result = sqlSession.flushStatements();`
26. `} else {`
27. `throw new BindingException("Unknown execution method for: " + command.getName());`
28. `}`
29. `if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {`
30. `throw new BindingException("Mapper method '" + command.getName()`
31. `+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");`
32. `}`
33. `return result;`
34. `}`

其实这里就回到了第一种模式，该模式是直接指定了statement的Id（这里是command.getName()），而通过mapper的接口方式，则多了这么步骤，最后通过MapperMethod，给sqlSession传入statement的id。

sqlSession其实自己也不执行sql，它只是mybatis对外公布的一个api入口，具体它委托给了executor去执行sql。

3.8 什么时候去getMapper

*  手工get，比如：
    
         
    
    1.  `public void createStudent(Student student) {`
    2.  `SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();`
    3.  `try {`
    4.  `StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);`
    5.  `studentMapper.insertStudent(student);`
    6.  `sqlSession.commit();`
    7.  `} finally {`
    8.  `sqlSession.close();`
    9.  `}`
    10. `}`
 *  集成spring的话，在spring容器给指定的bean注入mapper的时候get出来(`见MapperFactoryBean的getObject方法`

##  四、mybatis-spring帮忙做了什么 ##

4.1 通过MapperScannerConfigurer将mapper适配成spring bean

\[html\] [view plain][] [copy][view plain]

1.    
2.  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
3.      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>  
4.      <property name="basePackage" value="com.xixicat.dao"/>  
5.  </bean>

这里使用 MapperFactoryBean将Mapper接口配置成 Spring bean 实体同时注入sqlSessionFactory。

4.2 MapperScannerConfigurer给每个mapper生成对应的MapperFactoryBean

1.  `public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {`
2.  `if (this.processPropertyPlaceHolders) {`
3.  `processPropertyPlaceHolders();`
4.  `}`
5.   
6.  `ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);`
7.  `scanner.setAddToConfig(this.addToConfig);`
8.  `scanner.setAnnotationClass(this.annotationClass);`
9.  `scanner.setMarkerInterface(this.markerInterface);`
10. `scanner.setSqlSessionFactory(this.sqlSessionFactory);`
11. `scanner.setSqlSessionTemplate(this.sqlSessionTemplate);`
12. `scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);`
13. `scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);`
14. `scanner.setResourceLoader(this.applicationContext);`
15. `scanner.setBeanNameGenerator(this.nameGenerator);`
16. `scanner.registerFilters();`
17. `scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));`
18. `}`

4.3 委托给ClassPathMapperScanner去scan

1.  `public Set<BeanDefinitionHolder> doScan(String... basePackages) {`
2.  `Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);`
3.   
4.  `if (beanDefinitions.isEmpty()) {`
5.  `logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");`
6.  `} else {`
7.  `for (BeanDefinitionHolder holder : beanDefinitions) {`
8.  `GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();`
9.   
10. `if (logger.isDebugEnabled()) {`
11. `logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()`
12. `+ "' and '" + definition.getBeanClassName() + "' mapperInterface");`
13. `}`
14.  
15. `// the mapper interface is the original class of the bean`
16. `// but, the actual class of the bean is MapperFactoryBean`
17. `definition.getPropertyValues().add("mapperInterface", definition.getBeanClassName());`
18. `definition.setBeanClass(MapperFactoryBean.class);`
19.  
20. `definition.getPropertyValues().add("addToConfig", this.addToConfig);`
21.  
22. `boolean explicitFactoryUsed = false;`
23. `if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {`
24. `definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));`
25. `explicitFactoryUsed = true;`
26. `} else if (this.sqlSessionFactory != null) {`
27. `definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);`
28. `explicitFactoryUsed = true;`
29. `}`
30.  
31. `if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {`
32. `if (explicitFactoryUsed) {`
33. `logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");`
34. `}`
35. `definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));`
36. `explicitFactoryUsed = true;`
37. `} else if (this.sqlSessionTemplate != null) {`
38. `if (explicitFactoryUsed) {`
39. `logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");`
40. `}`
41. `definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);`
42. `explicitFactoryUsed = true;`
43. `}`
44.  
45. `if (!explicitFactoryUsed) {`
46. `if (logger.isDebugEnabled()) {`
47. `logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");`
48. `}`
49. `definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);`
50. `}`
51. `}`
52. `}`
53.  
54. `return beanDefinitions;`
55. `}`

这里出现了MapperFactoryBean的身影，然后判断配置文件是指定注入sqlSessionFactory，还是 sqlTemplate(二者不能同时指定，这里是指定了sqlSessionFactory)。这里通过 sqlSessionFactoryBeanName暂时先注入引用，因为此时还在给spring托管的bean进行create，不确定 sqlSessionFactory是否已经被创建。

### 4.4 关于MapperFactoryBean ###

1.  `public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {`
2.   
3.  `private Class<T> mapperInterface;`
4.   
5.  `private boolean addToConfig = true;`
6.   
7.  `/**`
8.  `* Sets the mapper interface of the MyBatis mapper`
9.  `*`
10. `* @param mapperInterface class of the interface`
11. `*/`
12. `public void setMapperInterface(Class<T> mapperInterface) {`
13. `this.mapperInterface = mapperInterface;`
14. `}`
15.  
16. `/**`
17. `* If addToConfig is false the mapper will not be added to MyBatis. This means`
18. `* it must have been included in mybatis-config.xml.`
19. `* <p>`
20. `* If it is true, the mapper will be added to MyBatis in the case it is not already`
21. `* registered.`
22. `* <p>`
23. `* By default addToCofig is true.`
24. `*`
25. `* @param addToConfig`
26. `*/`
27. `public void setAddToConfig(boolean addToConfig) {`
28. `this.addToConfig = addToConfig;`
29. `}`
30.  
31. `/**`
32. `* {@inheritDoc}`
33. `*/`
34. `@Override`
35. `protected void checkDaoConfig() {`
36. `super.checkDaoConfig();`
37.  
38. `notNull(this.mapperInterface, "Property 'mapperInterface' is required");`
39.  
40. `Configuration configuration = getSqlSession().getConfiguration();`
41. `if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {`
42. `try {`
43. `configuration.addMapper(this.mapperInterface);`
44. `} catch (Throwable t) {`
45. `logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", t);`
46. `throw new IllegalArgumentException(t);`
47. `} finally {`
48. `ErrorContext.instance().reset();`
49. `}`
50. `}`
51. `}`
52.  
53. `/**`
54. `* {@inheritDoc}`
55. `*/`
56. `public T getObject() throws Exception {`
57. `return getSqlSession().getMapper(this.mapperInterface);`
58. `}`
59.  
60. `/**`
61. `* {@inheritDoc}`
62. `*/`
63. `public Class<T> getObjectType() {`
64. `return this.mapperInterface;`
65. `}`
66.  
67. `/**`
68. `* {@inheritDoc}`
69. `*/`
70. `public boolean isSingleton() {`
71. `return true;`
72. `}`
73.  
74. `}`

注意这里继承了SqlSessionDaoSupport，在spring把sqlSessionFactory创建出来后，会去把之前注入的引用改为真的实例，调SqlSessionDaoSupport的setSqlSessionFactory方法。

1.  `public abstract class SqlSessionDaoSupport extends DaoSupport {`
2.   
3.  `private SqlSession sqlSession;`
4.   
5.  `private boolean externalSqlSession;`
6.   
7.  `public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {`
8.  `if (!this.externalSqlSession) {`
9.  `this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);`
10. `}`
11. `}`
12.  
13. `public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {`
14. `this.sqlSession = sqlSessionTemplate;`
15. `this.externalSqlSession = true;`
16. `}`
17.  
18. `/**`
19. `* Users should use this method to get a SqlSession to call its statement methods`
20. `* This is SqlSession is managed by spring. Users should not commit/rollback/close it`
21. `* because it will be automatically done.`
22. `*`
23. `* @return Spring managed thread safe SqlSession`
24. `*/`
25. `public SqlSession getSqlSession() {`
26. `return this.sqlSession;`
27. `}`
28.  
29. `/**`
30. `* {@inheritDoc}`
31. `*/`
32. `protected void checkDaoConfig() {`
33. `notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");`
34. `}`
35.  
36. `}`

这里值得注意的是setSqlSessionFactory方法new了一个SqlSessionTemplate。

###  4.5 SqlSessionTemplate ###

它的一个重要的构造器为

1.  `public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,`
2.  `PersistenceExceptionTranslator exceptionTranslator) {`
3.   
4.  `notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");`
5.  `notNull(executorType, "Property 'executorType' is required");`
6.   
7.  `this.sqlSessionFactory = sqlSessionFactory;`
8.  `this.executorType = executorType;`
9.  `this.exceptionTranslator = exceptionTranslator;`
10. `this.sqlSessionProxy = (SqlSession) newProxyInstance(`
11. `SqlSessionFactory.class.getClassLoader(),`
12. `new Class[] { SqlSession.class },`
13. `new SqlSessionInterceptor());`
14. `}`

mybatis-srping比传统mybatis方法多做的事情就在于此，生成了一个sqlSessionProxy。这里static import了java.lang.reflect.Proxy.newProxyInstance;也就是使用使用jdk代理进行了 SqlSessionInterceptor拦截。

###  4.6 SqlSessionInterceptor ###

1.  `private class SqlSessionInterceptor implements InvocationHandler {`
2.  `public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {`
3.  `SqlSession sqlSession = getSqlSession(`
4.  `SqlSessionTemplate.this.sqlSessionFactory,`
5.  `SqlSessionTemplate.this.executorType,`
6.  `SqlSessionTemplate.this.exceptionTranslator);`
7.  `try {`
8.  `Object result = method.invoke(sqlSession, args);`
9.  `if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {`
10. `// force commit even on non-dirty sessions because some databases require`
11. `// a commit/rollback before calling close()`
12. `sqlSession.commit(true);`
13. `}`
14. `return result;`
15. `} catch (Throwable t) {`
16. `Throwable unwrapped = unwrapThrowable(t);`
17. `if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {`
18. `// release the connection to avoid a deadlock if the translator is no loaded. See issue #22`
19. `closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);`
20. `sqlSession = null;`
21. `Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);`
22. `if (translated != null) {`
23. `unwrapped = translated;`
24. `}`
25. `}`
26. `throw unwrapped;`
27. `} finally {`
28. `if (sqlSession != null) {`
29. `closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);`
30. `}`
31. `}`
32. `}`
33. `}`

到了这里就明白了mybatis-spring帮忙做了session的open和close。

##  4.7关于一级缓存 ##

最后留个问题给大家，如果是使用mybatis-spring，那么mybatis的一级缓存默认开启的话，那么有达到一级缓存的设计初衷的效果么？

[view plain]: https://blog.csdn.net/zmx729618/article/details/78646328#