MyBatis框架及原理分析

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架，其主要就完成2件事情：

1. 封装JDBC操作
2. 利用反射打通Java类与SQL语句之间的相互转换

MyBatis的主要设计目的就是让我们对执行SQL语句时对输入输出的数据管理更加方便，所以方便地写出SQL和方便地获取SQL的执行结果才是MyBatis的核心竞争力。
MyBatis的配置

MyBatis框架和其他绝大部分框架一样，需要一个配置文件，其配置文件大致如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <settings>
        <setting name="cacheEnabled" value="true"/>
        <setting name="lazyLoadingEnabled" value="false"/>
        <!--<setting name="logImpl" value="STDOUT_LOGGING"/> <!– 打印日志信息 –>-->
    </settings>

    <typeAliases>
        <typeAlias type="com.luo.dao.UserDao" alias="User"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/> <!--事务管理类型-->
            <dataSource type="POOLED">
                <property name="username" value="luoxn28"/>
                <property name="password" value="123456"/>
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.1.150/ssh_study"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="userMapper.xml"/>
    </mappers>

</configuration>

以上配置中，最重要的是数据库参数的配置，比如用户名密码等，如果配置了数据表对应的mapper文件，则需要将其加入到<mappers>节点下。

MyBatis的主要成员

• Configuration MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中
• SqlSession 作为MyBatis工作的主要顶层API，表示和数据库交互时的会话，完成必要数据库增删改查功能
• Executor MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
• StatementHandler 封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数等
• ParameterHandler 负责对用户传递的参数转换成JDBC Statement 所对应的数据类型
• ResultSetHandler 负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
• TypeHandler 负责java数据类型和jdbc数据类型(也可以说是数据表列类型)之间的映射和转换
• MappedStatement MappedStatement维护一条<select|update|delete|insert>节点的封装
• SqlSource 负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
• BoundSql 表示动态生成的SQL语句以及相应的参数信息

以上主要成员在一次数据库操作中基本都会涉及，在SQL操作中重点需要关注的是SQL参数什么时候被设置和结果集怎么转换为JavaBean对象的，这两个过程正好对应StatementHandler和ResultSetHandler类中的处理逻辑。

image.png

MyBatis的初始化

MyBatis的初始化的过程其实就是解析配置文件和初始化Configuration的过程，MyBatis的初始化过程可用以下几行代码来表述：

String resource = "mybatis.xml";

// 加载mybatis的配置文件（它也加载关联的映射文件）
InputStream inputStream = null;
try {
    inputStream = Resources.getResourceAsStream(resource);
} catch (IOException e) {
    e.printStackTrace();
}

// 构建sqlSession的工厂
sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

首先会创建SqlSessionFactory建造者对象，然后由它进行创建SqlSessionFactory。这里用到的是建造者模式，建造者模式最简单的理解就是不手动new对象，而是由其他类来进行对象的创建。

// SqlSessionFactoryBuilder类
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.
        }
    }
}

XMLConfigBuilder对象会进行XML配置文件的解析，实际为configuration节点的解析操作。

// XMLConfigBuilder类
public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
    try {
        //issue #117 read properties first
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631

        /* 处理environments节点数据 */
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

在configuration节点下会依次解析properties/settings/.../mappers等节点配置。在解析environments节点时，会根据transactionManager的配置来创建事务管理器，根据dataSource的配置来创建DataSource对象，这里面包含了数据库登录的相关信息。在解析mappers节点时，会读取该节点下所有的mapper文件，然后进行解析，并将解析后的结果存到configuration对象中。

// XMLConfigBuilder类
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)) {

                /* 创建事务管理器 */
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                DataSource dataSource = dsFactory.getDataSource();

                /* 建造者模式 设计模式 */
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                        .transactionFactory(txFactory)
                        .dataSource(dataSource);
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

// 解析单独的mapper文件
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse(); // 开始解析mapper文件了 :)
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

解析完MyBatis配置文件后，configuration就初始化完成了，然后根据configuration对象来创建SqlSession，到这里时，MyBatis的初始化的征程已经走完了。

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

MyBatis的SQL查询流程

SQL语句的执行才是MyBatis的重要职责，该过程就是通过封装JDBC进行操作，然后使用Java反射技术完成JavaBean对象到数据库参数之间的相互转换，这种映射关系就是有TypeHandler对象来完成的，在获取数据表对应的元数据时，会保存该表所有列的数据库类型，大致逻辑如下所示：

/* Get resultSet metadata */
ResultSetMetaData metaData = resultSet.getMetaData();
int column = metaData.getColumnCount();

for (int i = 1; i <= column; i++) {
    JdbcType jdbcType = JdbcType.forCode(metaData.getColumnType(i));
    typeHandlers.add(TypeHandlerRegistry.getTypeHandler(jdbcType));

    columnNames.add(metaData.getColumnName(i));
}

使用如下代码进行SQL查询操作：

sqlSession = sessionFactory.openSession();

User user = sqlSession.selectOne("com.luo.dao.UserDao.getUserById", 1);
System.out.println(user);

创建sqlSession的过程其实就是根据configuration中的配置来创建对应的类，然后返回创建的sqlSession对象。调用selectOne方法进行SQL查询，selectOne方法最后调用的是selectList，在selectList中，会查询configuration中存储的MappedStatement对象，mapper文件中一个sql语句的配置对应一个MappedStatement对象，然后调用执行器进行查询操作。

// DefaultSqlSession类
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;
    }
}

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操作中，优先会查询缓存是否命中，命中则直接返回，否则从数据库中查询。

// CachingExecutor类
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    /* 获取关联参数的sql，boundSql */
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    /* 创建cache key值 */
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

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);
}

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    /**
     * 先往localCache中插入一个占位对象，这个地方
     */
    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操作是由SimplyExecutor代理来完成的，该方法中有2个子流程，一个是SQL参数的设置，另一个是SQL查询操作和结果集的封装。

// SimpleExecutor类
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: SQL查询参数的设置 */
        stmt = prepareStatement(handler, ms.getStatementLog());

        /* 子流程2: SQL查询操作和结果集封装 */
        return handler.<E>query(stmt, resultHandler);
    } finally {
        closeStatement(stmt);
    }
}

子流程1 SQL查询参数的设置：

首先获取数据库connection连接，然后准备statement，然后就设置SQL查询中的参数值。打开一个connection连接，在使用完后不会close，而是存储下来，当下次需要打开连接时就直接返回。

// SimpleExecutor类
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    /* 获取Connection连接 */
    Connection connection = getConnection(statementLog);

    /* 准备Statement */
    stmt = handler.prepare(connection, transaction.getTimeout());

    /* 设置SQL查询中的参数值 */
    handler.parameterize(stmt);
    return stmt;
}

// DefaultParameterHandler类
public void setParameters(PreparedStatement ps) {
    /**
     * 设置SQL参数值，从ParameterMapping中读取参数值和类型，然后设置到SQL语句中
     */
    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);
                }
            }
        }
    }
}

子流程2 SQL查询结果集的封装：

// SimpleExecutor类
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    // 执行查询操作
    ps.execute();
    // 执行结果集封装
    return resultSetHandler.<E> handleResultSets(ps);
}

// DefaultReseltSetHandler类
public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
    /**
     * 获取第一个ResultSet，同时获取数据库的MetaData数据，包括数据表列名、列的类型、类序号等。
     * 这些信息都存储在了ResultSetWrapper中了
     */
    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);
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    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++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }

ResultSetWrapper是ResultSet的包装类，调用getFirstResultSet方法获取第一个ResultSet，同时获取数据库的MetaData数据，包括数据表列名、列的类型、类序号等，这些信息都存储在ResultSetWrapper类中了。然后调用handleResultSet方法来来进行结果集的封装

// DefaultResultSetHandler类
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
        if (parentMapping != null) {
            handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
        } else {
            if (resultHandler == null) {
                DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
                handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
                multipleResults.add(defaultResultHandler.getResultList());
            } else {
                handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
        }
    } finally {
        // issue #228 (close resultsets)
        closeResultSet(rsw.getResultSet());
    }
}


这里调用handleRowValues方法进行结果值的设置。
// DefaultResultSetHandler类
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    if (resultMap.hasNestedResultMaps()) {
        ensureNoRowBounds();
        checkResultHandler();
        handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
        // 封装数据
        handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
}

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
        throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    skipRows(rsw.getResultSet(), rowBounds);
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
        ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
        Object rowValue = getRowValue(rsw, discriminatedResultMap);
        storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
}

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    // createResultObject为新创建的对象，数据表对应的类
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final MetaObject metaObject = configuration.newMetaObject(rowValue);
        boolean foundValues = this.useConstructorMappings;
        if (shouldApplyAutomaticMappings(resultMap, false)) {
            // 这里把数据填充进去，metaObject中包含了resultObject信息
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
        }
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
        foundValues = lazyLoader.size() > 0 || foundValues;
        rowValue = (foundValues || configuration.isReturnInstanceForEmptyRow()) ? rowValue : null;
    }
    return rowValue;
}

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    if (autoMapping.size() > 0) {
        // 这里进行for循环调用，因为user表中总共有7列，所以也就调用7次
        for (UnMappedColumnAutoMapping mapping : autoMapping) {
            // 这里将esultSet中查询结果转换为对应的实际类型
            final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
            if (value != null) {
                foundValues = true;
            }
            if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
                // gcode issue #377, call setter on nulls (value is not 'found')
                metaObject.setValue(mapping.property, value);
            }
        }
    }
    return foundValues;
}

mapping.typeHandler.getResult会获取查询结果值的实际类型，比如我们user表中id字段为int类型，那么它就对应Java中的Integer类型，然后通过调用statement.getInt("id")来获取其int值，其类型为Integer。metaObject.setValue方法会把获取到的Integer值设置到Java类中的对应字段。

// MetaObject类
public void setValue(String name, Object value) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
        MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
        if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
            if (value == null && prop.getChildren() != null) {
                // don't instantiate child path if value is null
                return;
            } else {
                metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
            }
        }
        metaValue.setValue(prop.getChildren(), value);
    } else {
        objectWrapper.set(prop, value);
    }
}

metaValue.setValue方法最后会调用到Java类中对应数据域的set方法，这样也就完成了SQL查询结果集的Java类封装过程。最后贴一张调用栈到达Java类的set方法中的快照：

image

MyBatis缓存

MyBatis提供查询缓存，用于减轻数据库压力，提高性能。MyBatis提供了一级缓存和二级缓存。

image

一级缓存是SqlSession级别的缓存，每个SqlSession对象都有一个哈希表用于缓存数据，不同SqlSession对象之间缓存不共享。同一个SqlSession对象对象执行2遍相同的SQL查询，在第一次查询执行完毕后将结果缓存起来，这样第二遍查询就不用向数据库查询了，直接返回缓存结果即可。MyBatis默认是开启一级缓存的。

二级缓存是mapper级别的缓存，二级缓存是跨SqlSession的，多个SqlSession对象可以共享同一个二级缓存。不同的SqlSession对象执行两次相同的SQL语句，第一次会将查询结果进行缓存，第二次查询直接返回二级缓存中的结果即可。MyBatis默认是不开启二级缓存的，可以在配置文件中使用如下配置来开启二级缓存：

<pre style="margin: 0px; padding: 0px; overflow: auto; word-wrap: break-word; font-family: &quot;Courier New&quot; !important; font-size: 12px !important;"><settings>
    <setting name="cacheEnabled" value="true"/>
</settings></pre>

当SQL语句进行更新操作(删除/添加/更新)时，会清空对应的缓存，保证缓存中存储的都是最新的数据。MyBatis的二级缓存对细粒度的数据级别的缓存实现不友好，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存，具体业务具体实现。

以上内容转自https://www.cnblogs.com/luoxn28/p/6417892.html 转载只是为了学习 并无他意

mybatis源码解析图

Mybatis核心流程源码分析流程图解.png

源码编译与下载

https://github.com/mybatis/mybatis-3

https://github.com/mybatis/parent（依赖）

image.png

image.png

可以直接idea导入 也可以直接下载为zip包（推荐这种）。

image.png

Mybatis源码袭来parent工程。需要先编译parent工程在编译mybatis，具体如下

解决parent依赖问题：

在构建的过程中会出现找不到pom.xml中依赖的父模块mybatis-parent

我们需要将paren工程克隆到本地目录中：git clone https://github.com/mybatis/parent.git ，然后先进入parent工程下进行mvn clean install 将parent工程依赖的包下载下来、并保证parent工程编译通过，这步不会出现问题，在编译的输出信息中我们会看到parent工程的版本号，如图所示：

![image.png](https:https://upload-images.jianshu.io/upload_images/24028241-abe08f15dimage.png

pom.xml文件parent依赖的version标签处，如下文。 接下来修改mybatis工程的pom.xml文件中标识parent依赖的地方：

|

<parent>

<groupId>org.mybatis</groupId>

<artifactId>mybatis-parent</artifactId>

<version>28-SNAPSHOT</version>

<relativePath>../parent/pom.xml</relativePath>

</parent>

|

告诉我们部分插件没有指定的相应的版本号，出于工程的稳定性考虑需要对使用的插件指定其版本号，并给出了合适的版本号，如图红色方框中的文字。我们只要在mybatisg工程的pom.xml文件中找到相对应的插件处添加<version>NUM代表具体的版本号。到这我们再执行mvn clean install 指令就可以将mybatis工程构建成功了。

image.png

首先Mybatis是一个优秀的持久层ORM框架，它对jdbc的操作数据库的过程进行封装，使得开发者只需要关注SQL本身。不需要花费精力去处理一些重复和繁琐的步骤。最后通过java对象和statement中的sql进行映射生成最终执行的sql语句。最后由mysql框架执行sql并将结果映射成java对象并返回。

ORM：对象关系映射，简单点说就是将数据库中的表和java中的对象建立映射关系，可以让我们操作对象来间接的操作数据库。

半ORM：在查询关联对象或关联集合对象时，需要手动编写sql来完成。

MyBatis编程步骤

• 创建SqlSessionFactory
• 通过SqlSessionFactory创建SqlSession
• 通过sqlsession执行数据库操作
• 调用session.commit()提交事务
• 调用session.close关闭会话

MyBatis的工作原理

• 读取MyBatis配置文件。（获取MyBatis的运行环境等信息）
• 加载映射文件。（SQL映射文件，其中配置了操作数据库的SQL语句）
• 构造会话工厂：通过MyBatis的环境等配置信息构建会话工厂SqlSessionFactory
• 创建会话对象：有会话工厂创建SqlSession对象，该对象包括了执行SQL语句的所有方法
• Executor执行器：根据SqlSession传递的参数动态的生成需要执行的SQL语句，同时负责查询缓存的维护
• Mappedstatement对象：用于存储要映射的SQL语句的id、参数等信息
• 输入参数映射：参数类型可以为Map、List等集合类型也可以使用基本数据类型和POJO类型
• 输出结果映射：和输入类似。

MyBatis的优点

• 基于SQL语句编程，相当灵活。SQL写在XML中，解除sql与程序代码的耦合，便于统一管理。提供XML标签，支持编写动态SQL语句，并可重用
• 消除了 JDBC 大量冗余的代码，不需要手动开关连接；
• 很好的与各种数据库兼容
• 能够与 Spring 很好的集成；
• 提供映射标签，支持对象与数据库的 ORM 字段关系映射；提供对象关系映射标签，支持对象关系组件维护。

MyBatis框架的缺点

• SQL 语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL 语句的功底有一定要求。
• SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

MyBatis与Hibernate有哪些不同

• MyBatis是一个半ORM框架，需要自己编写sql语句，灵活性高，但是需要自定义多套sql映射文件，工作量大
• Hibernate数据库无关性好，节省代码，提高效率

{}和${}的区别

{}：是预编译处理，会把sql中的#{}替换为？，调用PreoaredStatement的set方法来赋值

{}替换为变量的值。
使用#{}可以有效的防止SQL注入，提高系统的安全性 。

当实体类的属性名和表中的字段名不一致如何处理

• 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。

• 通过<resultMap>类映射字段名和实体类属性名的一一对应的关系

模糊查询like怎么编写

• 在Java代码中添加sql通配符
• 在sql语句中拼接通配符（但是会引起sql注入问题）

通常一个Xml映射文件，都会写一个Dao接口与之对应。那么Dao接口的工作原理是什么。

Dao接口就是Mapper接口。

• 接口的全限定名就是映射文件的namespace的值
• 接口的方法名就是映射文件中Mapper的Statement的id值
• 接口方法内的参数就是传递给sql的参数

Mapper接口是没有实现类的，当调用接口方法的时候，接口的全限定名+方法名拼接字符串作为key值，可以唯一定位一个MapperStatement。在MyBatis中，每一个<select>、<insert>、<update>、<delete>标签都会被解析为一个MapperStatement对象

Dao接口的方法，参数不同时，方法能重载吗

Mapper接口里的方法，是不能重载的，因为使用全限定名+方法名的保存和寻找策略。所以不能重载。

Mapper接口的工作原理是JDK动态代理，MyBatis运行时会使用JDK动态代理为Mapper接口生成代理对象proxy，代理对象会拦截接口方法，转而执行MapperStatement所代表的sql，然后将sql执行结果返回。

MyBatis是如何进行分页的以及分页插件的原理是什么

MyBatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理的分页功能，或者使用分页插件来完成物理分页

分页插件的基本原理就是使用MyBatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect，添加对应的物理分页语句和物理分页参数。

Mybati是如何将sql执行机构封装为对象并返回的？有哪些映射形式

• 使用<resultMap>标签，逐一定义数据库列名和对象属性名之间的映射关系。
• 使用sql列的别名功能，将列别名书写为对象属性名

有了列名和属性名的映射关系后，MyBatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的

如何进行批量插入

如何获取自动生成的主键值

• 使用JDBC内置方法
• 插入后查询获取
• 插入前查询获取主键

如何在mapper中传递多个参数

• Dao层函数
• 使用@param注解
• 多个参数封装成map

MyBatis动态sql

MyBatis动态sql可以在Xml映射文件内，以标签的形式编写动态sql，执行原理是根据表达式的值完成逻辑判断并动态拼接sql功能

MyBatis提供了九种sql标签

• trim
• where
• set
• foreach
• if
• choose
• when
• otherwise
• bind

XML文件标签

• select
• insert
• update
• delete
• resultMap
• parameterMap
• sql
• include
• selectKey

MyBatis的Xml映射文件中，不同的Xml文件id是否可以重复

如果配置了namespace那么id可以重复，要是没有配置namespace，id就不可以重复

MyBatis实现一对一有几种方式

• 联合查询

• • 几个表联合查询，只查询一次，通过配置collection节点

• 嵌套查询

• • 先查一个表，再根据查出的id去另外一个表里查询数据，也是通过配置collection，但是另外一个表的查询通过select节点配置

MyBatis是否支持延迟加载，以及如何实现

Mybatis仅支持association关联对象和collection关联集合对象的延迟加载。可以通过配置lazyLoadingEnabled来进行配置。

原理

使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName()，拦截器 invoke()方法发现 a.getB()是null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加载的基本原理。

MyBatis的缓存

• 一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为Session，当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存。
• 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态),可在它的映射文件中配置<cache/> ；

缓存更新

• 进行增删改
• 调用清除方法
• 设置清除属性

MyBatis的接口绑定，以及实现方式

接口绑定：就是在MyBatis中任意定义接口，然后把接口里面的方法和SQL语句进行绑定，我们在使用的时候直接调用接口方法即可

实现方式

• 通过注解绑定
• 通过xml里面写sql语句来绑定，需要指定xml中namespace必须为接口的全路径名。

Mybatis的mapper接口调用时有哪些要求

• Mapper接口的方法名和mapper.xml中sql的id相同
• Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的parameterType 的类型相同
• Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的resultType 的类型相同
• Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径

Mybatis 的插件运行原理，以及如何编写一个插件。

Mybatis 仅可以编写针对 ParameterHandler、ResultSetHandler、StatementHandler、Executor 这 4 种接口的插件，Mybatis 使用 JDK 的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这 4 种接口对象的方法时，就会进入拦截方法，具体就是 InvocationHandler 的 invoke()方法，当然，只会拦截那些你指定需要拦截的方法。

编写插件：实现 Mybatis 的 Interceptor 接口并复写 intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

预编译

定义

SQL预编译是指数据库驱动在发送SQL语句和参数给DBMS之前对SQL语句进行编译，这样DBMS执行SQL时，就不需要重现编译

预编译作用

可以优化SQL的执行。预编译后的大多数SQL可以直接运行，同时预编译语句对象可以重复利用。还可以防止SQL注入

MyBatis有哪些Executor执行器，他们之间的区别是什么

有三种基本的Executor执行器：SimpleExecutor、ReuseExxecutor、BatchExecutor

SimpleExecutor

每执行一次update或者select就开启一个Statement对象，用完就立即关闭

ReuseRxecutor

执行update或者select，以sql为key查找Statement对象。为了重复使用Statement对象

BatchExecutor

执行update，将所有sql都添加到批处理中，等待同一执行。其魂村了多个Statement对象。

当实体类中的属性名和表中的字段名不一样，怎么办

• 通过在查询的SQL语句中定义字段名的别名，让字段名和实体类的属性名一致
• 通过resultMap来映射字段名和实体类属性名的一一对应的关系

ResultType和ResultMap的区别

首先MyBatis在查询进行select映射的时候，返回类型可以用resultType也可以用resultMap，其中resultType是直接表示返回类型的，而resultMap则是对外部ResultMap的引用。这两不能同时存在

在MyBatis进行查询映射的时候，其实查询出来的每一个属性都是放在一个对应的Map中，键是属性名、值是对应的值。

3. MyBatis是如何进行分页的？分页插件的原理是什么？

Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页。也可以直接编写SQL实现分页或者使用分页插件。
分页插件的原理：实现MyBatis提供的接口来实现自定义插件，然后在插件的拦截方法内拦截待执行的SQL，最后重写SQL。

4. Dao 接口里的方法，参数不同时，方法能重载吗？

Mapper 接口里的方法，是不能重载的，因为是使用全限名+方法名的保存和寻找策略。Mapper 接口的工作原理是 JDK 动态代理，Mybatis 运行时会使用 JDK动态代理为 Mapper 接口生成代理对象 proxy，代理对象会拦截接口方法，转而执行 MapperStatement 所代表的 sql，然后将 sql 执行结果返回。

5. MyBatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？

使用resultMap标签，定义数据库列名和对象属性名之间的映射关系。
使用sql列的别名功能，将列的别名书写为对象属性名。
有了列名与属性名的映射关系后，MyBatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回。

6. Mybaits 的优缺点？

优点：
基于SQL语句编程，相当灵活，不会对应用程序或者数据库的现有设计造成任何影响，SQL写在XML里，解除sql与程序代码的耦合，便于统一管理；提供XML标签，支持编写动态SQL语句，并可重用。
与JDBC相比，减少了50%以上的代码量，消除了JDBC大量冗余的代码，不需要手动开关连接；
很好的与各种数据库兼容，能够与 Spring 很好的集成；
提供映射标签，支持对象与数据库的ORM字段关系映射；提供对象关系映射标签，支持对象关系组件维护。
缺点：
SQL语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求。
QL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

7. 谈谈你对MyBatis的理解？

MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架，它内部封装了JDBC，开发时只需要关注SQL语句本身。程序员直接编写原生态SQL，可以严格控制sql执行性能，灵活度高。

8. MyBatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

不同的Xml映射文件，如果配置了namespace，id可以重复。如果没有配置namespace，id不能重复。原因是namespace+id是作为Map<String，MapperStatement>的key使用的，如果没有namespace，id重复会导致数据互相覆盖。有了namespace，id就可以重复，namespace不同，namespace+id自然也就不同。

9. #{}和${}的区别是什么？

是预编译处理，KaTeX parse error: Expected 'EOF', got '#' at position 19: …串替换。 Mybatis在处理#̲时，会将sql中的#{}替换为…时，就是把$替换成变量的值。

使用#可以有效的防止SQL注入，提高系统安全性。

10. 当实体类中的属性名和表中的字段名不一样 ，怎么办？

通过在查询的sql语句中定义字段名的别名。
通过resultMap标签来映射字段名和实体类属性名的一一对应的关系。

11. Mybatis映射文件中，如果A标签通过include引用了B标签的内容，请问B标签能否定义在A标签的后面，还是说必须定义在A标签的前面？

Mybatis解析Xml映射文件是按照顺序解析的，但是被引用的B标签定义在任何地方Mybatis都可以正确识别。原理是Mybatis解析A标签，发现A标签引用了B标签，但是B标签尚未解析到，此时会将A标签标记为未解析状态，然后继续解析余下的标签，包含B标签。待所有标签解析完毕，Mybatis会重新解析那些被标记为未解析的标签，此时再解析A标签时，B标签已经存在，A标签也就可以正常解析完成了。

12. MyBats中的 一对一、一对多的关联查询 ？

定义一个resultMap，使用association属性实现一对一的关联查询；使用collection属性实现一对多的关联查询。

13. MyBatis实现一对一有几种方式?具体怎么操作的？

联合查询是几个表联合查询，只查询一次， 通过在resultMap里面配置association节点配置一对一的类就可以完成；
嵌套查询先查一个表，根据这个表里面的结果的外键id，去再另外一个表里面查询数据，也是通过association配置，但另外一个表的查询通过select属性配置。

14. MyBatis 的好处是什么？

把sql语句从 Java 源程序中独立出来，放在单独的XML文件中编写，给程序的维护带来了很大便利。
能自动将结果集转换成Java Bean对象，大大简化了Java数据库编程的重复工作。
程序员可以结合数据库自身的特点灵活控制sql语句，能够完成复杂查询。

15. 讲一下MyBatis的一级、二级缓存（说说MyBatis的缓存）？

MyBatis的缓存分为一级缓存和二级缓存，一级缓存放在session里面，默认就有。二级缓存放在它的命名空间里，默认是不打开的，使用二级缓存属性类需要实现Serializable序列化接口，可在它的映射文件中配置cache标签

16. Mapper 编写有哪几种方式？

接口实现类继承 SqlSessionDaoSupport，需要编写mapper 接口，mapper 接口实现类、mapper.xml 文件。
在 sqlMapConfig.xml 中配置 mapper.xml 的位置
定义 mapper 接口
实现类集成 SqlSessionDaoSupportmapper 方法中可以 this.getSqlSession()进行数据增删改查。
spring 配置
使用 org.mybatis.spring.mapper.MapperFactoryBean，在 sqlMapConfig.xml 中配置 mapper.xml 的位置，定义 mapper 接口：
mapper.xml 中的 namespace 为 mapper 接口的地址
mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致
Spring 中定义
第三种：使用mapper扫描器：
mapper.xml 文件编写：
定义 mapper 接口，注意 mapper.xml 的文件名和 mapper 的接口名称保持一致，且放在同一个目录
配置 mapper 扫描器：
使用扫描器后从 spring 容器中获取 mapper 的实现对象。

17. MyBatis在mapper中如何传递多个参数?

直接在方法中传递参数，xml文件用#符号来获取
使用@param注解或者多个参数封装成 map

18. MyBatis 是否支持延迟加载？如果支持，它的实现原理是什么？

MyBatis仅支持association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在 MyBatis配置文件中，可以通过 lazyLoadingEnabled=true/false 配置是否启用延迟加载。
原理是：使用CGLIB创建目标对象的代理对象，当调用目标方法时会进入拦截器方法，比如调用a.getB().getName()，拦截器invoke()方法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB()，于是a的对象b属性就有值了，接着完成a.getB().getName()方法的调用。

19. Xml 映射文件中，除了常见的 select、insert、updae、delete标签之外，还有哪些标签？

resultMap、parameterMap、sql、include、selectKey，加上动态sql的9个标签，其中sql为sql片段标签，通过include标签标签引入sql片段，selectKey标签为不支持自增的主键生成策略标签。

20. 通常一个Xml映射文件，都会写一个Dao接口与之对应，请问这个 Dao 接口的工作原理是什么，是否可以重载？

不能重载，因为通过Dao寻找Xml对应sql的时候，使用全限名+方法名的保存和寻找策略。Dao接口工作原理为jdk动态代理原理，运行时会为dao生成proxy，代理对象会拦截接口方法，去执行对应的sql返回数据。

21. 什么是MyBatis的接口绑定？有哪些实现方式？

接口绑定是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定。
接口绑定有两种实现方式：
通过注解绑定，在接口的方法上面加上@Select、@Update等注解，里面包含Sql语句来绑定；
通过xml里面写SQL来绑定，要指定xml映射文件里面的namespace必须为接口的全路径名。
当Sql语句比较简单时候，用注解绑定；当SQL语句比较复杂时候，用xml绑定，一般用 xml 绑定的比较多。

22. MyBatis如何获取自动生成的(主)键值?

在insert标签中使用useGeneratedKeys和keyProperty两个属性来获取自动生成的主键值。

23. 使用MyBatis的mapper接口调用时有哪些要求？

Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同；
Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的parameterType 的类型相同；
Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的resultType 的类型相同；
Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径。

24. MyBatis 动态sql有什么用？执行原理？有哪些动态sql？

MyBatis动态sql可以在Xml映射文件内，以标签的形式编写动态sql。
执行原理是根据表达式的值完成逻辑判断并动态拼接 sql 的功能。
MyBatis提供了9种动态sql标签：trim、where、set、foreach、if、choose、when、otherwise、bind。

25. MyBatis是否可以映射 Enum 枚举类？

MyBatis不单可以映射枚举类，还可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler，实现TypeHandler的setParameter()和getResult()接口方法。TypeHandler有两个作用，一是完成从javaType至jdbcType的转换，二是完成jdbcType至javaType的转换，体现为setParameter()和getResult()两个方法，分别代表设置sql问号占位符参数和获取列查询结果。

26. Mybatis能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别？

Mybatis不仅可以执行一对一、一对多的关联查询，还可以执行多对一，多对多的关联查询。多对一查询，其实就是一对一查询，只需要把selectOne()修改为selectList()即可；多对多查询，其实就是一对多查询，只需要把selectOne()修改为selectList()即可。
关联对象查询有两种实现方式，一种是单独发送一个sql去查询关联对象，赋给主对象，然后返回主对象。另一种是使用嵌套查询，嵌套查询的含义为使用join查询，一部分列是A对象的属性值，另外一部分列是关联对象B的属性值，好处是只发一个sql查询，就可以把主对象和其关联对象查出来。

27. MyBatis里面的动态Sql是怎么设定的?用什么语法?

MyBatis里面的动态Sql一般是通过if节点来实现,通过OGNL语法来实现,但是如果要写的完整,必须配合where,trim节点,where节点是判断包含节点有内容就插入where,否则不插入,trim节点是用来判断如果动态语句是以and或or开始,那么会自动把这个and或者or取掉。

28. 简述MyBatis的插件运行原理，以及如何编写一个插件？

运行原理：MyBatis只能编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor四种接口的插件，MyBatis通过动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这四种接口对象的方法时，就会进入拦截方法。具体就是调用InvocationHandler的invoke()方法，只会拦截指定需要拦截的方法。
编写插件：实现MyBatis的Interceptor接口并复写 ntercept()方法，然后给插件编写注解，指定要拦截哪一个接口的哪些方法，最后在配置文件中配置编写的插件。

29. 为什么说Mybatis是半自动 ORM 映射工具？它与全自动的区别在哪里？

Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以称之为半自动ORM映射工具。

30. resultType和resultMap的区别？

类的名字和数据库相同时，可以直接设置resultType参数为Pojo类。若不同，需要设置resultMap将结果名字和Pojo名字进行转换。