Mybatis(二)-----------------Sqlsession

最新推荐文章于 2023-12-09 08:21:25 发布
最新推荐文章于 2023-12-09 08:21:25 发布
阅读量193 收藏
点赞数
分类专栏： Mybatis
本文深入探讨MyBatis框架的执行流程，包括SqlSession的创建、Executor的生成及功能、Mapper的创建与工作原理、StatementHandler的作用以及参数设置与结果处理的过程。
摘要由CSDN通过智能技术生成

http://blog.csdn.net/hupanfeng/article/details/9238127


创建

正如其名，Sqlsession对应着一次数据库会话。由于数据库回话不是永久的，因此Sqlsession的生命周期也不应该是永久的，相反，在你每次访问数据库时都需要创建它（当然并不是说在Sqlsession里只能执行一次sql，你可以执行多次，当一旦关闭了Sqlsession就需要重新创建它）。创建Sqlsession的地方只有一个，那就是SqlsessionFactory的openSession方法：

[java]  view plain copy
  1. public SqlSessionopenSession() {  
  2.     returnopenSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);  
  3. }  

我们可以看到实际创建SqlSession的地方是openSessionFromDataSource，如下：

[java]  view plain copy
  1. private SqlSessionopenSessionFromDataSource(ExecutorType execType, TransactionIsolationLevellevel, boolean autoCommit) {  
  2.   
  3.     Connectionconnection = null;  
  4.   
  5.     try {  
  6.   
  7.         finalEnvironment environment = configuration.getEnvironment();  
  8.   
  9.         final DataSourcedataSource = getDataSourceFromEnvironment(environment);  
  10.   
  11.        TransactionFactory transactionFactory =getTransactionFactoryFromEnvironment(environment);  
  12.   
  13.        connection = dataSource.getConnection();  
  14.   
  15.         if (level != null) {  
  16.   
  17.            connection.setTransactionIsolation(level.getLevel());  
  18.   
  19.         }  
  20.   
  21.        connection = wrapConnection(connection);  
  22.   
  23.        Transaction tx = transactionFactory.newTransaction(connection,autoCommit);  
  24.   
  25.         Executorexecutor = configuration.newExecutor(tx, execType);  
  26.   
  27.         returnnewDefaultSqlSession(configuration, executor, autoCommit);  
  28.   
  29.     } catch (Exceptione) {  
  30.   
  31.        closeConnection(connection);  
  32.   
  33.         throwExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);  
  34.   
  35.     } finally {  
  36.   
  37.        ErrorContext.instance().reset();  
  38.   
  39.     }  
  40.   
  41. }  

可以看出，创建sqlsession经过了以下几个主要步骤：

1)       从配置中获取Environment；

2)       从Environment中取得DataSource；

3)       从Environment中取得TransactionFactory；

4)       从DataSource里获取数据库连接对象Connection；

5)       在取得的数据库连接上创建事务对象Transaction；

6)       创建Executor对象（该对象非常重要，事实上sqlsession的所有操作都是通过它完成的）；

7)       创建sqlsession对象。

Executor的创建

Executor与Sqlsession的关系就像市长与书记，Sqlsession只是个门面，真正干事的是Executor，Sqlsession对数据库的操作都是通过Executor来完成的。与Sqlsession一样，Executor也是动态创建的：

[java]  view plain copy
  1.     public ExecutornewExecutor(Transaction transaction, ExecutorType executorType) {  
  2.   
  3.        executorType = executorType == null ? defaultExecutorType :executorType;  
  4.   
  5.        executorType = executorType == null ?ExecutorType.SIMPLE : executorType;  
  6.   
  7.         Executor executor;  
  8.   
  9.         if(ExecutorType.BATCH == executorType) {  
  10.            executor = new BatchExecutor(this,transaction);  
  11.         } elseif(ExecutorType.REUSE == executorType) {  
  12.            executor = new ReuseExecutor(this,transaction);  
  13.         } else {  
  14.             executor = newSimpleExecutor(this, transaction);  
  15.         }  
  16.   
  17.         if (cacheEnabled) {  
  18.            executor = new CachingExecutor(executor);  
  19.         }  
  20.         executor =(Executor) interceptorChain.pluginAll(executor);  
  21.         return executor;  
  22. }  


可以看出，如果不开启cache的话，创建的Executor只是3中基础类型之一，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。开启cache的话（默认是开启的并且没有任何理由去关闭它），就会创建CachingExecutor，它以前面创建的Executor作为唯一参数。CachingExecutor在查询数据库前先查找缓存，若没找到的话调用delegate（就是构造时传入的Executor对象）从数据库查询，并将查询结果存入缓存中。

Executor对象是可以被插件拦截的，如果定义了针对Executor类型的插件，最终生成的Executor对象是被各个插件插入后的代理对象（关于插件会有后续章节专门介绍，敬请期待）。

Mapper

Mybatis官方手册建议通过mapper对象访问mybatis，因为使用mapper看起来更优雅，就像下面这样：

[java]  view plain copy
  1. session = sqlSessionFactory.openSession();  
  2. UserDao userDao= session.getMapper(UserDao.class);  
  3. UserDto user =new UserDto();  
  4. user.setUsername("iMbatis");  
  5. user.setPassword("iMbatis");  
  6. userDao.insertUser(user);  

那么这个mapper到底是什么呢，它是如何创建的呢，它又是怎么与sqlsession等关联起来的呢？下面为你一一解答。

创建

表面上看mapper是在sqlsession里创建的，但实际创建它的地方是MapperRegistry：

[java]  view plain copy
  1. public <T>T getMapper(Class<T> type, SqlSession sqlSession) {  
  2.     if (!knownMappers.contains(type))  
  3.         thrownewBindingException("Type " + type + " isnot known to the MapperRegistry.");  
  4.     try {  
  5.         returnMapperProxy.newMapperProxy(type, sqlSession);  
  6.     } catch (Exceptione) {  
  7.         thrownewBindingException("Error getting mapper instance. Cause: " + e, e);  
  8.     }  
  9. }  

可以看到，mapper是一个代理对象，它实现的接口就是传入的type，这就是为什么mapper对象可以通过接口直接访问。同时还可以看到，创建mapper代理对象时传入了sqlsession对象，这样就把sqlsession也关联起来了。我们进一步看看MapperProxy.newMapperProxy(type,sqlSession);背后发生了什么事情：

[java]  view plain copy
  1. publicstatic <T>T newMapperProxy(Class<T> mapperInterface, SqlSession sqlSession) {  
  2.     ClassLoaderclassLoader = mapperInterface.getClassLoader();  
  3.     Class<?>[] interfaces = new Class[]{mapperInterface};  
  4.     MapperProxyproxy = new MapperProxy(sqlSession);  
  5.     return (T) Proxy.newProxyInstance(classLoader,interfaces, proxy);  
  6. }  

看起来没什么特别的，和其他代理类的创建一样，我们重点关注一下MapperProxy的invoke方法

MapperProxy的invoke

我们知道对被代理对象的方法的访问都会落实到代理者的invoke上来，MapperProxy的invoke如下：

[java]  view plain copy
  1. public Objectinvoke(Object proxy, Method method, Object[] args) throws Throwable{  
  2.     if (method.getDeclaringClass()== Object.class) {  
  3.         return method.invoke(this, args);  
  4.     }  
  5.   
  6.     finalClass<?> declaringInterface = findDeclaringInterface(proxy, method);  
  7.     finalMapperMethod mapperMethod = newMapperMethod(declaringInterface, method, sqlSession);  
  8.     final Objectresult = mapperMethod.execute(args);  
  9.   
  10.     if (result ==null && method.getReturnType().isPrimitive()&& !method.getReturnType().equals(Void.TYPE)) {  
  11.         thrownewBindingException("Mapper method '" + method.getName() + "'(" + method.getDeclaringClass()  
  12.                 + ") attempted toreturn null from a method with a primitive return type ("  
  13.                + method.getReturnType() + ").");  
  14.     }  
  15.     return result;  
  16. }  


可以看到invoke把执行权转交给了MapperMethod，我们来看看MapperMethod里又是怎么运作的：

[java]  view plain copy
  1.     public Objectexecute(Object[] args) {  
  2.         Objectresult = null;  
  3.         if(SqlCommandType.INSERT == type) {  
  4.             Objectparam = getParam(args);  
  5.             result= sqlSession.insert(commandName, param);  
  6.         } elseif(SqlCommandType.UPDATE == type) {  
  7.             Object param = getParam(args);  
  8.             result= sqlSession.update(commandName, param);  
  9.         } elseif(SqlCommandType.DELETE == type) {  
  10.             Objectparam = getParam(args);  
  11.             result= sqlSession.delete(commandName, param);  
  12.         } elseif(SqlCommandType.SELECT == type) {  
  13.             if (returnsVoid &&resultHandlerIndex != null) {  
  14.                executeWithResultHandler(args);  
  15.             } elseif (returnsList) {  
  16.                result = executeForList(args);  
  17.             } elseif (returnsMap) {  
  18.                result = executeForMap(args);  
  19.             } else {  
  20.                Object param = getParam(args);  
  21.                result = sqlSession.selectOne(commandName, param);  
  22.             }  
  23.         } else {  
  24.             thrownewBindingException("Unknown execution method for: " + commandName);  
  25.         }  
  26.         return result;  
  27.   
  28. }  


可以看到，MapperMethod就像是一个分发者，他根据参数和返回值类型选择不同的sqlsession方法来执行。这样mapper对象与sqlsession就真正的关联起来了。

Executor

前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问最终都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经介绍了，下面介绍下他们的功能：

CacheExecutor

CacheExecutor有一个重要属性delegate，它保存的是某类普通的Executor，值在构照时传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先尝试从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。代码如下：

[java]  view plain copy
  1. public Listquery(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {  
  2.     if (ms != null) {  
  3.         Cachecache = ms.getCache();  
  4.         if (cache != null) {  
  5.            flushCacheIfRequired(ms);  
  6.            cache.getReadWriteLock().readLock().lock();  
  7.            try {  
  8.                if (ms.isUseCache() && resultHandler ==null) {  
  9.                    CacheKey key = createCacheKey(ms, parameterObject, rowBounds);  
  10.                    final List cachedList = (List)cache.getObject(key);  
  11.                    if (cachedList != null) {  
  12.                         returncachedList;  
  13.                    } else {  
  14.                        List list = delegate.query(ms,parameterObject, rowBounds, resultHandler);  
  15.                        tcm.putObject(cache,key, list);  
  16.                        return list;  
  17.                    }  
  18.                } else {  
  19.                    returndelegate.query(ms,parameterObject, rowBounds, resultHandler);  
  20.                }  
  21.             } finally {  
  22.                cache.getReadWriteLock().readLock().unlock();  
  23.             }  
  24.         }  
  25.     }  
  26.     returndelegate.query(ms,parameterObject, rowBounds, resultHandler);  
  27. }  

普通Executor

普通Executor有3类，他们都继承于BaseExecutor，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。下面以SimpleExecutor为例：

[java]  view plain copy
  1. public ListdoQuery(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {  
  2.     Statementstmt = null;  
  3.     try {  
  4.        Configuration configuration = ms.getConfiguration();  
  5.        StatementHandler handler = configuration.newStatementHandler(this, ms,parameter, rowBounds,resultHandler);  
  6.        stmt =prepareStatement(handler);  
  7.        returnhandler.query(stmt, resultHandler);  
  8.     } finally {  
  9.        closeStatement(stmt);  
  10.     }  
  11. }  

可以看出，Executor本质上也是个甩手掌柜，具体的事情原来是StatementHandler来完成的。

StatementHandler

当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的。

创建

[java]  view plain copy
  1. publicStatementHandler newStatementHandler(Executor executor, MappedStatementmappedStatement,  
  2.         ObjectparameterObject, RowBounds rowBounds, ResultHandler resultHandler) {  
  3.    StatementHandler statementHandler = newRoutingStatementHandler(executor, mappedStatement,parameterObject,rowBounds, resultHandler);  
  4.    statementHandler= (StatementHandler) interceptorChain.pluginAll(statementHandler);  
  5.    returnstatementHandler;  
  6. }  

可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper配置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要注意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。由于mybatis没有实现数据库的物理分页，众多物理分页的实现都是在这个地方使用拦截器实现的，本文作者也实现了一个分页拦截器，在后续的章节会分享给大家，敬请期待。

初始化

StatementHandler创建后需要执行一些初始操作，比如statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：

[java]  view plain copy
  1. private StatementprepareStatement(StatementHandler handler) throwsSQLException {  
  2.     Statementstmt;  
  3.     Connectionconnection = transaction.getConnection();  
  4.     stmt =handler.prepare(connection);  
  5.     handler.parameterize(stmt);  
  6.     return stmt;  
  7. }  

statement的开启和参数设置没什么特别的地方，handler.parameterize倒是可以看看是怎么回事。handler.parameterize通过调用ParameterHandler的setParameters完成参数的设置，ParameterHandler随着StatementHandler的创建而创建，默认的实现是DefaultParameterHandler：

[java]  view plain copy
  1. publicParameterHandler newParameterHandler(MappedStatement mappedStatement, ObjectparameterObject, BoundSql boundSql) {  
  2.    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement,parameterObject,boundSql);  
  3.    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);  
  4.    returnparameterHandler;  
  5. }  

同Executor和StatementHandler一样，ParameterHandler也是可以被拦截的。

参数设置

DefaultParameterHandler里设置参数的代码如下：

[java]  view plain copy
  1. publicvoidsetParameters(PreparedStatement ps) throwsSQLException {  
  2.    ErrorContext.instance().activity("settingparameters").object(mappedStatement.getParameterMap().getId());  
  3.    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();  
  4.     if(parameterMappings != null) {  
  5.        MetaObject metaObject = parameterObject == null ? null :configuration.newMetaObject(parameterObject);  
  6.         for (int i = 0; i< parameterMappings.size(); i++) {  
  7.            ParameterMapping parameterMapping = parameterMappings.get(i);  
  8.             if(parameterMapping.getMode() != ParameterMode.OUT) {  
  9.                Object value;  
  10.                String propertyName = parameterMapping.getProperty();  
  11.                PropertyTokenizer prop = newPropertyTokenizer(propertyName);  
  12.                if (parameterObject == null) {  
  13.                    value = null;  
  14.                } elseif (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){  
  15.                    value = parameterObject;  
  16.                } elseif (boundSql.hasAdditionalParameter(propertyName)){  
  17.                    value = boundSql.getAdditionalParameter(propertyName);  
  18.                } elseif(propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)  
  19.                         && boundSql.hasAdditionalParameter(prop.getName())){  
  20.                    value = boundSql.getAdditionalParameter(prop.getName());  
  21.                    if (value != null) {  
  22.                         value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));  
  23.                    }  
  24.                } else {  
  25.                    value = metaObject == null ? null :metaObject.getValue(propertyName);  
  26.                }  
  27.                TypeHandler typeHandler = parameterMapping.getTypeHandler();  
  28.                if (typeHandler == null) {  
  29.                    thrownew ExecutorException("Therewas no TypeHandler found for parameter " + propertyName  + " of statement " + mappedStatement.getId());  
  30.                 }  
  31.                typeHandler.setParameter(ps, i + 1, value,parameterMapping.getJdbcType());  
  32.             }  
  33.   
  34.         }  
  35.   
  36.     }  
  37. }  

这里面最重要的一句其实就是最后一句代码，它的作用是用合适的TypeHandler完成参数的设置。那么什么是合适的TypeHandler呢，它又是如何决断出来的呢？BaseStatementHandler的构造方法里有这么一句：

this.boundSql= mappedStatement.getBoundSql(parameterObject);

它触发了sql 的解析，在解析sql的过程中，TypeHandler也被决断出来了，决断的原则就是根据参数的类型和参数对应的JDBC类型决定使用哪个TypeHandler。比如：参数类型是String的话就用StringTypeHandler，参数类型是整数的话就用IntegerTypeHandler等。

参数设置完毕后，执行数据库操作（update或query）。如果是query最后还有个查询结果的处理过程。

结果处理

结果处理使用ResultSetHandler来完成，默认的ResultSetHandler是FastResultSetHandler，它在创建StatementHandler时一起创建，代码如下：

[java]  view plain copy
  1. publicResultSetHandler newResultSetHandler(Executor executor, MappedStatementmappedStatement,  
  2. RowBoundsrowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSqlboundSql) {  
  3.    ResultSetHandler resultSetHandler =mappedStatement.hasNestedResultMaps() ? newNestedResultSetHandler(executor, mappedStatement, parameterHandler,resultHandler, boundSql, rowBounds): new FastResultSetHandler(executor,mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);  
  4.    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);  
  5.    returnresultSetHandler;  
  6. }  

可以看出ResultSetHandler也是可以被拦截的，可以编写自己的拦截器改变ResultSetHandler的默认行为。

[java]  view plain copy
  1. ResultSetHandler内部一条记录一条记录的处理，在处理每条记录的每一列时会调用TypeHandler转换结果，如下：  
  2.   
  3.     protectedbooleanapplyAutomaticMappings(ResultSet rs, List<String> unmappedColumnNames,MetaObject metaObject) throws SQLException {  
  4.         booleanfoundValues = false;  
  5.         for (StringcolumnName : unmappedColumnNames) {  
  6.             final Stringproperty = metaObject.findProperty(columnName);  
  7.             if (property!= null) {  
  8.                 final ClasspropertyType =metaObject.getSetterType(property);  
  9.                 if (typeHandlerRegistry.hasTypeHandler(propertyType)) {  
  10.                    final TypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(propertyType);  
  11.                    final Object value = typeHandler.getResult(rs,columnName);  
  12.                    if (value != null) {  
  13.                        metaObject.setValue(property, value);  
  14.                        foundValues = true;  
  15.                    }  
  16.                 }  
  17.             }  
  18.         }  
  19.         returnfoundValues;  
  20.    }  

从代码里可以看到，决断TypeHandler使用的是结果参数的属性类型。因此我们在定义作为结果的对象的属性时一定要考虑与数据库字段类型的兼容性。


hunci
关注
专栏目录
mybatis-spring-1.3.1.jar下载
05-24
4. **简化DAO开发**：使用MyBatis-Spring，开发者可以专注于编写Mapper接口，而无需关心SqlSession的创建、关闭和事务提交等细节。 5. **批处理**：支持使用Spring的Batch模式进行批处理操作，提高数据插入、更新的...
Mybatis-Spring-1.2.2中文文档.zip
09-09
Mybatis-Spring提供了一个桥梁，使得Mybatis的SqlSession和Spring的数据访问抽象能够无缝协作。通过这个集成，用户可以在Spring的事务管理、依赖注入和AOP特性中充分利用Mybatis的灵活性。 2. **安装与配置** ...
MyBatis直接执行SQL的工具SqlMapper
08-26
今天小编就为大家分享一篇关于MyBatis直接执行SQL的工具SqlMapper，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
深入浅出MyBatis-Sqlsession
热门推荐
追求极致的人
07-03 12万+
前面的章节主要讲mybatis如何解析配置文件，这些都是一次性的过程。从本章开始讲解动态的过程，它们跟应用程序对mybatis的调用密切相关。本章先从sqlsession开始。 创建 正如其名，Sqlsession对应着一次数据库会话。由于数据库回话不是永久的，因此Sqlsession的生命周期也不应该是永久的，相反，在你每次访问数据库时都需要创建它（当然并不是说在Sqlsession里只能执
MyBatis源码解析——SqlSession执行Mapper过程
qq_16500963的博客
10-19 763
Mapper由两部分组成，分别为Mapper接口和通过注解或者XML文件配置的SQL语句。为了让读者有一个清晰的思路，笔者将SqlSession执行Mapper过程拆解为4部分介绍：首先介绍Mapper接口的注册过程，然后介绍MappedStatement对象的注册过程，接着介绍Mapper方法的调用过程，最后介绍SqlSession执行Mapper的过程。
Mybatis-SqlSession执行Mapper过程
星光之子的博客
09-09 503
SqlSession执行Mapper过程概述Mapper接口的注册过程MapperProxyMapperProxyFactoryMapperRegistryMappedStatement注册过程Mapper方法调用过程SqlSession执行Mapper过程 概述 将SqlSession执行Mapper过程拆解为4部分 Mapper接口的注册过程 MappedStatement对象的注册过程 Mapper方法的调用过程 SqlSession执行Mapper的过程 Mapper接口的注册过程 Mapper
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.zip）
02-07
- MyBatis 提供了本地缓存（Local Cache）和二级缓存（Second Level Cache），可以有效提高数据读取效率。缓存策略可配置，支持读写分离和清空操作。 9. **插件支持** - MyBatis 允许开发者自定义插件，拦截特定...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
9. **缓存机制**：MyBatis 提供了一级缓存和二级缓存，提高数据访问速度。查看源码，可以学习到 MyBatis 是如何实现缓存的存储、更新和清除策略的。 通过对 MyBatis-3.5.9 源码的学习，开发者可以深入理解其工作...
MyBatis-Simplified-Chinese.rar_ mybatis-3_Mybatis-spring_mybatis
09-20
mybatis-spring 是一个 MyBatis 与 Spring 框架的整合库，它提供了与 Spring 的无缝集成，如事务管理、自动扫描 Mapper 类、SqlSession 的自动关闭等，简化了在 Spring 中使用 MyBatis 的过程。 七、最佳实践 1. ...
mybatis/ibatis自动生成SQLMapper脚本
05-21
mybatis/ibatis自动生成sqlmapper的脚本
mybatis0100- Mapper接口到SqlSession的跨越
登峰小蚁
05-26 2535
文章目录1. mapper接口带来的便利2. sqlSeesion.getMapper(Class c)返回的对象是什么3. MapperProxy的Invoke方法4. mapperMethod.execute(sqlSession, args)方法 1. mapper接口带来的便利 如果是ibatis的时代，直接通过sqlSession对象调用方法，然后执行器等后续执行； SysRole s...
MyBatis内容分享（三）：Mapper映射文件和SqlSession
最新发布
之乎者也·的博客
12-09 882
它通过调用Configuration对象的addMapper方法完成，而Configuration对象的addMapper方法是通过MapperRegistry的addMapper方法完成的，它只是简单的将namespace属性对应的接口类型存入本地缓存中。解析配置文件是在MapperAnnotationBuilder类的parse方法里完成的，该方法先解析配置文件，然后再解析接口里的注解配置，且注解里的配置会覆盖配置文件里的配置，也就是说注解的优先级高于配置文件，这点需要注意。
MyBatis核心组件之SQL Mapper
qq_36525300的博客
05-14 630
简述 映射器（SQL Mapper）是MyBatis中最重要、最复杂的组件，它是由一个接口和对应的XML文件组成，它可以配置以下内容： 描述映射规则 提供SQL语句，并可以配置SQL参数类型、返回类型、缓存刷新等信息 配置缓存 提供动态SQL 映射器的主要作用就是将SQL查询到的结果映射成一个POJO（Java原生对象），或者将POJO的数据插入到数据库中，并定义一些关于缓存等的重要内容。 下...
【笔记】mybatis的sqlSession和Mapper详解
qq_41358574的博客
08-20 2839
1.SqlSession介绍和使用 SqlSession是一个接口类，它类似于你们公司前台的美女客服，它扮演着门面的作用，而真正干活的是Executor接口，你可以认为它是公司的工程师。假设我是客户找你们公司干活，我只需要告诉前台的美女客服（SqlSession）我要什么信息（参数），要做什么东西，过段时间，她会将结果给我。在这个过程中，作为用户的我所关心的是： 1）要给美女客服（SqlSession）什么信息（功能和参数）。 2）美女客服会返回什么结果（Result）。 而我不关心工程师（Executor
Mybatis笔记6 SqlSessionFactory SqlSession Mapper源码分析
zjj_daniu的博客
04-24 1万+
Mybatis流程步骤 a.获取SqlSessionFactory对象 b.获取SqlSession对象 c.获取Mapper对象（代理接口中的方法、mapper.xml中的标签） d.执行标签中定义的SQL语句 SqlSessionFactory String resource = "conf.xml"; InputStream inputStream = Resources.getRe...
mybatis sqlMapperConfig
ljj123_的博客
04-02 277
&lt;?xml version="1.0" encoding="utf-8" ?&gt; &lt;!DOCTYPE configuration PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN" "http://ibatis.apache.org/dtd/ibatis-...
【Mybatis源码分析】05-SqlSession执行过程之获取Mapper代理对象
通往神秘的道路的专栏
04-18 5767
当我们通过DefaultSqlSession的Mapper方式操作数据库时使用如下api: <T> T getMapper(Class<T> type); 此方法返回一个实现了type接口的实现类的实力，我们分析一下此实力的创建过程。 public <T> T getMapper(Class<T> type) { return conf...
SqlSession和Mapper使用
一只小星星
09-24 3984
这两个比较简单，就放在这里一起学习理解了。 一、SqlSession学习 在MyBatis中，SqlSession是其核心接口。在MyBatis中有两个实现类，DefaultSqlSession和SqlSessionManager。DefaultSqlSession是单线程使用的，而SqlSessionManager在多线程环境下使用。SqlSession的作用类似于一个JDBC中的Connect...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值