還是接着上一篇深入源碼分析mybatis查詢原理(三)繼續討論。
由於前面幾篇的查詢都是沒有帶參數的,那麼我現在加一個帶參數查詢的方法,來看一下mybatis如何處理參數並查詢。
EmpTexst.java t1()方法
Emp emp = empmapper.queryByEmpNoAndName(1, "admin");
System.out.println(emp);
empmapper.java
//按條件查詢
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);
empmapper.xml<select id="queryByEmpNoAndName" resultType="emp">
select * from emp where EMPNO = #{empNo} and ENAME = #{name}
</select>
以上就是增加的查詢
在Emp emp = empmapper.queryByEmpNoAndName(1, "admin");打上斷點。
進入源碼
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
重點關注mapperMethod.execute(sqlSession, args); 前面方法都討論過了,今天接着討論這個方法
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
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;
}
這個execute方法會根據執行SQL的類型和返回結果的類型選擇合適的sql執行,這個查詢將會執行
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
可以看到這裏的參數列表[1,admin]。
斷點進入 convertArgsToSqlCommandParam 這個方法,從這個方法名字可以知道,這個方法的作用是將參數列表轉換爲SQL的參數。源碼
public Object convertArgsToSqlCommandParam(Object[] args) {
return paramNameResolver.getNamedParams(args);
}
這裏看到有一個 paramNameResolver 對象,ParamNameResolver類是用來對方法的參數做解析的,解析的過程是在創建 MethodSignature 對象時解析的,由於上一章方法沒有參數,所以參數解析也就沒有討論到,現在給它補上,不好意思,這樣子就有點亂了。那我們回顧一下 MethodSignature 創建過程吧
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
if (resolvedReturnType instanceof Class<?>) {
this.returnType = (Class<?>) resolvedReturnType;
} else if (resolvedReturnType instanceof ParameterizedType) {
this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
} else {
this.returnType = method.getReturnType();
}
this.returnsVoid = void.class.equals(this.returnType);
this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
this.returnsCursor = Cursor.class.equals(this.returnType);
this.mapKey = getMapKey(method);
this.returnsMap = (this.mapKey != null);
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
this.paramNameResolver = new ParamNameResolver(configuration, method);
}
可以看到最後一段代碼 this.paramNameResolver = new ParamNameResolver(configuration, method);之前的分析,包括MethodSignature是什麼,何時創建都在上一章討論過了,這裏不再重複囉嗦了。好,我們點進去看看ParamNameResolver的創建過程。
ParamNameResolver 創建
public ParamNameResolver(Configuration config, Method method) {
final Class<?>[] paramTypes = method.getParameterTypes();
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final SortedMap<Integer, String> map = new TreeMap<Integer, String>();
int paramCount = paramAnnotations.length;
// get names from @Param annotations
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
if (isSpecialParameter(paramTypes[paramIndex])) {
// skip special parameters
continue;
}
String name = null;
for (Annotation annotation : paramAnnotations[paramIndex]) {
if (annotation instanceof Param) {
hasParamAnnotation = true;
name = ((Param) annotation).value();
break;
}
}
if (name == null) {
// @Param was not specified.
if (config.isUseActualParamName()) {
name = getActualParamName(method, paramIndex);
}
if (name == null) {
// use the parameter index as the name ("0", "1", ...)
// gcode issue #71
name = String.valueOf(map.size());
}
}
map.put(paramIndex, name);
}
names = Collections.unmodifiableSortedMap(map);
}
解讀一下這段代碼:首先,通過java的反射獲取到參數的類型和參數的註解method.getParameterAnnotations()方法返回的是註解的二維數組,每一個方法的參數包含一個註解數組。
到這裏,停一下,這個參數註解是個二維數組,那麼這個二維數組是怎麼排列組合的呢,參數註解的length和參數類型數組的length有什麼關係?
看上面的圖知道,paramAnnotations[0][0] = @org.apache.ibatis.annotations.Param(value=name),
paramAnnotations[1][0] = @org.apache.ibatis.annotations.Param(value=name),也就是說二維數組是包含多個僅有一個值的數組.因爲參數前可以添加多個註解,所以是二維數組,一個參數上不可以添加相同的註解,同一個註解可以加在不同的參數上!
而這個一維數組的length就是參數數組的length,如果一個參數沒有加註解,一個參數加了註解,會是怎麼樣的呢,我們改一下代碼。
empmapper.java//按條件查詢
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);
empmapper.xml<select id="queryByEmpNoAndName" resultType="emp">
select * from emp where EMPNO = #{0} and ENAME = #{name}
</select>
再次斷點進入,查看
可以看到第一個是空,第二個沒有區別。
好,回到主線上,mybatis通過反射獲取到參數類型數組和註解數組後,遍歷所有的參數 ,判斷這個參數的類型是否是特殊類型,這裏特殊類型指RowBounds和ResultHandler,是的話跳過,咱不處理 ,然後判斷這個參數是否是用來Param註解,如果使用的話,設置hasParamAnnotation爲true,表示參數中使用了Param註解,然後設置name就是Param註解的值,把name放到map中,鍵爲參數在方法中的位置,value爲Param的值 ,如果沒有使用Param註解,判斷是否開啓了UseActualParamName,如果開啓了,則使用java8的反射得到方法的名字。如果沒有開啓,那麼就會使用參數索引作爲name。
這個討論的有點,亂舉個例子,mybatis通過創建ParamNameResolver時對參數做解析。解析的結果:
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);
解析結果:{0=0, 1=name}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);
解析結果:{0=empNo, 1=name}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, String name);
解析結果:{0=empNo, 1=1}
好了,我們回到paramNameResolver.getNamedParams(args);接着往下討論
public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
if (args == null || paramCount == 0) {
return null;
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
} else {
final Map<String, Object> param = new ParamMap<Object>();
int i = 0;
for (Map.Entry<Integer, String> entry : names.entrySet()) {
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
解讀這段代碼,首先如果只有一個參數,就返回這個參數,否者的話就是遍歷names,取出Map的value作爲參數param的key,根據names的key作爲索引,從args中取出值作爲參數names的value.接着生成參數 names(格式就是,param+i ,生成爲param1,param2,param3.....)作爲param的key,並把args作爲值,若args 爲 [1, admin]。那這一步生成的param就是{param1=1, param2=admin}。
可能這麼說有點不清晰,還是把上面的例子拿過來。
args 爲 [1, admin]。
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);
names 爲 {0=0, 1=name}
解析結果:{0=1, name=admin, param1=1, param2=admin}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);
解析結果:name=admin, empNo=1, param1=1, param2=admin}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, String name);
解析結果:{1=admin, empNo=1, param1=1, param2=admin}
至此 把參數列表解析成SQL參數討論完成。
接着回到這段代碼:
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
selectOne方法
@Override
public <T> T selectOne(String statement, Object parameter) {
// Popular vote was to return null on 0 results and throw exception on too many.
List<T> list = this.<T>selectList(statement, parameter);
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
}
接着定位selectList方法
@Override
public <E> List<E> selectList(String statement, Object parameter) {
return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
MappedStatement ms = configuration.getMappedStatement(statement);
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().reset();
}
}
接續 query方法
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
首先 獲取 BoundSql ,這是什麼呢?
/**
* Copyright 2009-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.mapping;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.session.Configuration;
/**
* An actual SQL String got form an {@link SqlSource} after having processed any dynamic content.
* The SQL may have SQL placeholders "?" and an list (ordered) of an parameter mappings
* with the additional information for each parameter (at least the property name of the input object to read
* the value from).
* </br>
* Can also have additional parameters that are created by the dynamic language (for loops, bind...).
*
* @author Clinton Begin
*/
public class BoundSql {
private String sql;
private List<ParameterMapping> parameterMappings;
private Object parameterObject;
private Map<String, Object> additionalParameters;
private MetaObject metaParameters;
public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
this.sql = sql;
this.parameterMappings = parameterMappings;
this.parameterObject = parameterObject;
this.additionalParameters = new HashMap<String, Object>();
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public String getSql() {
return sql;
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public Object getParameterObject() {
return parameterObject;
}
public boolean hasAdditionalParameter(String name) {
PropertyTokenizer prop = new PropertyTokenizer(name);
String indexedName = prop.getIndexedName();
return additionalParameters.containsKey(indexedName);
}
public void setAdditionalParameter(String name, Object value) {
metaParameters.setValue(name, value);
}
public Object getAdditionalParameter(String name) {
return metaParameters.getValue(name);
}
}
英文好的同學 可以看看這段:
/**
* An actual SQL String got form an {@link SqlSource} after having processed any dynamic content.
* The SQL may have SQL placeholders "?" and an list (ordered) of an parameter mappings
* with the additional information for each parameter (at least the property name of the input object to read
* the value from).
* </br>
* Can also have additional parameters that are created by the dynamic language (for loops, bind...).
*
* @author Clinton Begin
*/
這個對象有三個屬性很重要:
private String sql; //從解析時可以看出這個sql不是配置文件中的sql,這個sql已經經過了處理(如:佔用位符的處理、動態語句的解析if、foreach等待)
private List<ParameterMapping> parameterMappings; //sql對應的參數列表(包含了參數名,類型,jdbc類型等等)
private Object parameterObject;//參數
接下來是創建CacheKey,這個CacheKey,使用一級緩存中會用到,這個暫時不討論,寫一章專門討論緩存時在討論。
接着 query
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, parameterObject, boundSql);
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
if (list == null) {
list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
可以看到,首先獲取緩存,根據CacheKey,從緩存中獲取結果,如果沒有則,從數據庫中獲取,並把結果設置到緩存中,以備後續有相同的查詢,提高性能。這需要注意的一點是之前調用query的Executor都是CachingExecutor,現在調用query的Executor是SimpleExecutor,這是一種設計模式:裝飾者模式。
好,進入SimpleExecutor的query方法,但是當我們代碼單步進入的是BaseExecutor。
這裏代碼多,就在裏面寫上註釋了
@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
//關閉 則報錯
if (closed) {
throw new ExecutorException("Executor was closed.");
}
//如果設置刷新緩存 ,並且queryStack查詢堆棧爲0,清局部緩存,再查詢(queryStack 處理遞歸調用)
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
//加一,這樣遞歸調用到上面的時候就不會再清局部緩存了
queryStack++;
//嘗試根據cachekey從localCache去查
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
//從數據庫中查找
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
關注 queryFromDatabase方法
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
localCache.removeObject(key);
}
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
再看 doQuery
@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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
跟源碼看一下 configuration.newStatementHandler,一路點下去,看到
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
switch (ms.getStatementType()) {
case STATEMENT:
delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case PREPARED:
delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case CALLABLE:
delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}
}
根據StatementType 創建對應的StatementHandler,而 StatementType 是在mapper.xml中配置的,默認爲PREPARED
接着關注一下prepareStatement方法:
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
首先獲取連接,然後獲取 PreparedStatement。我們知道myBatis是對jdbc的封裝,回想一下jdbc執行SQL的步驟吧。
1.加載驅動。 ---->> ---myBatis 配置文件 獲取dataSource.
2.獲取數據庫連接。 ---->> --- myBatis獲取prepareStatement時
3.創建Statement。 ---->>-----上圖也說明了myBatis怎麼獲取Statement
4.準備SQL ---->> ----- myBatis 的boundSql對象封裝處理好的SQL信息,參數信息。
5.設置參數 ---->> ----- 看上圖代碼,也就是這段代碼:
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
關注一下這段代碼:handler.parameterize(stmt);
一路點過去
@Override
public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
} catch (SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}
這段代碼就是PreparedStatement對象設置參數。首先獲取ParameterMapping列表,這個ParameterMapping主要是做參數解析後的結果,可以看到解析出了 參數的javaType,jdbcType,mode等等。
這段代碼中我們重點關注 那幾個if else 分支
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
} catch (SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
從parameterMapping中獲取到屬性,
首先判斷這個屬性是否是額外的參數,也就是使用 <if> <foreach>的時候,mybatis自動生成的動態參數,如果是的話就從動態參數中去取值。
第二,如果這個參數是空,那麼直接返回空。
第三,如果參數是一個簡單類型,或者是註冊了typeHandler的對象類型,就直接使用參數作爲返回值,最後一個是複雜對象或者是Map類型,把參數對象包裝成MetaObject,通過getValue獲取值。
之後設置參數值。
6.執行SQL語句 ---->> ---- 下邊這個 doQuery
7.處理結果集 ---->>-----
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
這個方法調用PreparedStatement執行SQL語句。接下來就是對結果集的處理。如果有讀者發現我說的有不對的地方,還望大家多多指教!