威尼斯888_www.wns888.com_威尼斯wns888官网
做最好的网站
威尼斯888 > 计算机网络 / 编程 > 目录如下

原标题:目录如下

浏览次数:83 时间:2019-10-08

本文将按mybatis中主要数据库查询操作的流程对其源码进行简单分析。目录如下:

1、mybatis的主要工作流程

2、mybatis进行数据查询的小实例

3、源码分析

4、总结

1、mybatis的主要工作流程

mybatis的工作流程:

加载配置-->SQL解析-->SQL执行-->结果映射

  • 加载配置:配置来源于两个地方,一处是配置文件,一处是Java代码的注解,将SQL的配置信息加载成为一个个MappedStatement对象(包括了传入参数映射配置、执行的SQL语句、结果映射配置),存储在内存中。

  • SQL解析:当API接口层接收到调用请求时,会接收到传入SQL的ID和传入对象(可以是Map、JavaBean或者基本数据类型),Mybatis会根据SQL的ID找到对应的MappedStatement,然后根据传入参数对象对MappedStatement进行解析,解析后可以得到最终要执行的SQL语句和参数。

  • SQL执行:将最终得到的SQL和参数拿到数据库进行执行,得到操作数据库的结果。

  • 结果映射:将操作数据库的结果按照映射的配置进行转换,可以转换成HashMap、JavaBean或者基本数据类型,并将最终结果返回

后面将按这个步骤来注解分析源码.

2、mybatis进行数据查询的小实例

下面代码主要展示了mybatis中进行数据库操作的几个核心要素。

public void testFindUserById(int userId) throws IOException { // mybatis配置文件 String resource = "mybatis-config.xml"; // mybatis通过SqlSessionFactory获取SessionFactory // 然后获取SqlSession,通过sqlSession来获取映射执行SQL的。 SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader);; SqlSession sqlSession = null; if (sf != null) { sqlSession = getSqlSessionFactory().openSession(); SysUserDao userDao = sqlSession.getMapper(SysUserDao.class); SysUser user = userDao.findUserById; } }

通过配置文件,生成了SqlSessionFactory,从而创建 SqlSession,在mybatis中,所有的sql执行,都是通过SqlSession来实现的。获取到sqlSession对象后,即可通过对应的getMapper方法来获取接口的动态实现类了,从而完成接口方法的执行。

3、源码分析

本节开始,将按照上面的代码执行过程,对mybatis的源码进行分析。分析涉及到以下几个大的过程:

  • 1、对配置文件的解析。需要搞明白配置文件中的数据解析存储到哪儿了
  • 2、接口类实现的获取。由于mybatis中是通过接口定义方法+xml配置方式来完成对数据库的操作,核心是通过动态代理的方式来构造接口实现类的,对这个获取过程和方法的执行需要分析。
  • 3、接口类中的方法的执行。同上

配置文件的解析过程,实际上是通过获取SqlSessionFactory来实现的,这个过程看下图:

图片 1获取SqlSessionFactory流程.png

在前面的例子中有一行代码:

SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader);;

调用SqlSessionFactoryBuilder().build方法来创建sqlSession工厂,builder方法的入口参数是Reader,通过调用Resources.getResourceAsReader来实现的。

mybatis中的Resources类主要是通过类加载器来简化对各种资源的获取操作

SqlSessionFactoryBuilder类主要提供了基于Reader和InputStream来解析xml文件的方法,主要依赖于XMLConfigBuilder来实现,通过XMLConfigBuilder的parse方法解析xml配置文件得到Configuration对象,通过configuration对象构造默认的SqlFactory实现类DefaultSqlSessionFactory实例

SqlSessionFactoryBuilder的build方法最终调用到以下方法:

/** * 解析xml文件两个步骤: * 1、读取xml信息; * 2、根据xml信息构建SqlSession工厂 */ public SqlSessionFactory build(Reader reader, String environment, Properties properties) { try { logger.info("build init."); // 1. 通过XMLConfigBuilder来解析xml配置文件 XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties); // 2. 调用xml解析器进行解析得到Configuration对象,xml文件中的配置信息都存储到configuration对象中了 // 3. 创建defaultSessionFactory对象 return build(parser.parse; } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance; try { reader.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } }

创建SelSessionFactory对象

// 创建SelSessionFactory对象 public SqlSessionFactory build(Configuration config) { return new DefaultSqlSessionFactory; }

实际上,创建SessionFactory对象的过程分为以下3大步骤:

  1. 通过XMLConfigBuilder来解析xml配置文件
  2. 调用xml解析器进行解析得到Configuration对象
  3. 创建defaultSessionFactory对象
// 进行解析操作 将最终解析到的数据存储在configuration对象中public Configuration parse() { if  { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } parsed = true; // 从根节点configuration上开始解析 parseConfiguration(parser.evalNode("/configuration")); // 这个地方的configuration是在当前类XMLConfigBuilder的父类BaseBuilder中定义的,在本类的构造方法中创建 // 这儿configuration对象已经返回了,通过上面的代码可以构造出SqlSessionFactory的实现对象了。 return configuration;}

接下来,在parseConfiguration方法中开始xml文件的解析:

// 解析configuration节点下的配置,可对照mybatis-config.xml文件 private void parseConfiguration(XNode root) { try { // 提取settings Properties settings = settingsAsPropertiess(root.evalNode("settings")); // 解析settings //issue #117 read properties first propertiesElement(root.evalNode("properties")); // 解析properties loadCustomVfs; // 别名解析 typeAliasesElement(root.evalNode("typeAliases")); // 插件解析 pluginElement(root.evalNode("plugins")); // 解析自定义的ObjectFatory实现 objectFactoryElement(root.evalNode("objectFactory")); objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); reflectionFactoryElement(root.evalNode("reflectionFactory")); // 解析settings settingsElement; // read it after objectFactory and objectWrapperFactory issue #631 // 解析environments 数据源的配置 environmentsElement(root.evalNode("environments")); databaseIdProviderElement(root.evalNode("databaseIdProvider")); // 类型处理解析 typeHandlerElement(root.evalNode("typeHandlers")); // mappers映射解析 mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }

上面的代码中开始对配置文件中的各个节点进行解析,我们目前关注mapper的解析即可:

private void mapperElement(XNode parent) throws Exception { logger.info("开始解析Mappers节点"); if (parent != null) { for (XNode child : parent.getChildren { if ("package".equals(child.getName { logger.info("开始处理package节点"); String mapperPackage = child.getStringAttribute; // 调用configuration的添加方法 configuration.addMappers(mapperPackage); } else { // 通常将在另外的配置文件中配置SQL String resource = child.getStringAttribute("resource"); String url = child.getStringAttribute; String mapperClass = child.getStringAttribute; if (resource != null && url == null && mapperClass == null) { // <mapper resource="com/xxxxxxx/dao/****Mapper.xml"/> logger.info("解析resource:" + resource); ErrorContext.instance().resource; // 获取配置文件 InputStream inputStream = Resources.getResourceAsStream; XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments; // 解析器进行解析 mapperParser.parse(); } else if (resource == null && url != null && mapperClass == null) { // url方式解析 ErrorContext.instance().resource; InputStream inputStream = Resources.getUrlAsStream; XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments; mapperParser.parse(); } else if (resource == null && url == null && mapperClass != null) { Class<?> mapperInterface = Resources.classForName(mapperClass); configuration.addMapper(mapperInterface); } else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } logger.info("解析Mappers节点结束!"); }

在xml中配置了如下的mapper:<mapper resource="com/xxxxxxx/dao/****Mapper.xml"/>,通过resource定位到指定的配置文件中,再进行解析,XMLMapperBuilder中parse方法如下:

 public void parse() { logger.info(" 开始解析mapper文件:XMLMapperBuilder.parse"); if (!configuration.isResourceLoaded) { // 对mapper文件中对各个元素进行解析 configurationElement(parser.evalNode("/mapper")); configuration.addLoadedResource; bindMapperForNamespace(); } parsePendingResultMaps(); parsePendingChacheRefs(); parsePendingStatements(); }private void configurationElement(XNode context) { try { String namespace = context.getStringAttribute("namespace"); if (namespace == null || namespace.equals { throw new BuilderException("Mapper's namespace cannot be empty"); } logger.info("解析到mapper文件中的namespace元素:" + namespace); builderAssistant.setCurrentNamespace(namespace); cacheRefElement(context.evalNode("cache-ref")); cacheElement(context.evalNode; parameterMapElement(context.evalNodes("/mapper/parameterMap")); resultMapElements(context.evalNodes("/mapper/resultMap")); sqlElement(context.evalNodes("/mapper/sql")); // 解析配置文件中的sql语句,重点关注这儿 buildStatementFromContext(context.evalNodes("select|insert|update|delete")); } catch (Exception e) { throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e); } }

重点看对sql的解析

 private void buildStatementFromContext(List<XNode> list) { logger.info("解析mapper文件中insert | delete | update | select 元素"); if (configuration.getDatabaseId() != null) { buildStatementFromContext(list, configuration.getDatabaseId; } buildStatementFromContext(list, null); } private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { // 循环遍历sql语句配置 for (XNode context : list) { final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId); try { // 解析配置节点,并构造产生SQL封装体 statementParser.parseStatementNode(); } catch (IncompleteElementException e) { configuration.addIncompleteStatement(statementParser); } } }

SQL的处理,涉及到对配置信息的解析,以及对这些信息对封装处理上

/** * 该方法完成: * 1、对sql配置中的数据进行解析提取 * 2、通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装,并保存到configuration中去 */ public void parseStatementNode() { // 下面对配置信息进行逐个解析 String id = context.getStringAttribute; String databaseId = context.getStringAttribute("databaseId"); if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { return; } Integer fetchSize = context.getIntAttribute("fetchSize"); Integer timeout = context.getIntAttribute("timeout"); String parameterMap = context.getStringAttribute("parameterMap"); String parameterType = context.getStringAttribute("parameterType"); Class<?> parameterTypeClass = resolveClass(parameterType); String resultMap = context.getStringAttribute("resultMap"); String resultType = context.getStringAttribute("resultType"); String lang = context.getStringAttribute; LanguageDriver langDriver = getLanguageDriver; Class<?> resultTypeClass = resolveClass(resultType); String resultSetType = context.getStringAttribute("resultSetType"); StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString; ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType); String nodeName = context.getNode().getNodeName(); SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH)); boolean isSelect = sqlCommandType == SqlCommandType.SELECT; boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect); boolean useCache = context.getBooleanAttribute("useCache", isSelect); boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false); // Include Fragments before parsing XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant); includeParser.applyIncludes(context.getNode; // Parse selectKey after includes and remove them. processSelectKeyNodes(id, parameterTypeClass, langDriver); // Parse the SQL (pre: <selectKey> and <include> were parsed and removed) SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass); String resultSets = context.getStringAttribute("resultSets"); String keyProperty = context.getStringAttribute("keyProperty"); String keyColumn = context.getStringAttribute("keyColumn"); KeyGenerator keyGenerator; String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX; keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true); if (configuration.hasKeyGenerator(keyStatementId)) { keyGenerator = configuration.getKeyGenerator(keyStatementId); } else { keyGenerator = context.getBooleanAttribute("useGeneratedKeys", configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) ? new Jdbc3KeyGenerator() : new NoKeyGenerator(); } // 通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装 builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered, keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets); }

public MappedStatement addMappedStatement( String id, SqlSource sqlSource, StatementType statementType, SqlCommandType sqlCommandType, Integer fetchSize, Integer timeout, String parameterMap, Class<?> parameterType, String resultMap, Class<?> resultType, ResultSetType resultSetType, boolean flushCache, boolean useCache, boolean resultOrdered, KeyGenerator keyGenerator, String keyProperty, String keyColumn, String databaseId, LanguageDriver lang, String resultSets) { logger.info("解析mapper文件中的sql语句对象 元素 id:" + id); if (unresolvedCacheRef) { throw new IncompleteElementException("Cache-ref not yet resolved"); } id = applyCurrentNamespace(id, false); boolean isSelect = sqlCommandType == SqlCommandType.SELECT; MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType) .resource .fetchSize(fetchSize) .timeout .statementType(statementType) .keyGenerator(keyGenerator) .keyProperty(keyProperty) .keyColumn(keyColumn) .databaseId(databaseId) .lang .resultOrdered(resultOrdered) .resulSets(resultSets) .resultMaps(getStatementResultMaps(resultMap, resultType, id)) .resultSetType(resultSetType) .flushCacheRequired(valueOrDefault(flushCache, !isSelect)) .useCache(valueOrDefault(useCache, isSelect)) .cache(currentCache); ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id); if (statementParameterMap != null) { statementBuilder.parameterMap(statementParameterMap); } // 存储解析到到sql语句 MappedStatement statement = statementBuilder.build(); // 添加statement对象,对sql 的解析封装完成 configuration.addMappedStatement(statement); return statement; }

到此,对sql的解析封装完成,mybatis将mapper中的sql语句封装到MappedStatement对象中,存储到configuration对象的mappedStatements映射中。Configuration类中的存储SQL封装的集合:

 // 映射的SQL语句 protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");

在执行SQL 的时候还要从上述集合中获取对应的sql相关信息。

在前面的实例代码中很容易就获取到SqlSession对象了,有一行代码是获取Mapper对象的:

 SysUserDao userDao = sqlSession.getMapper(SysUserDao.class);

先看SqlSession对象的获取,通过上面分析,得到SqlSessionFactory的实现是DefaultSqlSessionFactory类。其openSession方法如下:

/** * 创建SqlSession * @see org.apache.ibatis.session.SqlSessionFactory#openSession() */ @Override public SqlSession openSession() { logger.info("open session..."); return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false); }/** * 获取SqlSession对象 * @param execType * @param level * @param autoCommit * @return */ private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Transaction tx = null; try { logger.info("openSessionFromDataSource..."); // environment内包含了数据源和事务相关的配置 final Environment environment = configuration.getEnvironment(); // 根据environment获取事务管理 final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); // 从environment中获取DataSource tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); // 执行器,通过Excutor来执行SQL语句,Excutor是对Statement的封装 final Executor executor = configuration.newExecutor(tx, execType); // 创建了一个DefaultSqlSession对象,传入了执行器 return new DefaultSqlSession(configuration, executor, autoCommit); } catch (Exception e) { closeTransaction; // may have fetched a connection so lets call close() throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e); } finally { ErrorContext.instance; } }

得到的SqlSession对象是DefaultSqlSession类的对象,现在看其getMapper方法

/** * 直接去configuration中找相关的mapper对象 * @see org.apache.ibatis.session.SqlSession#getMapper(java.lang.Class) */ @Override public <T> T getMapper(Class<T> type) { logger.info("getMapper name:" + type.getName; return configuration.<T>getMapper(type, this); }

Configuration类中的getMapper方法:

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { return mapperRegistry.getMapper(type, sqlSession); }

调用了MapperRegistry类中的方法,MapperRegistry主要负责mapper的注册,提供mapper代理功能。

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { // 让代理去找mapper final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get; if (mapperProxyFactory == null) { throw new BindingException("Type " + type + " is not known to the MapperRegistry."); } try { // 关键: 创建,具体的mapper代理执行类来创建。 return mapperProxyFactory.newInstance(sqlSession); } catch (Exception e) { throw new BindingException("Error getting mapper instance. Cause: " + e, e); } } public T newInstance(SqlSession sqlSession) { // 注意MapperProxy代理类,后续mapper方法执行的时候会到该代理的invoke方法中去 final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); return newInstance(mapperProxy); }protected T newInstance(MapperProxy<T> mapperProxy) { // 动态代理我们写的dao接口 return  Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); }

mybatis通过jdk的动态代理来为我们创建了mapper接口的实现。需要注意:MapperProxy这个代理类,后续mapper方法执行的时候会到该代理的invoke方法中去

 /** * MapperProxy在执行时会触发此方法 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 方法所在的是不是一个类? Mapper是一个接口,不是类,则跳过 System.out.println("method.getDeclaringClass():" + method.getDeclaringClass; if (Object.class.equals(method.getDeclaringClass { try { return method.invoke(this, args); } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable; } } final MapperMethod mapperMethod = cachedMapperMethod; // 交给mapperMethod去执行 return mapperMethod.execute(sqlSession, args); }

MapperMethod是整个代理机制中的核心,对SqlSession中的方法做了封装。

/** * 根据sql类型去判断执行,最终还是去调用sqlSession中的方法去完成 * @param sqlSession * @param args * @return */ public Object execute(SqlSession sqlSession, Object[] args) { // 返回结果 Object result; // insert操作 if (SqlCommandType.INSERT == command.getType { // 参数转换处理 Object param = method.convertArgsToSqlCommandParam; // 调用sqlSession的insert方法 result = rowCountResult(sqlSession.insert(command.getName); // update } else if (SqlCommandType.UPDATE == command.getType { Object param = method.convertArgsToSqlCommandParam; result = rowCountResult(sqlSession.update(command.getName); // delete } else if (SqlCommandType.DELETE == command.getType { Object param = method.convertArgsToSqlCommandParam; result = rowCountResult(sqlSession.delete(command.getName); // select } else if (SqlCommandType.SELECT == command.getType { // 如果返回void,并且参数有结果处理器 if (method.returnsVoid() && method.hasResultHandler { executeWithResultHandler(sqlSession, args); result = null; // 返回多行结果的 } else if (method.returnsMany { // 分析这儿 result = executeForMany(sqlSession, args); // 返回类型是map } else if (method.returnsMap { result = executeForMap(sqlSession, args); } else { // 否则,就是查询单个对象的 Object param = method.convertArgsToSqlCommandParam; result = sqlSession.selectOne(command.getName; } // flush操作 } else if (SqlCommandType.FLUSH == command.getType { result = sqlSession.flushStatements(); } else { // 不匹配,说明,mapper中定义的方法不对 throw new BindingException("Unknown execution method for: " + command.getName; } //如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常 if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid { throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType; } return result; }

executeForMany方法:

/** * 返回多行查询结果的,主要是调用sqlSession的seleceList方法实现 * @param sqlSession * @param args * @param <E> * @return */ private <E> Object executeForMany(SqlSession sqlSession, Object[] args) { List<E> result; Object param = method.convertArgsToSqlCommandParam; // 如果参数中含有rowBounds则调用分页查询 if (method.hasRowBounds { RowBounds rowBounds = method.extractRowBounds; result = sqlSession.<E>selectList(command.getName(), param, rowBounds); } else { // 没有分页,普通查询 result = sqlSession.<E>selectList(command.getName; } // issue #510 Collections & arrays support if (!method.getReturnType().isAssignableFrom(result.getClass { if (method.getReturnType().isArray { return convertToArray; } else { return convertToDeclaredCollection(sqlSession.getConfiguration(), result); } } return result; }

对数据库的操作 最终还是落到SqlSession(DefaultSqlSession实现)类上了。看查询操作:

/** * 在MapperProxy中调用 * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds) */ @Override public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { MappedStatement ms = configuration.getMappedStatement(statement); // 实际上是然executor去执行了。 return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance; } }

DefaultSqlSession中的selectList 方法

/** * 在MapperProxy中调用 * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds) */ @Override public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { MappedStatement ms = configuration.getMappedStatement(statement); // 实际上是然executor去执行了。 return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance; } }

BaseExecutor中query方法:

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { BoundSql boundSql = ms.getBoundSql(parameter); // 生成缓存key CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql); return query(ms, parameter, rowBounds, resultHandler, key, boundSql); }

SimpleExecutor中的查询方法:

/** * 在SqlSession中调用 * @see org.apache.ibatis.executor.BaseExecutor#doQuery(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler, org.apache.ibatis.mapping.BoundSql) */ @Override public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { Configuration configuration = ms.getConfiguration(); // 构建StatementHandler对象 StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); // 预编译和基础设置 stmt = prepareStatement(handler, ms.getStatementLog; // StatementHandler封装了Statement,让其处理,并通过resultHandler来完成对结果集对回调处理 return handler.<E>query(stmt, resultHandler); } finally { closeStatement; } }

最终通过结果处理器进行回调,完成对查询到的结果集进行处理并返回。

4、总结

整体上,按照查询涉及到的代码过了一遍,对mybatis的源码有了个大体的了解,后续对其逐步进行解析。

本文由威尼斯888发布于计算机网络 / 编程,转载请注明出处:目录如下

关键词:

上一篇:就不需要为这些第三方类库设置版本号了

下一篇:那么我们可能需要使用JPA提供的repository方法