本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

听说你没有见过我

572

文章

279037

访问

+关注

分类

暂无分类

日期归档

暂无数据

Mybatis源码剖析：传统开发方式源码剖析

发布于2021-05-29 22:18 阅读(1381) 评论(0) 点赞(5) 收藏(5)

Mybatis源码剖析：传统开发方式源码剖析

1、源码剖析-初始化

Inputstream inputstream = Resources.getResourceAsStream("mybatisconfig.xml");
//这一行代码正是初始化工作的开始。
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

进入源码分析：

// 1.我们最初调用的build
public SqlSessionFactory build (InputStream inputStream){
    //调用了重载方法
    return build(inputStream, null, null);
}

// 2.调用的重载方法
public SqlSessionFactory build (InputStream inputStream, String environment, Properties properties){
    try {
        // XMLConfigBuilder是专门解析mybatis的配置文件的类
        XMLConfigBuilder parser = new XMLConfigBuilder(inputstream,
        environment, properties);
        //这里又调用了一个重载方法。parser.parse()的返回值是Configuration对象
        return build(parser.parse());
    } catch (Exception e) {
    	throw ExceptionFactory.wrapException("Error buildingSqlSession.", e)
    }
}

MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用 org.apache.ibatis.session.Configuration 实例来维护

下面进入对配置文件解析部分：

首先对Configuration对象进行介绍：

Configuration对象的结构和xml配置文件的对象几乎相同。

回顾一下xml中的配置标签有哪些：
properties (属性)，settings (设置)，typeAliases (类型别名)，typeHandlers (类型处理器)，objectFactory (对象工厂)，mappers (映射器)等Configuration也有对应的对象属性来封装它们
也就是说初始化配置文件信息的本质就是创建Configuration对象，将解析的xml数据封装到Configuration内部属性中。

/**
* 解析 XML 成 Configuration 对象。
*/
public Configuration parse () {
    //若已解析，抛出BuilderException异常
    if (parsed) {
    	throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    //标记已解析
    parsed = true;
    // 解析 XML configuration 节点
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

    /**
    *解析XML
    */
private void parseConfiguration (XNode root){
    try {
        //issue #117 read properties first
        // 解析 <properties /> 标签
        propertiesElement(root.evalNode("properties"));
        // 解析〈settings /> 标签
        Properties settings =
        settingsAsProperties(root.evalNode("settings"));
        //加载自定义的VFS实现类
        loadCustomVfs(settings);
        // 解析 <typeAliases /> 标签
        typeAliasesElement(root.evalNode("typeAliases"));
        //解析<plugins />标签
        pluginElement(root.evalNode("plugins"));
        // 解析 <objectFactory /> 标签
        objectFactoryElement(root.evalNode("objectFactory"));
        // 解析 <objectWrapperFactory /> 标签
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        // 解析 <reflectorFactory /> 标签
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        // 赋值 <settings /> 至 Configuration 属性
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue
        #631
        // 解析〈environments /> 标签
        environmentsElement(root.evalNode("environments"));
        // 解析 <databaseIdProvider /> 标签
        databaseldProviderElement(root.evalNode("databaseldProvider"));
        // 解析 <typeHandlers /> 标签
        typeHandlerElement(root.evalNode("typeHandlers"));
        //解析<mappers />标签
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
    	throw new BuilderException("Error parsing SQL Mapper Configuration.Cause:" + e, e);
    }
}

介绍一下 MappedStatement ：

作用：MappedStatement与Mapper配置文件中的一个select/update/insert/delete节点相对应。

mapper中配置的标签都被封装到了此对象中，主要用途是描述一条SQL语句。

初始化过程：回顾刚开始介绍的加载配置文件的过程中，会对mybatis-config.xm l中的各个标签都进行解析，其中有mappers 标签用来引入mapper.xml文件或者配置mapper接口的目录。

<select id="getUser" resultType="user" >
	select * from user where id=#{id}
</select>

样的一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在 Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key =全限定类名+方法名，value =对应的MappedStatement对象。

在configuration中对应的属性为

Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");

在 XMLConfigBuilder 中的处理：

private void parseConfiguration(XNode root) {
    try {
        //省略其他标签的处理
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
    	throw new BuilderException("Error parsing SQL Mapper Configuration.Cause:" + e, e);
    }
}

到此对xml配置文件的解析就结束了，回到上述重载build方法

// 5.调用的重载方法
public SqlSessionFactory build(Configuration config) {
    //创建了 DefaultSqlSessionFactory 对象，传入 Configuration 对象。
    return new DefaultSqlSessionFactory(config);
}

2、源码剖析-执行SQL流程

先简单介绍**SqlSession **：

SqlSession是一个接口，它有两个实现类：DefaultSqlSession (默认)和 SqlSessionManager (弃用，不做介绍)

SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一个 SqlSession,并且在使用完毕后需要close

public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;
    private final Executor executor;
    ...
}

SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器

Executor：

Executor也是一个接口，他有三个常用的实现类：

BatchExecutor (重用语句并执行批量更新)
ReuseExecutor (重用预处理语句 prepared statements)
SimpleExecutor (普通的执行器，默认)

继续分析，初始化完毕后，我们就要执行SQL 了

SqlSession sqlSession = factory.openSession();
List<User> list = sqlSession.selectList("com.tao.mapper.UserMapper.getUserByName");

获得 sqlSession

//6. 进入 o penSession 方法。
public SqlSession openSession() {
    //getDefaultExecutorType()传递的是SimpleExecutor
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

//7. 进入penSessionFromDataSource。
//ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，autoCommit是否开启事务
//openSession的多个重载方法可以指定获得的SeqSession的Executor类型和事务的处理
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try{
        final Environment environment = configuration.getEnvironment();
        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){
        closeTransaction(tx); // may have fetched a connection so lets call
        close()
    }
}

执行 sqlsession 中的 api

//8.进入selectList方法，多个重载方法。
public <E > List < E > selectList(String statement) {
	return this.selectList(statement, null);
}

public <E > List < E > selectList(String statement, Object parameter) {
	return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
public <E > List < E > selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        //根据传入的全限定名+方法名从映射的Map中取出MappedStatement对象
        MappedStatement ms = configuration.getMappedStatement(statement);
        //调用Executor中的方法处理
        //RowBounds是用来逻辑分页
        // wrapCollection(parameter)是用来装饰集合或者数组参数
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
		throw ExceptionFactory.wrapException("Error queryingdatabase. Cause: + e, e);
	} finally {
		ErrorContext.instance().reset();
	}
}

3、源码剖析-executor

继续源码中的步骤，进入executor.query()

//此方法在SimpleExecutor的父类BaseExecutor中实现
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示
    BoundSql boundSql = ms.getBoundSql(parameter);
    //为本次查询创建缓存的Key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

//进入query的重载方法中
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.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
    	clearLocalCache();
    }
    List<E> list;
    try {
        queryStack++;
        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;
}

//从数据库查询
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;
}

// SimpleExecutor中实现父类的doQuery抽象方法
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();
        //传入参数创建StatementHanlder对象来执行查询
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds,
        resultHandler, boundSql);
        //创建jdbc中的statement对象
        stmt = prepareStatement(handler, ms.getStatementLog());
        // StatementHandler 进行处理
        return handler.query(stmt, resultHandler);
    } finally {
    	closeStatement(stmt);
    }
}

//创建Statement的方法
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //条代码中的getConnection方法经过重重调用最后会调用openConnection方法，从连接池中
    获 得连接。
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
}

//从连接池获得连接的方法
protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {
    	log.debug("Opening JDBC Connection");
    }
    //从连接池获得连接
    connection = dataSource.getConnection();
    if (level != null) {
    	connection.setTransactionIsolation(level.getLevel());
    }
}

上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能和作用是：

根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；
为查询创建缓存，以提高性能
创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果。

4、源码剖析-StatementHandler

StatementHandler对象主要完成两个工作：

对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符，我们其后再对占位符进行设值。StatementHandler通过 parameterize(statement)方法对 S tatement 进行设值；
StatementHandler 通过 List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；

进入到 StatementHandler 的 parameterize(statement)方法的实现：

public void parameterize(Statement statement) throws SQLException {
    //使用ParameterHandler对象来完成对Statement的设值
    parameterHandler.setParameters((PreparedStatement) statement);
}

/** ParameterHandler 类的 setParameters(PreparedStatement ps) 实现
* 对某一个Statement进行设置参数
* */
public void setParameters(PreparedStatement ps) throws SQLException {
    ErrorContext.instance().activity("settingparameters").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); 
                }
                // 每一个 Mapping都有一个 TypeHandler，根据 TypeHandler 来对
                preparedStatement 进 行设置参数
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if (value == null && jdbcType == null) jdbcType =
                configuration.getJdbcTypeForNull();
                //设置参数
                typeHandler.setParameter(ps, i + 1, value, jdbcType);
            }
    	}
    }
}

从上述的代码可以看到,StatementHandler的parameterize(Statement)方法调用了ParameterHandler的setParameters(statement)方法，ParameterHandler的setParameters(Statement )方法负责根据我们输入的参数，对statement对象的 ? 占位符处进行赋值。

进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的实现：

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    // 1.调用preparedStatemnt。execute()方法，然后将resultSet交给ResultSetHandler处理
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //2.使用 ResultHandler 来处理 ResultSet
    return resultSetHandler.<E> handleResultSets(ps);
}

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了 ResultSetHandler 的 handleResultSets(Statement)方法。

ResultSetHandler 的 handleResultSets(Statement)方法会将 Statement 语句执行后生成的 resultSet 结果集转换成List结果集。

public List<Object> handleResultSets(Statement stmt) throws SQLException {
	ErrorContext.instance().activity("handlingresults").object(mappedStatement.getId());
	//多ResultSet的结果集合，每个ResultSet对应一个Object对象。而实际上，每个 Object 是List<Object> 对象。
	//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也就是说，multipleResults最多就一个元素。
	final List<Object> multipleResults = new ArrayList<>();
	int resultSetCount = 0;
	//获得首个ResultSet对象，并封装成ResultSetWrapper对象
	ResultSetWrapper rsw = getFirstResultSet(stmt);
	//获得ResultMap数组
	//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也 就是说，resultMaps就一个元素。
	List<ResultMap> resultMaps = mappedStatement.getResultMaps();
	int resultMapCount = resultMaps.size();
	validateResultMapsCount(rsw, resultMapCount); // 校验
	while (rsw != null && resultMapCount > resultSetCount) {
		//获得ResultMap对象
		ResultMap resultMap = resultMaps.get(resultSetCount);
		//处理ResultSet，将结果添加到multipleResults中
		handleResultSet(rsw, resultMap, multipleResults, null);
		//获得下一个ResultSet对象，并封装成ResultSetWrapper对象
		rsw = getNextResultSet(stmt);
		//清理
		cleanUpAfterHandlingResultSet();
		// resultSetCount ++
		resultSetCount++;
	}
    
	//因为'mappedStatement.resultSets'只在存储过程中使用，本系列暂时不考虑，忽略即可
	String[] resultSets = mappedStatement.getResultSets();
	if(resultSets!=null){
		while (rsw != null && resultSetCount < resultSets.length) {
			ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
			if (parentMapping != null) {
				String nestedResultMapId = parentMapping.getNestedResultMapId();
				ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
				handleResultSet(rsw, resultMap, null, parentMapping);
			}
			rsw = getNextResultSet(stmt);
			cleanUpAfterHandlingResultSet();
			resultSetCount++;
		}
	}
	//如果是multipleResults单元素，则取首元素返回
	return collapseSingleResultList(multipleResults);
}