终结篇：MyBatis原理深入解析（一）

最新推荐文章于 2024-08-01 21:59:20 发布
置顶 最新推荐文章于 2024-08-01 21:59:20 发布
阅读量451 收藏
点赞数

MyBatis框架整体设计

MyBatis框架整体设计

5.1 接口层-和数据库交互的方式

MyBatis和数据库的交互有两种方式：

  1. 使用传统的MyBatis提供的API；

  2. 使用Mapper接口；

5.1.1 使用传统的MyBatis提供的API

这是传统的传递Statement Id 和查询参数给 SqlSession 对象，使用 SqlSession对象完成和数据库的交互；MyBatis提供了非常方便和简单的API，供用户实现对数据库的增删改查数据操作，以及对数据库连接信息和MyBatis 自身配置信息的维护操作。

传统的MyBatis工作模式

上述使用MyBatis 的方法，是创建一个和数据库打交道的SqlSession对象，然后根据Statement Id 和参数来操作数据库，这种方式固然很简单和实用，但是它不符合面向对象语言的概念和面向接口编程的编程习惯。由于面向接口的编程是面向对象的大趋势，MyBatis 为了适应这一趋势，增加了第二种使用MyBatis 支持接口（Interface）调用方式。

5.1.2 使用Mapper接口

MyBatis 将配置文件中的每一个<mapper> 节点抽象为一个 Mapper 接口：

这个接口中声明的方法和<mapper> 节点中的<select|update|delete|insert> 节点项对应，即<select|update|delete|insert> 节点的id值为Mapper 接口中的方法名称，parameterType 值表示Mapper 对应方法的入参类型，而resultMap 值则对应了Mapper 接口表示的返回值类型或者返回结果集的元素类型。

Mapper接口和Mapper.xml配置文件之间的对应关系

根据MyBatis 的配置规范配置好后，通过SqlSession.getMapper(XXXMapper.class)方法，MyBatis 会根据相应的接口声明的方法信息，通过动态代理机制生成一个Mapper 实例，我们使用Mapper接口的某一个方法时，MyBatis会根据这个方法的方法名和参数类型，确定Statement Id，底层还是通过SqlSession.select("statementId",parameterObject);或者SqlSession.update("statementId",parameterObject); 等等来实现对数据库的操作，MyBatis引用Mapper 接口这种调用方式，纯粹是为了满足面向接口编程的需要。（其实还有一个原因是在于，面向接口的编程，使得用户在接口上可以使用注解来配置SQL语句，这样就可以脱离XML配置文件，实现“0配置”）。

5.2 数据处理层

数据处理层可以说是MyBatis的核心，从大的方面上讲，它要完成两个功能：

  1. 通过传入参数构建动态SQL语句；

  2. SQL语句的执行以及封装查询结果集成List<E>；

5.2.1 参数映射和动态SQL语句生成

动态语句生成可以说是MyBatis框架非常优雅的一个设计，MyBatis 通过传入的参数值，使用 Ognl 来动态地构造SQL语句，使得MyBatis 有很强的灵活性和扩展性。

参数映射指的是对于java 数据类型和jdbc数据类型之间的转换：这里有包括两个过程：查询阶段，我们要将java类型的数据，转换成jdbc类型的数据，通过 preparedStatement.setXXX() 来设值；另一个就是对resultset查询结果集的jdbcType 数据转换成java 数据类型。

5.2.2 SQL语句的执行以及封装查询结果集成List<E>

动态SQL语句生成之后，MyBatis 将执行SQL语句，并将可能返回的结果集转换成List<E> 列表。MyBatis 在对结果集的处理中，支持结果集关系一对多和多对一的转换，并且有两种支持方式，一种为嵌套查询语句的查询，还有一种是嵌套结果集的查询。

5.3 框架支撑层

  1. 事务管理机制

    事务管理机制对于ORM框架而言是不可缺少的一部分，事务管理机制的质量也是考量一个ORM框架是否优秀的一个标准。

  2. 连接池管理机制

    由于创建一个数据库连接所占用的资源比较大，对于数据吞吐量大和访问量非常大的应用而言，连接池的设计就显得非常重要。

  3. 缓存机制

    为了提高数据利用率和减小服务器和数据库的压力，MyBatis 会对于一些查询提供会话级别的数据缓存，会将对某一次查询，放置到SqlSession 中，在允许的时间间隔内，对于完全相同的查询，MyBatis会直接将缓存结果返回给用户，而不用再到数据库中查找。

  4. SQL语句的配置方式

    传统的MyBatis 配置SQL语句方式就是使用XML文件进行配置的，但是这种方式不能很好地支持面向接口编程的理念，为了支持面向接口的编程，MyBatis 引入了Mapper接口的概念，面向接口的引入，对使用注解来配置SQL语句成为可能，用户只需要在接口上添加必要的注解即可，不用再去配置XML文件了，但是，目前的MyBatis 只是对注解配置SQL语句提供了有限的支持，某些高级功能还是要依赖XML配置文件配置SQL 语句。

5.4 引导层

引导层是配置和启动MyBatis配置信息的方式。MyBatis 提供两种方式来引导MyBatis ：基于XML配置文件的方式和基于Java API 的方式。

5.5 主要构件及其相互关系

从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个：

SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能；

Executor：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护；

StatementHandler：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。

ParameterHandler：负责对用户传递的参数转换成JDBC Statement 所需要的参数；

ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；

TypeHandler：负责java数据类型和jdbc数据类型之间的映射和转换；

MappedStatement：MappedStatement维护了一条<select|update|delete|insert>节点的封装；

SqlSource：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回；

BoundSql：表示动态生成的SQL语句以及相应的参数信息；

Configuration：MyBatis所有的配置信息都维持在Configuration对象之中；

它们的关系如下图所示：

MyBatis主要构件关系如图

6 SqlSession工作过程分析

  1. 开启一个数据库访问会话---创建SqlSession对象

    SqlSession sqlSession = factory.openSession();

    MyBatis封装了对数据库的访问，把对数据库的会话和事务控制放到了SqlSession对象中

  2. 为SqlSession传递一个配置的Sql语句的Statement Id和参数，然后返回结果：

    List<Employee> result = sqlSession.selectList("com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary",params);

    上述的"com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary"，是配置在EmployeesMapper.xml 的Statement ID，params是传递的查询参数。

    让我们来看一下sqlSession.selectList()方法的定义：

    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 {  
      //1.根据Statement Id，在mybatis 配置对象Configuration中查找和配置文件相对应的MappedStatement      
      MappedStatement ms = configuration.getMappedStatement(statement);  
      //2. 将查询任务委托给MyBatis 的执行器 Executor  
      List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);  
      return result;  
  } catch (Exception e) {  
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);  
  } finally {  
      ErrorContext.instance().reset();  
  }  
}

    MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护。使用者可以使用sqlSession.getConfiguration()方法来获取。MyBatis的配置文件中配置信息的组织格式和内存中对象的组织格式几乎完全对应的。

    上述例子中的：

    <select id="selectByMinSalary" resultMap="BaseResultMap" parameterType="java.util.Map" >  
 select   
     EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, SALARY  
 from LOUIS.EMPLOYEES  
 <if test="min_salary != null">  
     where SALARY < #{min_salary,jdbcType=DECIMAL}  
 </if>  
</select>

    加载到内存中会生成一个对应的MappedStatement对象，然后会以key="com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary" ，value为MappedStatement对象的形式维护到Configuration的一个Map中。当以后需要使用的时候，只需要通过Id值来获取就可以了。

    从上述的代码中我们可以看到SqlSession的职能是：SqlSession根据Statement ID, 在mybatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用mybatis执行器来执行具体的操作。

  3. MyBatis执行器Executor根据SqlSession传递的参数执行query()方法（由于代码过长，读者只需阅读我注释的地方即可）：

    /** 
 * BaseExecutor 类部分代码 
 * 
 */  
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 1. 根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示    
    BoundSql boundSql = ms.getBoundSql(parameter);  
    // 2. 为当前的查询创建一个缓存Key  
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);  
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);  
}  

@SuppressWarnings("unchecked")  
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 {  
             // 3.缓存中没有值，直接从数据库中读取数据    
             list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);  
         }  
     } finally {  
         queryStack--;  
     }  
     if (queryStack == 0) {  
         for (DeferredLoad deferredLoad : deferredLoads) {  
             deferredLoad.load();  
         }  
         deferredLoads.clear(); // issue #601  
         if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {  
             clearLocalCache(); // issue #482  
         }  
     }  
     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 {  

        //4. 执行查询，返回List 结果，然后    将查询的结果放入缓存之中  
        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();  
        //5. 根据既有的参数，创建StatementHandler对象来执行查询操作  
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);  
        //6. 创建java.Sql.Statement对象，传递给StatementHandler对象  
        stmt = prepareStatement(handler, ms.getStatementLog());  
        //7. 调用StatementHandler.query()方法，返回List结果集  
        return handler.<E>query(stmt, resultHandler);  
     } finally {  
         closeStatement(stmt);  
     }  
}

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

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

    1. 根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；

    2. 为查询创建缓存，以提高性能；

    3. 创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果；

  4. StatementHandler对象负责设置Statement对象中的查询参数、处理JDBC返回的resultSet，将resultSet加工为List 集合返回：

    接着上面的Executor第六步，看一下：prepareStatement() 方法的实现：

    /** 
 * 
 * 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(); 
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); 
        // 1.准备Statement对象，并设置Statement对象的参数 
        stmt = prepareStatement(handler, ms.getStatementLog()); 
        // 2. StatementHandler执行query()方法，返回List结果 
        return handler.<E>query(stmt, resultHandler); 
    } finally {
        closeStatement(stmt); 
    } 
}  

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;  
    Connection connection = getConnection(statementLog);  
    stmt = handler.prepare(connection);  
    //对创建的Statement对象设置参数，即设置SQL 语句中 ? 设置为指定的参数  
    handler.parameterize(stmt);  
    return stmt;  
}

    以上我们可以总结StatementHandler对象主要完成两个工作：

    1. 对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含 若干个? 占位符，我们其后再对占位符进行设值。
      StatementHandler通过parameterize(statement)方法对Statement进行设值；

    2. StatementHandler通过List<E> query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；

  5. StatementHandler 的parameterize(statement) 方法的实现：

    /** 
 * 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("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);  
                }  

                // 每一个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对象的 ? 占位符处进行赋值。

  6. StatementHandler 的List<E> query(Statement statement, ResultHandler resultHandler)方法的实现：

    /** 
  * PreParedStatement类的query方法实现 
  */  
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<E> query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了ResultSetHandler的handleResultSets(Statement) 方法。ResultSetHandler的handleResultSets(Statement) 方法会将Statement语句执行后生成的resultSet 结果集转换成List<E> 结果集：

    /**   
 * ResultSetHandler类的handleResultSets()方法实现 
 *  
 */  
public List<Object> handleResultSets(Statement stmt) throws SQLException {  
    final List<Object> multipleResults = new ArrayList<Object>();  

    int resultSetCount = 0;  
    ResultSetWrapper rsw = getFirstResultSet(stmt);  

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();  
    int resultMapCount = resultMaps.size();  
    validateResultMapsCount(rsw, resultMapCount);  

    while (rsw != null && resultMapCount > resultSetCount) {  
        ResultMap resultMap = resultMaps.get(resultSetCount);  

        //将resultSet  
        handleResultSet(rsw, resultMap, multipleResults, null);  
        rsw = getNextResultSet(stmt);  
        cleanUpAfterHandlingResultSet();  
        resultSetCount++;  
    }

    String[] resultSets = mappedStatement.getResulSets();  
    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++;  
        }  
    }  

    return collapseSingleResultList(multipleResults);  
}

7 MyBatis初始化机制

7.1 MyBatis的初始化做了什么

任何框架的初始化，无非是加载自己运行时所需要的配置信息。MyBatis的配置信息，大概包含以下信息，其高层级结构如下：


MyBatis配置信息结构图

MyBatis的上述配置信息会配置在XML配置文件中，那么，这些信息被加载进入MyBatis内部，MyBatis是怎样维护的呢？

MyBatis采用了一个非常直白和简单的方式---使用 org.apache.ibatis.session.Configuration对象作为一个所有配置信息的容器，Configuration对象的组织结构和XML配置文件的组织结构几乎完全一样（当然，Configuration对象的功能并不限于此，它还负责创建一些MyBatis内部使用的对象，如Executor等，这将在后续的文章中讨论）。如下图所示：


Configuration对象的组织结构和XML配置文件的组织结构几乎完全一样

MyBatis根据初始化好Configuration信息，这时候用户就可以使用MyBatis进行数据库操作了。可以这么说，MyBatis初始化的过程，就是创建 Configuration对象的过程。

MyBatis的初始化可以有两种方式：

基于XML配置文件：基于XML配置文件的方式是将MyBatis的所有配置信息放在XML文件中，MyBatis通过加载并XML配置文件，将配置文信息组装成内部的Configuration对象。

基于Java API：这种方式不使用XML配置文件，需要MyBatis使用者在Java代码中，手动创建Configuration对象，然后将配置参数set 进入Configuration对象中。

接下来我们将通过 基于XML配置文件方式的MyBatis初始化，深入探讨MyBatis是如何通过配置文件构建Configuration对象，并使用它。

7.2 基于XML配置文件创建Configuration对象

现在就从使用MyBatis的简单例子入手，深入分析一下MyBatis是怎样完成初始化的，都初始化了什么。看以下代码：

String resource = "mybatis-config.xml";  
InputStream inputStream = Resources.getResourceAsStream(resource);  
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
SqlSession sqlSession = sqlSessionFactory.openSession();  
List list = sqlSession.selectList("com.foo.bean.BlogMapper.queryAllBlogInfo");

有过MyBatis使用经验的读者会知道，上述语句的作用是执行com.foo.bean.BlogMapper.queryAllBlogInfo 定义的SQL语句，返回一个List结果集。总的来说，上述代码经历了mybatis初始化 -->创建SqlSession -->执行SQL语句返回结果三个过程。

上述代码的功能是根据配置文件mybatis-config.xml 配置文件，创建SqlSessionFactory对象，然后产生SqlSession，执行SQL语句。而mybatis的初始化就发生在第三句：SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 现在就让我们看看第三句到底发生了什么。

  1. MyBatis初始化基本过程：

    SqlSessionFactoryBuilder根据传入的数据流生成Configuration对象，然后根据Configuration对象创建默认的SqlSessionFactory实例。

    初始化的基本过程如下序列图所示：


    MyBatis初始化序列图

    由上图所示，mybatis初始化要经过简单的以下几步：

    1. 调用SqlSessionFactoryBuilder对象的build(inputStream)方法；

    2. SqlSessionFactoryBuilder会根据输入流inputStream等信息创建XMLConfigBuilder对象;

    3. SqlSessionFactoryBuilder调用XMLConfigBuilder对象的parse()方法；

    4. XMLConfigBuilder对象返回Configuration对象；

    5. SqlSessionFactoryBuilder根据Configuration对象创建一个DefaultSessionFactory对象；

    6. SqlSessionFactoryBuilder返回 DefaultSessionFactory对象给Client，供Client使用。

    SqlSessionFactoryBuilder相关的代码如下所示：

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

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties)  {  
    try  {  
        //2. 创建XMLConfigBuilder对象用来解析XML配置文件，生成Configuration对象  
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);  
        //3. 将XML配置文件内的信息解析成Java对象Configuration对象  
        Configuration config = parser.parse();  
        //4. 根据Configuration对象创建出SqlSessionFactory对象  
        return build(config);  
    } 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.  
        }  
    }
}

// 从此处可以看出，MyBatis内部通过Configuration对象来创建SqlSessionFactory,用户也可以自己通过API构造好Configuration对象，调用此方法创SqlSessionFactory  
public SqlSessionFactory build(Configuration config) {  
    return new DefaultSqlSessionFactory(config);  
}

    上述的初始化过程中，涉及到了以下几个对象：

    SqlSessionFactoryBuilder ：SqlSessionFactory的构造器，用于创建SqlSessionFactory，采用了Builder设计模式

    Configuration ：该对象是mybatis-config.xml文件中所有mybatis配置信息

    SqlSessionFactory：SqlSession工厂类，以工厂形式创建SqlSession对象，采用了Factory工厂设计模式

    XmlConfigParser ：负责将mybatis-config.xml配置文件解析成Configuration对象，共SqlSessonFactoryBuilder使用，创建SqlSessionFactory

  2. 创建Configuration对象的过程：
    接着上述的 MyBatis初始化基本过程讨论，当SqlSessionFactoryBuilder执行build()方法，调用了XMLConfigBuilder的parse()方法，然后返回了Configuration对象。那么parse()方法是如何处理XML文件，生成Configuration对象的呢？

    • （1）XMLConfigBuilder会将XML配置文件的信息转换为Document对象，而XML配置定义文件DTD转换成XMLMapperEntityResolver对象，然后将二者封装到XpathParser对象中，XpathParser的作用是提供根据Xpath表达式获取基本的DOM节点Node信息的操作。如下图所示：


      XpathParser组成结构图和生成图

    • （2）之后XMLConfigBuilder调用parse()方法：会从XPathParser中取出 <configuration>节点对应的Node对象，然后解析此Node节点的子Node：properties, settings, typeAliases,typeHandlers, objectFactory, objectWrapperFactory, plugins, environments,databaseIdProvider, mappers：

      public Configuration parse() {  
    if (parsed) {  
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");  
    }  
    parsed = true;  
    //源码中没有这一句，只有parseConfiguration(parser.evalNode("/configuration"));  
    //为了让读者看得更明晰，源码拆分为以下两句  
    XNode configurationNode = parser.evalNode("/configuration");  
    parseConfiguration(configurationNode);  
    return configuration;
}
/** 
 * 解析 "/configuration"节点下的子节点信息，然后将解析的结果设置到Configuration对象中 
 */  
private void parseConfiguration(XNode root) {  
    try {  
        //1.首先处理properties 节点     
        propertiesElement(root.evalNode("properties")); //issue #117 read properties first  
        //2.处理typeAliases  
        typeAliasesElement(root.evalNode("typeAliases"));  
        //3.处理插件  
        pluginElement(root.evalNode("plugins"));  
        //4.处理objectFactory  
        objectFactoryElement(root.evalNode("objectFactory"));  
        //5.objectWrapperFactory  
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));  
        //6.settings  
        settingsElement(root.evalNode("settings"));  
        //7.处理environments  
        environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631  
        //8.database  
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));  
        //9.typeHandlers  
        typeHandlerElement(root.evalNode("typeHandlers"));  
        //10.mappers  
        mapperElement(root.evalNode("mappers"));  
    } catch (Exception e) {  
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);  
    }  
}

      注意：在上述代码中，还有一个非常重要的地方，就是解析XML配置文件子节点<mappers>的方法mapperElements(root.evalNode("mappers")), 它将解析我们配置的Mapper.xml配置文件，Mapper配置文件可以说是MyBatis的核心，MyBatis的特性和理念都体现在此Mapper的配置和设计上。

    • （3）然后将这些值解析出来设置到Configuration对象中：

      解析子节点的过程这里就不一一介绍了，用户可以参照MyBatis源码仔细揣摩，我们就看上述的environmentsElement(root.evalNode("environments")); 方法是如何将environments的信息解析出来，设置到Configuration对象中的：

      /** 
 * 解析environments节点，并将结果设置到Configuration对象中 
 * 注意：创建envronment时，如果SqlSessionFactoryBuilder指定了特定的环境（即数据源）； 
 *      则返回指定环境（数据源）的Environment对象，否则返回默认的Environment对象； 
 *      这种方式实现了MyBatis可以连接多数据源 
 */  
private void environmentsElement(XNode context) throws Exception {  
   if (context != null)  
   {  
        if (environment == null)  
        {  
            environment = context.getStringAttribute("default");  
        }  
        for (XNode child : context.getChildren())  
        {  
             String id = child.getStringAttribute("id");  
             if (isSpecifiedEnvironment(id))  
             {  
                 //1.创建事务工厂 TransactionFactory  
                 TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));  
                 DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));  
                 //2.创建数据源DataSource  
                 DataSource dataSource = dsFactory.getDataSource();  
                 //3. 构造Environment对象  
                 Environment.Builder environmentBuilder = new Environment.Builder(id)  
            .transactionFactory(txFactory)  
            .dataSource(dataSource);  
                 //4. 将创建的Envronment对象设置到configuration 对象中  
                 configuration.setEnvironment(environmentBuilder.build());  
            }  
        }  
   }  
}
      private boolean isSpecifiedEnvironment(String id)  
{  
    if (environment == null)  
    {  
         throw new BuilderException("No environment specified.");  
    }  
    else if (id == null)  
    {  
         throw new BuilderException("Environment requires an id attribute.");  
    }  
    else if (environment.equals(id))  
    {  
        return true;  
    }  
    return false;  
}

    • （4）返回Configuration对象：

      将上述的MyBatis初始化基本过程的序列图细化：


      基于XML配置创建Configuration对象的过程


作者：陶邦仁
链接：http://www.jianshu.com/p/ec40a82cae28
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
bwh0520
关注
Mybatis整体架构设计介绍
阳仔的博客
03-13 570
一、整体结构 下面是从功能流程层次描述MyBatis的整体架构图 而下面是MyBatis源码包对应的架构图 下面以“功能流程角度的架构图”来简要地分析下各层的架构，在后面系列文章中将有专题来深入解析MyBatis重要的功能点。 1、接口层 我们知道，在不考虑与Spring集成的情况下,使用MyBatis执行数据库操作的代码如下 String resource = “org/mybatis/ex...
终结篇：史上最全MyBatis源码深入解析底层原理实战
rexuejava的博客
07-09 1537
1 引言# 本文主要讲解JDBC怎么演变到Mybatis的渐变过程，重点讲解了为什么要将JDBC封装成Mybaits这样一个持久层框架。再而论述Mybatis作为一个数据持久层框架本身有待改进之处。 2 JDBC实现查询分析# 我们先看看我们最熟悉也是最基础的通过JDBC查询数据库数据，一般需要以下七个步骤： 加载JDBC驱动； 建立并获取数据库连接； 创建 JDBC Statements 对象； 设置SQL语句的传入参数； 执行SQL语句并获得查询结果； 对查询结果进行转换处理并将处理
《深入理解mybatis原理》 MyBatis的架构设计以及实例分析
热门推荐
我的程序人生(亦山札记)
11-04 17万+
MyBatis是目前非常流行的ORM框架，它的功能很强大，然而其实现却比较简单、优雅。本文主要讲述MyBatis的架构设计思路，并且讨论MyBatis的几个核心部件，然后结合一个select查询实例，深入代码，来探究MyBatis的实现。
MyBatis源码窥探:MyBatis整体架构解析
weixin_33850015的博客
12-20 313
Mybatis的使用这里就不介绍了，不知道怎么使用的朋友可以点击http://www.mybatis.org/mybatis-3/zh/index.html这里面的教程很详细，包括xml的配置、映射、动态sql都有介绍，可以学习和使用，本系列的文章将会更深入的了解MyBatis。1. ORM简介ORM（Object Relational Mapping）对象-关系映射框架，ORM的主要功能就是根据...
MyBatis框架整体设计
luzhensmart的专栏
10-16 263
5.1 接口层-和数据库交互的方式# MyBatis和数据库的交互有两种方式： 使用传统的MyBatis提供的API； 使用Mapper接口； 5.1.1 使用传统的MyBatis提供的API### 这是传统的传递Statement Id 和查询参数给 SqlSession 对象，使用 SqlSession对象完成和数据库的交互；MyBatis提供了非常方便和简单...
深入剖析 mybatis 原理（四）插件的原理和应用
ignore
12-22 1242
mybatis 插件原理
Java中高级面试题总览(一)
数据与算法架构提升之路专栏
03-29 2万+
高频面试题深入剖析
Java知识体系只这一篇就够了！
mufengru的博客
01-12 1221
虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。static一个很重要的用途就是实现单例设计模式，单例模式的特点是该类只能有一个实例,为了实现这一功能，必须隐藏类的构造函数,即把构造函数声明为private,并提供一个创建对象的方法,由于构造对象被声明为private,外界无法直接创建这个类型的对象,只能通过该类提供的方法来获取类的对象,要达到这样的目的只能把创建对象的方法声明为static.
网易面试Java开发凉凉经，面试官：基础不牢，技术不够深入，无缘offer，无缘网易......
程序员干货站
06-04 2093
前言 我也是经朋友介绍来的网易，先是投了简历，然后朋友通知我说可以面试了，于是我就带着忐忑的心理来到网易公司。面试的是一位帅气的光头叔叔，下午三点开始，之前准备了很多准备应付技术问答，结果基础还是太差了，无缘网易… 首先还是感谢吧，感谢网易面试官的肯定和建议。 网易一共经历了四轮面试，前三轮技术面，第四轮总监面。 岗位：我投递的是杭研所的Java开发岗位。 行程：半天的时间南京=杭州之间穿行，单程2个小时，从杭州东站=网易大厦，单程1个小时（如果能买到城站高铁动车票可以从城站触发。） 吃饭：可以去网易食
mybatis的整体架构
西风烈马
07-19 749
mybatis的整体架构分为三层： 1）基础支持层 该层包括：数据源模块、事务管理模块、缓存模块、Binding模块、反射模块、类型转换模块、日志模块、资源加载模块、解析器模块 2）核心处理层 该层包括：配置解析、参数映射、SQL解析、SQL执行、结果集映射、插件 3）接口层 该层包括：SqlSession...
原理分析之二：框架整体设计
我的IT博客
03-21 429
  1.引言 本文主要讲解Mybatis的整体程序设计，理清楚框架的主要脉络。后面文章我们再详细讲解各个组件。   2.整体设计 2.1 总体流程 (1)加载配置并初始化       触发条件：加载配置文件       配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执...
Mybatis 整体架构
CoderLi
04-02 971
Mybatis 分为三层架构 基础支撑层 核心处理层 接口层 基础支撑层 类型转换模块 微信公众号:CoderLi JDBC类型与 Java 类型之间的相互转换、不管是入参还是结果集的转换、都是这个模块职责。 还有一个功能就是类型别名、这个有点类似 Spring 的别名、为了引用的时候名称更加简短 日志模块 Mybatis 的日志模块通过适配器模式可以集成主流的各种日志框架、Log4J、Logback等 反射工具模块 Mybatis 的反射工具、如 MetaObject 提供了一些更加灵活的 API.
mybatis解读（一）——整体架构
qq_34777858的博客
07-19 1063
MyBatis整体架构分为三层：基础支持层、核心处理层、接口层。 基础支持层： 反射模块： 类型转换模块：MyBatis为简化配置文件提供了别名机制； 为SQL语句绑定实参以及映射查询结果集（实现JDBC类型与java类型之间的转换）都是类型转换模块的功能。 在为SQL绑定实参时将java类型转换成JDBC类型，在映射结果集时，会将数据由JDBC类型转换为java类型。 日志模块： ...
MyBatis--总体框架设计
m0_52675592的博客
04-29 346
文章目录MyBatis架构接口层--和数据库交互的方式使用传统的MyBatis提供的API使用Mapper接口数据处理层参数映射和动态SQL语句生成SQL语句的执行以及封装查询结果集成List框架支撑层引导层主要构件及其相互关系 MyBatis架构 MyBatis框架整体设计如下： 接口层–和数据库交互的方式 MyBatis和数据库的交互有两种方式： 使用传统的MyBatis提供的API 使用Mapper接口 使用传统的MyBatis提供的API 这是传统的传递Statement Id和查询参数给Sq
浅谈 Mybatis 框架
最新发布
m0_63191002的博客
08-01 4791
MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程(多条SQL语句的集合)以及高级映射。MyBatis 去除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的XML或注解来配置和映射原始类型、接口和Java POJO (Plain Old Java Objects,普通老式Java对象)为数据库中的记录。存储过程：高级映射：程序中的类对应数据库中的表，程序中的类里的属性对应数据库的表中的字段。
mybatis简介及框架设计
Stream_who的博客
12-19 569
一、基本概念 1. MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射 2. MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集 3. MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录 二、优缺点 1...
Mybatis整体架构
sinat_38430122的博客
03-14 573
mybatis整体架构分为三层，分别是基础支持层，核心处理层，接口层。1，基础支持层：基础支持层含有整个mybatis的基础模块，这些模块为核心处理层提供了良好的支撑。（1）反射模块：mybatis提供了反射模块，该模块对java原生反射进行了良好封装。（2）类型转换模块：mybatis为简化配置文件提供了别名机制，该机制是类型转换模块的主要功能之一。另一个功能是实现JDBC类型和JAVA类型之间...
杨开振：MyBatis技术原理与实战PDF解析
资源摘要信息:"杨开振的深入浅出MyBatis技术原理与实战的pdf版本" MyBatis是一个流行的Java持久层框架，它提供了对象关系映射（ORM）功能，通过XML或注解的方式将对象和数据库中的表进行映射。它消除了几乎所有的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值