主頁 > 後端開發 > 精盡MyBatis原始碼分析 - SqlSession 會話與 SQL 執行入口

精盡MyBatis原始碼分析 - SqlSession 會話與 SQL 執行入口

2020-11-26 20:28:41 後端開發

該系列檔案是本人在學習 Mybatis 的原始碼程序中總結下來的，可能對讀者不太友好，請結合我的原始碼注釋（Mybatis原始碼分析 GitHub 地址、Mybatis-Spring 原始碼分析 GitHub 地址、Spring-Boot-Starter 原始碼分析 GitHub 地址）進行閱讀

MyBatis 版本：3.5.2

MyBatis-Spring 版本：2.0.3

MyBatis-Spring-Boot-Starter 版本：2.1.4

SqlSession會話與SQL執行入口

在前面一系列的檔案中，已經詳細的介紹了 MyBatis 的初始化和執行 SQL 的程序，在執行 SQL 的程序中，還存在著一些疑問，例如其中一直提到的 SqlSession 會話在 MyBatis 中是如何被創建的？如何呼叫 Executor 執行器執行 SQL 的？

那么接下來就關于上面兩個的兩個問題，一起來探討一下 MyBatis 中 SqlSession 會話的相關內容

先回顧一下《基礎支持層》的Binding模塊，每個Mapper Interface會有對應的MapperProxyFactory動態代理物件工廠，用于創建MapperProxy動態代理物件，Mapper 介面中的每個方法都有對應的MapperMethod物件，該物件會通過 SqlSession 會話執行資料操作

再來看到這張MyBatis整體圖：

SQLExecuteProcess

在單獨使用 MyBatis 進行資料庫操作時，需要通過SqlSessionFactoryBuilder構建一個SessionFactory物件，然后通過它創建一個SqlSession會話進行資料庫操作

我們通常都會先呼叫SqlSession會話的getMapper(Class<T> mapper)方法，為 Mapper 介面生成一個“實作類”（JDK動態代理物件），然后就可以通過它進行資料庫操作

示例

// <1> 構建 SqlSessionFactory 物件
Reader reader = Resources.getResourceAsReader("org/apache/ibatis/autoconstructor/mybatis-config.xml");
// <2> 默認 DefaultSqlSessionFactory 物件
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);

// <3> 獲得 SqlSession 物件，默認 DefaultSqlSession 物件
SqlSession sqlSession = sqlSessionFactory.openSession();

// <4> 獲得 Mapper 物件
final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);

// <5> 執行查詢
final Object subject = mapper.getSubject(1);

SqlSessionFactoryBuilder

org.apache.ibatis.session.SqlSessionFactoryBuilder：構建SqlSessionFactory工廠類，里面定義了許多build多載方法，主要分為處理Reader和InputStream兩種檔案資源物件，代碼如下：

public class SqlSessionFactoryBuilder {

	public SqlSessionFactory build(Reader reader) {
		return build(reader, null, null);
	}

	public SqlSessionFactory build(Reader reader, String environment) {
		return build(reader, environment, null);
	}

	public SqlSessionFactory build(Reader reader, Properties properties) {
		return build(reader, null, properties);
	}

	/**
	 * 構造 SqlSessionFactory 物件
	 *
	 * @param reader Reader 物件
	 * @param environment 環境
	 * @param properties Properties 變數
	 * @return SqlSessionFactory 物件
	 */
	public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
		try {
			/*
			 * <1> 創建 XMLConfigBuilder 物件
			 * 會生成一個 XPathParser，包含 Document 物件
			 * 會創建一個 Configuration 全域配置物件
			 */
			XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
			/*
			 * <2> 決議 XML 檔案并配置到 Configuration 全域配置物件中
			 * <3> 創建 DefaultSqlSessionFactory 物件
			 */
			return build(parser.parse());
		} catch (Exception e) {
			throw ExceptionFactory.wrapException("Error building SqlSession.", e);
		} finally {
			ErrorContext.instance().reset();
			try {
				reader.close();
			} catch (IOException e) {
				// Intentionally ignore. Prefer previous error.
			}
		}
	}

	public SqlSessionFactory build(InputStream inputStream) {
		return build(inputStream, null, null);
	}

	public SqlSessionFactory build(InputStream inputStream, String environment) {
		return build(inputStream, environment, null);
	}

	public SqlSessionFactory build(InputStream inputStream, Properties properties) {
		return build(inputStream, null, properties);
	}

	public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
		try {
			XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
			return build(parser.parse());
		} catch (Exception e) {
			throw ExceptionFactory.wrapException("Error building SqlSession.", e);
		} finally {
			ErrorContext.instance().reset();
			try {
				inputStream.close();
			} catch (IOException e) {
				// Intentionally ignore. Prefer previous error.
			}
		}
	}

	public SqlSessionFactory build(Configuration config) {
		return new DefaultSqlSessionFactory(config);
	}

}

在《MyBatis初始化（一）之加載mybatis-config.xml》中已經分析了，這里就不再贅述，就是根據檔案資源創建Configuration全域配置物件，然后構建一個DefaultSqlSessionFactory物件

DefaultSqlSessionFactory

org.apache.ibatis.session.defaults.DefaultSqlSessionFactory：實作 SqlSessionFactory 介面，默認的 SqlSessionFactory 實作類

openSession方法

openSession方法，創建一個DefaultSqlSession物件，如下：

public class DefaultSqlSessionFactory implements SqlSessionFactory {

	private final Configuration configuration;

	public DefaultSqlSessionFactory(Configuration configuration) {
		this.configuration = configuration;
	}

	@Override
	public SqlSession openSession() {
		return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
	}

	@Override
	public SqlSession openSession(boolean autoCommit) {
		return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
	}

	@Override
	public SqlSession openSession(ExecutorType execType) {
		return openSessionFromDataSource(execType, null, false);
	}

	@Override
	public SqlSession openSession(TransactionIsolationLevel level) {
		return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
	}

	@Override
	public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
		return openSessionFromDataSource(execType, level, false);
	}

	@Override
	public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
		return openSessionFromDataSource(execType, null, autoCommit);
	}

	@Override
	public SqlSession openSession(Connection connection) {
		return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
	}

	@Override
	public SqlSession openSession(ExecutorType execType, Connection connection) {
		return openSessionFromConnection(execType, connection);
	}
}

openSession有很多多載的方法，主要是提供以下幾種入參的支持：

型別 引數名稱 默認值 描述
boolean autoCommit false 事務是否自動提交
ExecutorType execType ExecutorType.SIMPLE Executor執行器型別
TransactionIsolationLevel level 無 事務隔離級別
java.sql.Connection connection 無 資料庫連接

內部直接呼叫openSessionFromDataSource私有方法，內部也需要呼叫openSessionFromConnection私有方法，如果存在connection入參，內部則直接呼叫openSessionFromConnection私有方法

openSessionFromDataSource方法

openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit)方法，用于創建一個DefaultSqlSession物件，方法如下：

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,
        boolean autoCommit) {
    Transaction tx = null;
    try {
        // 獲得 Environment 物件
        final Environment environment = configuration.getEnvironment();
        // 創建 Transaction 物件
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
        tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
        // 創建 Executor 物件
        final Executor executor = configuration.newExecutor(tx, execType);
        // 創建 DefaultSqlSession 物件
        return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
        // 如果發生例外，則關閉 Transaction 物件
        closeTransaction(tx); // may have fetched a connection so lets call close()
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}
  1. 獲得Environment當前環境物件
  2. 通過getTransactionFactoryFromEnvironment方法，從 Environment 環境物件中TransactionFactory物件，用于創建一個Transaction事務
  3. 然后再創建一個Executor執行器物件
  4. 根據全域配置物件、執行器和事務是否自動提交創建一個DefaultSqlSession物件

openSessionFromConnection方法

openSessionFromConnection(ExecutorType execType, Connection connection)方法，用于創建一個DefaultSqlSession物件

和上面的方法邏輯相同，只不過它的入參直接傳入了一個Connection資料庫連接，方法如下：

private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
    try {
        // 獲得是否可以自動提交
        boolean autoCommit;
        try {
            autoCommit = connection.getAutoCommit();
        } catch (SQLException e) {
            // Failover to true, as most poor drivers
            // or databases won't support transactions
            autoCommit = true;
        }
        // 獲得 Environment 物件
        final Environment environment = configuration.getEnvironment();
        // 創建 Transaction 物件
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
        final Transaction tx = transactionFactory.newTransaction(connection);
        // 創建 Executor 物件
        final Executor executor = configuration.newExecutor(tx, execType);
        // 創建 DefaultSqlSession 物件
        return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

和上面的方法不同的是，創建Transaction事務物件時，傳入的引數直接是Connection資料庫連接物件

getTransactionFactoryFromEnvironment方法

getTransactionFactoryFromEnvironment(Environment environment)方法，用于創建一個TransactionFactory物件，在創建 SqlSessionFactory 時，就可以通過設定 Environment 的 DataSource 資料源和 TransactionFactory 事務工廠來集成第三方資料源和事務管理器，代碼如下：

private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
    // 情況一，創建 ManagedTransactionFactory 物件
    if (environment == null || environment.getTransactionFactory() == null) {
        return new ManagedTransactionFactory();
    }
    // 情況二，使用 `environment` 中的
    return environment.getTransactionFactory();
}

closeTransaction方法

closeTransaction(Transaction tx)方法，關閉事務，方法如下：

private void closeTransaction(Transaction tx) {
    if (tx != null) {
        try {
            tx.close();
        } catch (SQLException ignore) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

DefaultSqlSession

org.apache.ibatis.session.defaults.DefaultSqlSession：實作 SqlSession 介面，默認的 SqlSession 實作類，呼叫 Executor 執行器，執行資料庫操作

構造方法

public class DefaultSqlSession implements SqlSession {

    /**
     * 全域配置
     */
	private final Configuration configuration;
    /**
     * 執行器物件
     */
	private final Executor executor;
	/**
	 * 是否自動提交事務
	 */
	private final boolean autoCommit;
	/**
	 * 是否發生資料變更
	 */
	private boolean dirty;
	/**
	 * Cursor 陣列
	 */
	private List<Cursor<?>> cursorList;

	public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
		this.configuration = configuration;
		this.executor = executor;
		this.dirty = false;
		this.autoCommit = autoCommit;
	}
}

select方法

執行資料庫查詢操作，提供了許多多載方法

@Override
public void select(String statement, Object parameter, ResultHandler handler) {
    select(statement, parameter, RowBounds.DEFAULT, handler);
}

@Override
public void select(String statement, ResultHandler handler) {
    select(statement, null, RowBounds.DEFAULT, handler);
}

@Override
public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
        MappedStatement ms = configuration.getMappedStatement(statement);
        executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

@Override
public <T> T selectOne(String statement) {
    return this.selectOne(statement, null);
}

@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.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;
    }
}

@Override
public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
    return this.selectMap(statement, null, mapKey, RowBounds.DEFAULT);
}

@Override
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
    return this.selectMap(statement, parameter, mapKey, RowBounds.DEFAULT);
}

@Override
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
    // <1> 執行查詢
    final List<? extends V> list = selectList(statement, parameter, rowBounds);
    // <2> 創建 DefaultMapResultHandler 物件
    final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<>(mapKey,
            configuration.getObjectFactory(), configuration.getObjectWrapperFactory(),
            configuration.getReflectorFactory());
    // <3> 創建 DefaultResultContext 物件
    final DefaultResultContext<V> context = new DefaultResultContext<>();
    // <4> 遍歷查詢結果
    for (V o : list) {
        // 設定 DefaultResultContext 中
        context.nextResultObject(o);
        // 使用 DefaultMapResultHandler 處理結果的當前元素
        mapResultHandler.handleResult(context);
    }
    // <5> 回傳結果
    return mapResultHandler.getMappedResults();
}

@Override
public <E> List<E> selectList(String statement) {
    return this.selectList(statement, null);
}

@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 {
        // <1> 獲得 MappedStatement 物件
        MappedStatement ms = configuration.getMappedStatement(statement);
        // <2> 執行查詢
        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();
    }
}

上面有很多的資料庫查詢方法，主要分為以下幾種：

  • select：執行資料庫查詢操作，通過入參中的ResultHandler處理結果集，無回傳結果
  • selectList：執行資料庫查詢操作，回傳List集合
  • selectOne：呼叫selectList方法，執行資料庫查詢操作，最多只能回傳一條資料
  • selectMap：呼叫selectList方法，執行資料庫查詢操作，通過DefaultMapResultHandler進行處理，將回傳結果轉換成Map集合

可以看到通過Executor執行器的query方法執行查詢操作，可以回顧《SQL執行程序（一）之Executor》中的內容

這里會先呼叫wrapCollection方法對入參進行包裝（如果是集合型別）

update方法

執行資料庫更新操作

@Override
public int insert(String statement) {
    return insert(statement, null);
}

@Override
public int insert(String statement, Object parameter) {
    return update(statement, parameter);
}

@Override
public int delete(String statement) {
    return update(statement, null);
}

@Override
public int delete(String statement, Object parameter) {
    return update(statement, parameter);
}

@Override
public int update(String statement) {
    return update(statement, null);
}

@Override
public int update(String statement, Object parameter) {
    try {
        // <1> 標記 dirty ，表示執行過寫操作
        dirty = true;
        // <2> 獲得 MappedStatement 物件
        MappedStatement ms = configuration.getMappedStatement(statement);
        // <3> 執行更新操作
        return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

insert和delete方法最終都是呼叫update方法，通過Executor執行器的update方法執行資料庫更新操作

這里會先呼叫wrapCollection方法對入參進行包裝（如果是集合型別）

wrapCollection方法

wrapCollection(final Object object)方法，將集合型別的引數包裝成StrictMap物件，方法如下：

public static class StrictMap<V> extends HashMap<String, V> {

    private static final long serialVersionUID = -5741767162221585340L;

    @Override
    public V get(Object key) {
        if (!super.containsKey(key)) {
            throw new BindingException(
                    "Parameter '" + key + "' not found. Available parameters are " + this.keySet());
        }
        return super.get(key);
    }

}

private Object wrapCollection(final Object object) {
    if (object instanceof Collection) {
        // 如果是集合，則添加到 collection 中
        StrictMap<Object> map = new StrictMap<>();
        map.put("collection", object);
        // 如果是 List ，則添加到 list 中
        if (object instanceof List) {
            map.put("list", object);
        }
        return map;
    } else if (object != null && object.getClass().isArray()) {
        // 如果是 Array ，則添加到 array 中
        StrictMap<Object> map = new StrictMap<>();
        map.put("array", object);
        return map;
    }
    return object;
}

getMapper方法

getMapper(Class<T> type)方法，獲取Mapper介面的代理物件

@Override
public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
}

通過Configuration全域配置物件獲取一個動態代理物件

實際通過MapperRegistry注冊表獲取到該Mapper介面對應的MapperProxyFactory動態代理工廠，然后創建一個MapperProxy動態代理的實體物件

其他方法

  • flushStatements()：提交批處理
  • commit()：提交事務
  • rollback()：回滾事務
  • close()：關閉當前會話
  • getConnection()：獲取當前事務的資料庫連接
  • clearCache()：清理一級快取

MapperMethod

org.apache.ibatis.binding.MapperMethod：Mapper介面中定義的方法對應的Mapper方法，通過它來執行SQL

先來看看執行一個SQL的完整流程圖：

SQL-Process

在《基礎支持層》的Binding模塊已經講過了相關的內容，例如看到前面示例的第4步，通過DefaultSqlSession的getMapper方法會執行以下操作：

  1. 創建Mapper介面對應的MapperProxyFactory動態代理物件工廠
  2. 通過這個工廠的newInstance方法會創建一個MapperProxy介面代理類，然后回傳該Mapper介面的動態代理物件

當你呼叫這個介面的某個方法時，會進入這個MapperProxy代理類，我們來看到它的invoke方法是如何實作的，方法如下：

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        // <1> 如果是 Object 定義的方法，直接呼叫
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
        } else if (method.isDefault()) { // 是否有 default 修飾的方法
            // 針對Java7以上版本對動態型別語言的支持
            if (privateLookupInMethod == null) {
                return invokeDefaultMethodJava8(proxy, method, args);
            } else {
                return invokeDefaultMethodJava9(proxy, method, args);
            }
        }
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
    // <2.1> 獲得 MapperMethod 物件
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // <2.2> 執行 MapperMethod 方法
    return mapperMethod.execute(sqlSession, args);
}

首先獲取到方法對應的MapperMethod物件，然后通過該物件去執行資料庫的操作

execute方法

public Object execute(SqlSession sqlSession, Object[] args) {
    // 根據 SqlCommand 的 Type 判斷應該如何執行 SQL 陳述句
    Object result;
    switch (command.getType()) {
    case INSERT: {
        // <1> 獲取引數值與引數名的映射
        Object param = method.convertArgsToSqlCommandParam(args);
  		// <2> 然后通過 SqlSession 進行資料庫更新操作，并將受影響行數轉換為結果
        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()) { // 無回傳，且入參中有 ResultHandler 結果處理器
            executeWithResultHandler(sqlSession, args);
            result = null;
        } else if (method.returnsMany()) {
    		// 執行查詢，回傳串列
            result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
    		// 執行查詢，回傳 Map
            result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
    		// 執行查詢，回傳 Cursor
            result = executeForCursor(sqlSession, args);
        } else { // 執行查詢，回傳單個物件
            // 獲取引數名稱與入參的映射
            Object param = method.convertArgsToSqlCommandParam(args);
            // 執行查詢，回傳單條資料
            result = sqlSession.selectOne(command.getName(), param);
            if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) {
                result = Optional.ofNullable(result);
            }
        }
        break;
    case FLUSH:
        result = sqlSession.flushStatements();
        break;
    default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    // 回傳結果為 null ，并且回傳型別為原始型別（基本型別），則拋出 BindingException 例外
    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;
}

根據 SqlCommand 的 Type 判斷應該如何執行 SQL 陳述句，型別分為INSERT、UPDATE、DELETE、SELECT和FLUSH（進行批處理）五種

前三種都屬于資料庫的更新操作，呼叫的是DefaultSqlSession的update方法，通過rowCountResult(int rowCount)將受影響行數轉換為回傳物件

查詢陳述句的話就分為以下幾種情況：

  1. 無回傳，且入參中有 ResultHandler 結果處理器，則呼叫executeWithResultHandler方法，執行查詢，回傳結果設定為null
  2. 回傳物件為多條資料，則呼叫executeForMany方法，執行查詢，回傳串列
  3. 回傳物件為Map型別，則呼叫executeForMap方法，執行查詢，回傳Map
  4. 回傳物件為Cursor型別，則呼叫executeForCursor方法，執行查詢，回傳Cursor
  5. 回傳物件為單個物件，則呼叫DefaultSqlSession的selectOne方法，執行查詢，回傳單個物件

上面執行資料庫操作前會先呼叫convertArgsToSqlCommandParam方法，獲取引數值與引數名的映射

convertArgsToSqlCommandParam方法

convertArgsToSqlCommandParam(Object[] args)方法，根據入參回傳引數名稱與入參的映射，方法如下：

public Object convertArgsToSqlCommandParam(Object[] args) {
    return paramNameResolver.getNamedParams(args);
}

在《基礎支持層》的反射模塊的ParamNameResolver小節已經分析過該方法，可以跳過去看看

rowCountResult方法

rowCountResult(int rowCount)方法，將受影響行數轉換為結果，方法如下：

private Object rowCountResult(int rowCount) {
    final Object result;
    if (method.returnsVoid()) {
        result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
        result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
        result = (long) rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
        result = rowCount > 0;
    } else {
        throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: "
                + method.getReturnType());
    }
    return result;
}

executeWithResultHandler方法

executeWithResultHandler(SqlSession sqlSession, Object[] args)方法，通過入參中定義的ResultHandler結果處理器執行查詢，方法如下：

private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
    // <1> 獲得 MappedStatement 物件
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
    /*
     * <2> 配置校驗
     * 因為入參定義了 ResultHandler 結果處理器，所以如果不是存盤程序，且沒有配置回傳結果的 Java Type，則會拋出例外
     */
    if (!StatementType.CALLABLE.equals(ms.getStatementType())
            && void.class.equals(ms.getResultMaps().get(0).getType())) {
        throw new BindingException(
                "method " + command.getName() + " needs either a @ResultMap annotation, a @ResultType annotation,"
                        + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
    }
    // <3> 獲取引數名稱與入參的映射
    Object param = method.convertArgsToSqlCommandParam(args);
    // <4> 執行資料庫查詢操作
    if (method.hasRowBounds()) { // <4.1> 入參定義了 RowBounds 分頁物件
      // <4.1.1> 獲取入參定義了 RowBounds 分頁物件
        RowBounds rowBounds = method.extractRowBounds(args);
        // <4.1.2> 執行查詢
        sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
    } else {
      // <4.2> 執行查詢
        sqlSession.select(command.getName(), param, method.extractResultHandler(args));
    }
}
  1. 獲得 MappedStatement 物件
  2. 配置校驗，因為入參定義了 ResultHandler 結果處理器，所以如果不是存盤程序，且沒有配置回傳結果的 Java Type，則會拋出例外
  3. 獲取引數名稱與入參的映射
  4. 執行資料庫查詢操作
    1. 入參定義了 RowBounds 分頁物件，則獲取該物件，然后執行查詢，傳入分析物件
    2. 沒有定義則執行執行查詢

executeForMany方法

executeForMany(SqlSession sqlSession, Object[] args)方法，執行查詢，回傳串列，方法如下：

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    // 獲取引數名稱與入參的映射
    Object param = method.convertArgsToSqlCommandParam(args);
    // 執行資料庫查詢操作
    if (method.hasRowBounds()) {
        RowBounds rowBounds = method.extractRowBounds(args);
        // 執行查詢，回傳 List 集合
        result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      // 執行查詢，回傳 List 集合
        result = sqlSession.selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    // 封裝 Array 或 Collection 結果
    if (!method.getReturnType().isAssignableFrom(result.getClass())) { // 如果不是 List 集合型別
        if (method.getReturnType().isArray()) {
          	// 將 List 轉換成 Array 陣列型別的結果
            return convertToArray(result);
        } else {
          	// 轉換成其他 Collection 集合型別的結果
            return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
        }
    }
    // 直接回傳 List 集合型別的結果
    return result;
}
  1. 獲取引數名稱與入參的映射
  2. 執行資料庫查詢操作，獲取到 List 集合結果
  3. 根據回傳結果的型別進行轉換
    1. 如果是 Array 陣列型別，則將 List 轉換成 Array 陣列型別的結果
    2. 如果是其他集合型別，則將 List 轉換成其他 Collection 集合型別的結果
    3. 否則直接回傳 List 集合型別的結果

executeForMap方法

executeForMap(SqlSession sqlSession, Object[] args)方法，執行查詢，回傳Map，方法如下：

private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
    Map<K, V> result;
    // 獲取引數名稱與入參的映射
    Object param = method.convertArgsToSqlCommandParam(args);
    // 執行 SELECT 操作
    if (method.hasRowBounds()) {
        RowBounds rowBounds = method.extractRowBounds(args);
  		// 執行查詢，回傳 Map 集合
        result = sqlSession.selectMap(command.getName(), param, method.getMapKey(), rowBounds);
    } else {
  		// 執行查詢，回傳 Map 集合
        result = sqlSession.selectMap(command.getName(), param, method.getMapKey());
    }
    return result;
}
  1. 獲取引數名稱與入參的映射
  2. 執行查詢，回傳 Map 集合

總結

本分分析了 SqlSession 會話在 MyBatis 中是如何被創建，如何獲取到 Mapper 介面的動態代理物件，通過該動態代理物件是如何執行 SQL 的

  1. SqlSessionFactoryBuilder構造器提供build方法，根據mybatis-config.xml組態檔對 MyBatis 進行初始化，生成Configuration物件，用于構建一個DefaultSqlSessionFactory物件

  2. 通過1生成的 SqlSession 工廠物件，我們可以構建一個DefaultSqlSession會話物件，通過這個會話物件的getMapper(Class<T> mapper)方法，可以為 Mapper 介面創建一個動態代理物件（JDK動態代理），其動態代理類為MapperProxy物件

  3. 呼叫 Mapper 介面的某個方法時，會進入相應的MapperProxy代理類，根據方法對應的MapperMethod物件，執行資料庫操作

  4. 執行資料庫相關操作，呼叫的就是上面的DefaultSqlSession會話物件的相關方法，該會話內部則會通過Executor執行器去執行資料庫的相關操作，并回傳執行結果

好了，對于 MyBatis 整體上所有的內容已經全部分析完了，相信大家對 MyBatis 有了一個全面認識，其中肯定有不對或者迷惑的地方，歡迎指正！！！感謝大家的閱讀！！！??????

參考文章：芋道原始碼《精盡 MyBatis 原始碼分析》

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/227878.html

標籤：Java

上一篇：Java8 Stream：2萬字20個實體，玩轉集合的篩選、歸約、分組、聚合

下一篇：pycharm 完成pull，push，建立分支更新github代碼

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂