10.1传统方式源码剖析:

源码剖析-初始化

Inputstream inputstream = Resources.getResourceAsStream("mybatis-config.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 building SqlSession.", e)
}

MyBatis在初始化的时候,会将MyBatis的配置信息全部加载到内存中,使用

org.apache.ibatis.session.Configuratio n 实例来维护

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

首先对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配置文件的解析就结束了,回到步骤2.中调用的重载build方法

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

源码剖析-执行SQL流程

先简单介绍SqlSession :

SqlSession是一个接口,它有两个实现类:DefaultSqlSession (默认)和

SqlSessionManager (弃用,不做介绍)

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

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

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

Executor:

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

BatchExecutor (重用语句并执行批量更新)

ReuseExecutor (重用预处理语句 prepared statements)

SimpleExecutor (普通的执行器,默认)

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

SqlSession sqlSession = factory.openSession();
List<User> list = sqlSession.selectList("com.lagou.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 querying database. Cause: + e, e);
        
  } finally {
    ErrorContext.instance().reset();
     
}

源码剖析-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的功能和作用是:

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

源码剖析-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("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对象的?占位符处进行赋值。

进入到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("handling results").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);
}

10.2 Mapper代理方式:

回顾下写法:

public static void main(String[] args) {
       //前三步都相同
       InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
       SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
       SqlSession sqlSession = factory.openSession();
       //这里不再调用SqlSession的api,而是获得了接口对象,调用接口中的方法。
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       List<User> list = mapper.getUserByName("tom");
 
}

思考一个问题,通常的Mapper接口我们都没有实现的方法却可以使用,是为什么呢?答案很简单动态代理

开始之前介绍一下MyBatis初始化时对接口的处理:MapperRegistry是Configuration中的一个属性,

它内部维护一个HashMap用于存放mapper接口的工厂类,每个接口对应一个工厂类。mappers中可以配置接口的包路径,或者某个具体的接口类。

<mappers>
<mapper class="com.lagou.mapper.UserMapper"/>
<package name="com.lagou.mapper"/>
</mappers>

当解析mappers标签时,它会判断解析到的是mapper配置文件时,会再将对应配置文件中的增删 改查标签 封装成MappedStatement对象,存入mappedStatements中。(上文介绍了)当判断解析到接口时,会建此接口对应的MapperProxyFactory对象,存入HashMap中,key =接口的字节码对象,value =此接口对应的MapperProxyFactory对象。

源码剖析-getmapper()

进入 sqlSession.getMapper(UserMapper.class )中

  //DefaultSqlSession 中的 getMapper
   public <T> T getMapper(Class<T> type) {
       return configuration.<T>getMapper(type, this);
 
  }
  
   //configuration 中的给 g etMapper
   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
       return mapperRegistry.getMapper(type, sqlSession);
 
  }
  
   //MapperRegistry 中的 g etMapper
   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
       //从 MapperRegistry 中的 HashMap 中拿 MapperProxyFactory
       final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
       if (mapperProxyFactory == null) {
           throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
     
        }
        
       try {
           //通过动态代理工厂生成示例。
           return mapperProxyFactory.newInstance(sqlSession);
      } catch (Exception e) {
                 throw new BindingException("Error getting mapper instance. Cause: " + e, e);
      }
}


   //MapperProxyFactory 类中的 newInstance 方法
   public T newInstance(SqlSession sqlSession) {
       //创建了 JDK动态代理的Handler类
       final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
       //调用了重载方法
       return newInstance(mapperProxy);
 
  }
  
   //MapperProxy 类,实现了 InvocationHandler 接口
   public class MapperProxy<T> implements InvocationHandler, Serializable {
       //省略部分源码
     private final SqlSession sqlSession;
       private final Class<T> mapperInterface;
       private final Map<Method, MapperMethod> methodCache;
       //构造,传入了 SqlSession,说明每个session中的代理对象的不同的!
       public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
           this.sqlSession = sqlSession;
           this.mapperInterface = mapperInterface;
           this.methodCache = methodCache;
     
      }
       //省略部分源码
 
}

源码剖析-invoke()

在动态代理返回了示例后,我们就可以直接调用mapper类中的方法了,但代理对象调用方法,执行是在MapperProxy中的invoke方法中

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       try {
           //如果是Object定义的方法,直接调用
           if (Object.class.equals(method.getDeclaringClass())) {
               return method.invoke(this, args);
         
          } else if (isDefaultMethod(method)) {
               return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) {
              throw ExceptionUtil.unwrapThrowable(t);
        }
       // 获得 MapperMethod 对象
       final MapperMethod mapperMethod = cachedMapperMethod(method);
       //重点在这:MapperMethod最终调用了执行的方法
       return mapperMethod.execute(sqlSession, args);
}

进入execute方法:

 public Object execute(SqlSession sqlSession, Object[] args) {
       Object result;
       //判断mapper中的方法类型,最终调用的还是SqlSession中的方法 
    switch(command.getType()) {
       case INSERT: {
           //转换参数
           Object param = method.convertArgsToSqlCommandParam(args);
           //执行INSERT操作
           // 转换 rowCount
           result = rowCountResult(sqlSession.insert(command.getName(), param));
           break;
     
        }
       case UPDATE: {
           //转换参数
           Object param = method.convertArgsToSqlCommandParam(args);
         // 转换 rowCount
           result = rowCountResult(sqlSession.update(command.getName(), param));
           break;
     
        }
       case DELETE: {
           //转换参数
           Object param = method.convertArgsToSqlCommandParam(args);
           // 转换 rowCount
           result = rowCountResult(sqlSession.delete(command.getName(), param));
           break;
     
        }
       case SELECT:
       //无返回,并且有ResultHandler方法参数,则将查询的结果,提交给ResultHandler 进行处理
       if (method.returnsVoid() && method.hasResultHandler()) {
           executeWithResultHandler(sqlSession, args);
           result = null;
       //执行查询,返回列表
     
} else if (method.returnsMany()) {
           result = executeForMany(sqlSession, args);
       //执行查询,返回Map
     
} else if (method.returnsMap()) {
           result = executeForMap(sqlSession, args);
       //执行查询,返回Cursor
     
} else if (method.returnsCursor()) {
           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;
}

10.3 二级缓存源码剖析:

二级缓存构建在一级缓存之上,在收到查询请求时,MyBatis 首先会查询二级缓存,若二级缓存未命

中,再去查询一级缓存,一级缓存没有,再查询数据库。

二级缓存------》 一级缓存------》数据库

与一级缓存不同,二级缓存和具体的命名空间绑定,一个Mapper中有一个Cache,相同Mapper中的

MappedStatement共用一个Cache,一级缓存则是和 SqlSession 绑定。

启用二级缓存

分为三步走:

1)开启全局二级缓存配置:

<settings>
   <setting name="cacheEnabled" value="true"/>
</settings>

2. 在需要使用二级缓存的Mapper配置文件中配置标签

 <cache></cache>

3)在具体CURD标签上配置 useCache=true

<select id="findById" resultType="com.lagou.pojo.User" useCache="true">
      select * from user where id = #{id}
  </select>

标签 < cache/> 的解析

根据之前的mybatis源码剖析,xml的解析工作主要交给XMLConfigBuilder.parse()方法来实现

 // XMLConfigBuilder.parse()
 public Configuration parse() {
     if (parsed) {
         throw new BuilderException("Each XMLConfigBuilder can only be used
once.");
   
}
     parsed = true;
     parseConfiguration(parser.evalNode("/configuration"));// 在这里
     return configuration;
}
 
// parseConfiguration()
// 既然是在xml中添加的,那么我们就直接看关于mappers标签的解析
private void parseConfiguration(XNode root) {
    try {
        Properties settings = settingsAsPropertiess(root.evalNode("settings"));
      propertiesElement(root.evalNode("properties"));
        loadCustomVfs(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectionFactoryElement(root.evalNode("reflectionFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        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);
    }
}
// mapperElement()
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判断
                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());
                    // 生成XMLMapperBuilder,并执行其parse方法
                    mapperParser.parse();
                } 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.");
              }
            }
        }
    }
}

我们来看看解析Mapper.xml

// XMLMapperBuilder.parse()
public void parse() {
   if (!configuration.isResourceLoaded(resource)) {
       // 解析mapper属性
       configurationElement(parser.evalNode("/mapper"));
       configuration.addLoadedResource(resource);
       bindMapperForNamespace();
 
}
   parsePendingResultMaps();
   parsePendingChacheRefs();
   parsePendingStatements();
}
// configurationElement()
private void configurationElement(XNode context) {
   try {
       String namespace = context.getStringAttribute("namespace");
       if (namespace == null || namespace.equals("")) {
           throw new BuilderException("Mapper's namespace cannot be empty");
     
}
       builderAssistant.setCurrentNamespace(namespace);
       cacheRefElement(context.evalNode("cache-ref"));
       // 最终在这里看到了关于cache属性的处理
       cacheElement(context.evalNode("cache"));
       parameterMapElement(context.evalNodes("/mapper/parameterMap"));
       resultMapElements(context.evalNodes("/mapper/resultMap"));
       sqlElement(context.evalNodes("/mapper/sql"));
       // 这里会将生成的Cache包装到对应的MappedStatement
     
 buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
 
} catch (Exception e) {
       throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
 
}
}
// cacheElement()
private void cacheElement(XNode context) throws Exception {
   if (context != null) {
       //解析<cache/>标签的type属性,这里我们可以自定义cache的实现类,比如redisCache,如
果没有自定义,这里使用和一级缓存相同的PERPETUAL
       String type = context.getStringAttribute("type", "PERPETUAL");
       Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
       String eviction = context.getStringAttribute("eviction", "LRU");
       Class<? extends Cache> evictionClass =
typeAliasRegistry.resolveAlias(eviction);
       Long flushInterval = context.getLongAttribute("flushInterval");
       Integer size = context.getIntAttribute("size");
       boolean readWrite = !context.getBooleanAttribute("readOnly", false);
   boolean blocking = context.getBooleanAttribute("blocking", false);
       Properties props = context.getChildrenAsProperties();
       // 构建Cache对象
       builderAssistant.useNewCache(typeClass, evictionClass, flushInterval,
size, readWrite, blocking, props);
 
}
}

先来看看是如何构建Cache对象的

MapperBuilderAssistant.useNewCache()

public Cache useNewCache(Class<? extends Cache> typeClass,
                        Class<? extends Cache> evictionClass,
                        Long flushInterval,
                        Integer size,
                        boolean readWrite,
                        boolean blocking,
                        Properties props) {
   // 1.生成Cache对象
   Cache cache = new CacheBuilder(currentNamespace)
        //这里如果我们定义了<cache/>中的type,就使用自定义的Cache,否则使用和一级缓存相同
的PerpetualCache
      .implementation(valueOrDefault(typeClass, PerpetualCache.class))
      .addDecorator(valueOrDefault(evictionClass, LruCache.class))
      .clearInterval(flushInterval)
      .size(size)
      .readWrite(readWrite)
      .blocking(blocking)
      .properties(props)
      .build();
   // 2.添加到Configuration中
   configuration.addCache(cache);
   // 3.并将cache赋值给MapperBuilderAssistant.currentCache
   currentCache = cache;
   return cache;
}

我们看到一个Mapper.xml只会解析一次标签,也就是只创建一次Cache对象,放进configuration中,并将cache赋值给MapperBuilderAssistant.currentCache

buildStatementFromContext(context.evalNodes("select|insert|update|delete"));将Cache包装到MappedStatement

/ buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list) {
   if (configuration.getDatabaseId() != null) {
       buildStatementFromContext(list, configuration.getDatabaseId());
 
}
   buildStatementFromContext(list, null);
}
//buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list, String
requiredDatabaseId) {
   for (XNode context : list) {
       final XMLStatementBuilder statementParser = new
XMLStatementBuilder(configuration, builderAssistant, context,
requiredDatabaseId);
       try {
           // 每一条执行语句转换成一个MappedStatement
           statementParser.parseStatementNode();
     
} catch (IncompleteElementException e) {
           configuration.addIncompleteStatement(statementParser);
     
 
}
}
}
// XMLStatementBuilder.parseStatementNode();
public void parseStatementNode() {
   String id = context.getStringAttribute("id");
   String databaseId = context.getStringAttribute("databaseId");
 
...
   Integer fetchSize = context.getIntAttribute("fetchSize");
   Integer timeout = context.getIntAttribute("timeout");
   String parameterMap = context.getStringAttribute("parameterMap");
   String parameterType = context.getStringAttribute("parameterType");
   Class<?> parameterTypeClass = resolveClass(parameterType);
   String resultMap = context.getStringAttribute("resultMap");
   String resultType = context.getStringAttribute("resultType");
   String lang = context.getStringAttribute("lang");
   LanguageDriver langDriver = getLanguageDriver(lang);
 
...
   // 创建MappedStatement对象
   builderAssistant.addMappedStatement(id, sqlSource, statementType,
sqlCommandType,
                                       fetchSize, timeout, parameterMap,
parameterTypeClass, resultMap, resultTypeClass,
                                       resultSetTypeEnum, flushCache, useCache,
resultOrdered,
                                       keyGenerator, keyProperty, keyColumn,
databaseId, langDriver, resultSets);
}
// builderAssistant.addMappedStatement()
public MappedStatement addMappedStatement(
   String id,
 
...) {
   if (unresolvedCacheRef) {
       throw new IncompleteElementException("Cache-ref not yet resolved");
 
}
   id = applyCurrentNamespace(id, false);
   boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
   //创建MappedStatement对象
   MappedStatement.Builder statementBuilder = new
MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
      ...
      .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
      .useCache(valueOrDefault(useCache, isSelect))
      .cache(currentCache);// 在这里将之前生成的Cache封装到MappedStatement
 ParameterMap statementParameterMap = getStatementParameterMap(parameterMap,
parameterType, id);
   if (statementParameterMap != null) {
       statementBuilder.parameterMap(statementParameterMap);
 
}
   MappedStatement statement = statementBuilder.build();
   configuration.addMappedStatement(statement);
   return statement;
}

我们看到将Mapper中创建的Cache对象,加入到了每个MappedStatement对象中,也就是同一个

Mapper中所有的2

有关于标签的解析就到这了。

查询源码分析

CachingExecutor

// CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
   BoundSql boundSql = ms.getBoundSql(parameterObject);
   // 创建 CacheKey
   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 {
   // 从 MappedStatement 中获取 Cache,注意这里的 Cache 是从MappedStatement中获取的
   // 也就是我们上面解析Mapper中<cache/>标签中创建的,它保存在Configration中
   // 我们在上面解析blog.xml时分析过每一个MappedStatement都有一个Cache对象,就是这里
   Cache cache = ms.getCache();
   // 如果配置文件中没有配置 <cache>,则 cache 为空
   if (cache != null) {
       //如果需要刷新缓存的话就刷新:flushCache="true"
       flushCacheIfRequired(ms);
       if (ms.isUseCache() && resultHandler == null) {
           ensureNoOutParams(ms, boundSql);
           // 访问二级缓存
           List<E> list = (List<E>) tcm.getObject(cache, key);
           // 缓存未命中
           if (list == null) {
               // 如果没有值,则执行查询,这个查询实际也是先走一级缓存查询,一级缓存也没有的话,则进行DB查询
               list = delegate.<E>query(ms, parameterObject, rowBounds,
resultHandler, key, boundSql);
               // 缓存查询结果
               tcm.putObject(cache, key, list);
         
}
           return list;
     }


 
}
 return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

如果设置了flushCache="true",则每次查询都会刷新缓存

<!-- 执行此语句清空缓存 -->
<select id="findbyId" resultType="com.lagou.pojo.user" useCache="true" flushCache="true" >
 
select * from t_demo
</select>

如上,注意二级缓存是从 MappedStatement 中获取的。由于 MappedStatement 存在于全局配置中,可以多个 CachingExecutor 获取到,这样就会出现线程安全问题。除此之外,若不加以控制,多个事务共用一个缓存实例,会导致脏读问题。至于脏读问题,需要借助其他类来处理,也就是上面代码中tcm 变量对应的类型。下面分析一下。

TransactionalCacheManager

/** 事务缓存管理器 */
public class TransactionalCacheManager {
   // Cache 与 TransactionalCache 的映射关系表
   private final Map<Cache, TransactionalCache> transactionalCaches = new
HashMap<Cache, TransactionalCache>();
   public void clear(Cache cache) {
       // 获取 TransactionalCache 对象,并调用该对象的 clear 方法,下同
       getTransactionalCache(cache).clear();
 
}
   public Object getObject(Cache cache, CacheKey key) {
       // 直接从TransactionalCache中获取缓存
       return getTransactionalCache(cache).getObject(key);
 
}
   public void putObject(Cache cache, CacheKey key, Object value) {
       // 直接存入TransactionalCache的缓存中
       getTransactionalCache(cache).putObject(key, value);
 
}
   public void commit() {
       for (TransactionalCache txCache : transactionalCaches.values()) {
           txCache.commit();
     
 
}
}
   public void rollback() {
       for (TransactionalCache txCache : transactionalCaches.values()) {
           txCache.rollback();
     
 
}
}
   private TransactionalCache getTransactionalCache(Cache cache) {
       // 从映射表中获取 TransactionalCache
       TransactionalCache txCache = transactionalCaches.get(cache);
       if (txCache == null) {
           // TransactionalCache 也是一种装饰类,为 Cache 增加事务功能
           // 创建一个新的TransactionalCache,并将真正的Cache对象存进去
           txCache = new TransactionalCache(cache);
           transactionalCaches.put(cache, txCache);
     
}
       return txCache;
 
}
}

TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系,该类也仅负责维护两者的映射关系,真正做事的还是 TransactionalCache。TransactionalCache 是一种缓存装饰器,可以为 Cache 实例增加事务功能。我在之前提到的脏读问题正是由该类进行处理的。下面分析一下该类的逻辑。

TransactionalCache

public class TransactionalCache implements Cache {
   //真正的缓存对象,和上面的Map<Cache, TransactionalCache>中的Cache是同一个
   private final Cache delegate;
   private boolean clearOnCommit;
   // 在事务被提交前,所有从数据库中查询的结果将缓存在此集合中
   private final Map<Object, Object> entriesToAddOnCommit;
   // 在事务被提交前,当缓存未命中时,CacheKey 将会被存储在此集合中
   private final Set<Object> entriesMissedInCache;
   @Override
   public Object getObject(Object key) {
       // 查询的时候是直接从delegate中去查询的,也就是从真正的缓存对象中查询
       Object object = delegate.getObject(key);
       if (object == null) {
           // 缓存未命中,则将 key 存入到 entriesMissedInCache 中
           entriesMissedInCache.add(key);
     
}
       if (clearOnCommit) {
           return null;
     
} else {
           return object;
     
 
}
}
   @Override
   public void putObject(Object key, Object object) {
       // 将键值对存入到 entriesToAddOnCommit 这个Map中中,而非真实的缓存对象 delegate
中
       entriesToAddOnCommit.put(key, object);
 
}
   @Override
   public Object removeObject(Object key) {
       return null;
 
}
   @Override
   public void clear() {
       clearOnCommit = true;
       // 清空 entriesToAddOnCommit,但不清空 delegate 缓存
       entriesToAddOnCommit.clear();
 
}
   public void commit() {
       // 根据 clearOnCommit 的值决定是否清空 delegate
       if (clearOnCommit) {
           delegate.clear();
     
}
       
       // 刷新未缓存的结果到 delegate 缓存中
       flushPendingEntries();
       // 重置 entriesToAddOnCommit 和 entriesMissedInCache
       reset();
 
}
   public void rollback() {
       unlockMissedEntries();
       reset();
 
}
   private void reset() {
       clearOnCommit = false;
       // 清空集合
       entriesToAddOnCommit.clear();
       entriesMissedInCache.clear();
 
}
   private void flushPendingEntries() {
       for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet())
{
           // 将 entriesToAddOnCommit 中的内容转存到 delegate 中
           delegate.putObject(entry.getKey(), entry.getValue());
     
}
       for (Object entry : entriesMissedInCache) {
           if (!entriesToAddOnCommit.containsKey(entry)) {
               // 存入空值
               delegate.putObject(entry, null);
         
     
 
}
}
}
   private void unlockMissedEntries() {
       for (Object entry : entriesMissedInCache) {
           try {
               // 调用 removeObject 进行解锁
               delegate.removeObject(entry);
         
} catch (Exception e) {
               log.warn("...");
         
     
 
}
}
}
}

存储二级缓存对象的时候是放到了TransactionalCache.entriesToAddOnCommit这个map中,但是每次查询的时候是直接从TransactionalCache.delegate中去查询的,所以这个二级缓存查询数据库后,设置缓存值是没有立刻生效的,主要是因为直接存到 delegate 会导致脏数据问题

为何只有SqlSession提交或关闭之后?

那我们来看下SqlSession.commit()方法做了什么

SqlSession

@Override
public void commit(boolean force) {
   try {
       // 主要是这句
       executor.commit(isCommitOrRollbackRequired(force));
       dirty = false;
 
    } catch (Exception e) {
           throw ExceptionFactory.wrapException("Error committing transaction.Cause: " + e, e);
     
    } finally {
           ErrorContext.instance().reset();
     
    }
}


// CachingExecutor.commit()


@Override
public void commit(boolean required) throws SQLException {
   delegate.commit(required);
   tcm.commit();// 在这里
}


// TransactionalCacheManager.commit()


public void commit() {
   for (TransactionalCache txCache : transactionalCaches.values()) {
       txCache.commit();// 在这里
    }
}


// TransactionalCache.commit()
public void commit() {
   if (clearOnCommit) {
       delegate.clear();
    }
   flushPendingEntries();//这一句
   reset();
}


// TransactionalCache.flushPendingEntries()
private void flushPendingEntries() {
   for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
       // 在这里真正的将entriesToAddOnCommit的对象逐个添加到delegate中,只有这时,二级缓存才真正的生效
       delegate.putObject(entry.getKey(), entry.getValue());
 
    }
    
   for (Object entry : entriesMissedInCache) {
       if (!entriesToAddOnCommit.containsKey(entry)) {
           delegate.putObject(entry, null);
        }
    }
}

二级缓存的刷新

我们来看看SqlSession的更新操作

public int update(String statement, Object parameter) {
   int var4;
   try {
       this.dirty = true;
       MappedStatement ms = this.configuration.getMappedStatement(statement);
       var4 = this.executor.update(ms, this.wrapCollection(parameter));
 
} catch (Exception var8) {
       throw ExceptionFactory.wrapException("Error updating database.
Cause: "
+ var8, var8);
 
} finally {
       ErrorContext.instance().reset();
 
}
   return var4;
}
public int update(MappedStatement ms, Object parameterObject) throws
SQLException {
   this.flushCacheIfRequired(ms);
   return this.delegate.update(ms, parameterObject);
}
private void flushCacheIfRequired(MappedStatement ms) {
   //获取MappedStatement对应的Cache,进行清空
   Cache cache = ms.getCache();
   //SQL需设置flushCache="true" 才会执行清空
   if (cache != null && ms.isFlushCacheRequired()) {
 this.tcm.clear(cache);
 
}
}

MyBatis二级缓存只适用于不常进行增、删、改的数据,比如国家行政区省市区街道数据。一但数据变更,MyBatis会清空缓存。因此二级缓存不适用于经常进行更新的数据。

总结:

在二级缓存的设计上,MyBatis大量地运用了装饰者模式,如CachingExecutor, 以及各种Cache接口的装饰器。

• 二级缓存实现了Sqlsession之间的缓存数据共享,属于namespace级别
• 二级缓存具有丰富的缓存策略。
• 二级缓存可由多个装饰器,与基础缓存组合而成
• 二级缓存工作由 一个缓存装饰执行器CachingExecutor和 一个事务型预缓存TransactionalCache完成。

10.4 延迟加载源码剖析：

什么是延迟加载？

问题

在开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我

们所说的延迟加载。

举个栗子

* 在一对多中，当我们有一个用户，它有个100个订单
在查询用户的时候，要不要把关联的订单查出来？
在查询订单的时候，要不要把关联的用户查出来？

* 回答
在查询用户时，用户下的订单应该是，什么时候用，什么时候查询。
在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。

延迟加载

就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。

* 优点：
先从单表查询，需要时再从关联表去关联查询，大大ᨀ高数据库性能，因为查询单表要比关联查询多张表速度要快。

* 缺点：
因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

* 在多表中：
一对多，多对多：通常情况下采用延迟加载
一对一（多对一）：通常情况下采用立即加载

* 注意：
延迟加载是基于嵌套查询来实现的

实现

局部延迟加载

在association和collection标签中都有一个fetchType属性，通过修改它的值，可以修改局部的加载策略。

<!-- 开启一对多 延迟加载 -->
<resultMap id="userMap" type="user">
    <id column="id" property="id"></id>
    <result column="username" property="username"></result>
    <result column="password" property="password"></result>
    <result column="birthday" property="birthday"></result>
    <!--

fetchType="lazy" 懒加载策略

fetchType="eager" 立即加载策略

-->
    <collection property="orderList" ofType="order" column="id"

select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy"></collection>
</resultMap>
<select id="findAll" resultMap="userMap">

SELECT * FROM `user`

</select>

全局延迟加载

在Mybatis的核心配置文件中可以使用setting标签修改全局的加载策略。

<settings>
    <!--开启全局延迟加载功能-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

注意

7.。

<!-- 关闭一对一 延迟加载 -->
<resultMap id="orderMap" type="order">
    <id column="id" property="id"></id>
    <result column="ordertime" property="ordertime"></result>
    <result column="total" property="total"></result>
    <!--

fetchType="lazy" 懒加载策略

fetchType="eager" 立即加载策略

-->
    <association property="user" column="uid" javaType="user"

select="com.lagou.dao.UserMapper.findById" fetchType="eager"></association>
</resultMap>
<select id="findAll" resultMap="orderMap">

SELECT * from orders

</select>

延迟加载原理实现

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

总结：延迟加载主要是通过动态代理的形式实现，通过代理拦截到指定方法，执行数据加载。

延迟加载原理（源码剖析)

MyBatis延迟加载主要使用：Javassist，Cglib实现，类图展示：

Setting配置加载：

public class Configuration
{
    /** aggressiveLazyLoading：
    * 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).
    * 默认为true
    * */
    protected boolean aggressiveLazyLoading;
    /**
    * 延迟加载触发方法
    */
    protected Set < String > lazyLoadTriggerMethods = new HashSet < String > (Arrays.asList(new String[]
    {
        "equals",
        "clone",
        "hashCode",
        "toString"
    }));
    /** 是否开启延迟加载 */
    protected boolean lazyLoadingEnabled = false;
    /**
    * 默认使用Javassist代理工厂
    * @param proxyFactory
    */
    public void setProxyFactory(ProxyFactory proxyFactory)
    {
        if(proxyFactory == null)
        {
            proxyFactory = new JavassistProxyFactory();
        }
        this.proxyFactory = proxyFactory;
    }
    //省略...
}

延迟加载代理对象创建

Mybatis的查询结果是由ResultSetHandler接口的handleResultSets()方法处理的。ResultSetHandler

接口只有一个实现，DefaultResultSetHandler，接下来看下延迟加载相关的一个核心的方法

//#mark 建立结果对象
  private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // reset previous mapping result
    final List<Class<?>> constructorArgTypes = new ArrayList<Class<?>>();
    final List<Object> constructorArgs = new ArrayList<Object>();
    //#mark 建立返回的结果映射的真实对象
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
    if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
      for (ResultMapping propertyMapping : propertyMappings) {
        // issue gcode #109 && issue #149 判断属性有没配置嵌套查询，若是有就建立代理对象
        if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
          //#mark 建立延迟加载代理对象
          resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
          break;
        }
      }
    }
    this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty(); // set current mapping result
    return resultObject;
  }

代理功能实现

因为Javasisst和Cglib的代理实现基本相同，这里主要介绍Javasisstui

ProxyFactory接口定义

public interface ProxyFactory {

  void setProperties(Properties properties);

  /**
   * 建立代理
   * @param target 目标结果对象
   * @param lazyLoader 延迟加载对象
   * @param configuration 配置
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造参数类型
   * @param constructorArgs 构造参数值
   * @return
   */
  Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);
}

默认采用javassistProxy进行代理对象的创建

JavasisstProxyFactory实现

public class JavassistProxyFactory implements org.apache.ibatis.executor.loader.ProxyFactory {

    
    /**
   * 接口实现
   * @param target 目标结果对象
   * @param lazyLoader 延迟加载对象
   * @param configuration 配置
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造参数类型
   * @param constructorArgs 构造参数值
   * @return
   */
  @Override
  public Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
  }

    //省略...
    
  /**
   * 代理对象实现，核心逻辑执行
   */
  private static class EnhancedResultObjectProxyImpl implements MethodHandler {
  
    /**
   * 建立代理对象
   * @param type
   * @param callback
   * @param constructorArgTypes
   * @param constructorArgs
   * @return
   */
  static Object crateProxy(Class<?> type, MethodHandler callback, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {

    ProxyFactory enhancer = new ProxyFactory();
    enhancer.setSuperclass(type);

    try {
      //经过获取对象方法，判断是否存在该方法
      type.getDeclaredMethod(WRITE_REPLACE_METHOD);
      // ObjectOutputStream will call writeReplace of objects returned by writeReplace
      if (log.isDebugEnabled()) {
        log.debug(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
      }
    } catch (NoSuchMethodException e) {
      //没找到该方法，实现接口
      enhancer.setInterfaces(new Class[]{WriteReplaceInterface.class});
    } catch (SecurityException e) {
      // nothing to do here
    }

    Object enhanced;
    Class<?>[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
    Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
    try {
      //建立新的代理对象
      enhanced = enhancer.create(typesArray, valuesArray);
    } catch (Exception e) {
      throw new ExecutorException("Error creating lazy proxy.  Cause: " + e, e);
    }
    //设置代理执行器
    ((Proxy) enhanced).setHandler(callback);
    return enhanced;
  }
  
  
     /**
     * 代理对象执行
     * @param enhanced 原对象
     * @param method 原对象方法
     * @param methodProxy 代理方法
     * @param args 方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object enhanced, Method method, Method methodProxy, Object[] args) throws Throwable {
      final String methodName = method.getName();
      try {
        synchronized (lazyLoader) {
          if (WRITE_REPLACE_METHOD.equals(methodName)) { 
            //忽略暂未找到具体做用
            Object original;
            if (constructorArgTypes.isEmpty()) {
              original = objectFactory.create(type);
            } else {
              original = objectFactory.create(type, constructorArgTypes, constructorArgs);
            }
            PropertyCopier.copyBeanProperties(type, enhanced, original);
            if (lazyLoader.size() > 0) {
              return new JavassistSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
            } else {
              return original;
            }
          } else {
              //延迟加载数量大于0
            if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
                //aggressive 一次加载性全部须要要延迟加载属性或者包含触发延迟加载方法
              if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                log.debug("==> laze lod trigger method:" + methodName + ",proxy method:" + methodProxy.getName() + " class:" + enhanced.getClass());
                //一次所有加载
                lazyLoader.loadAll();
              } else if (PropertyNamer.isSetter(methodName)) {
                //判断是否为set方法，set方法不须要延迟加载
                final String property = PropertyNamer.methodToProperty(methodName);
                lazyLoader.remove(property);
              } else if (PropertyNamer.isGetter(methodName)) {
                final String property = PropertyNamer.methodToProperty(methodName);
                if (lazyLoader.hasLoader(property)) {
                  //延迟加载单个属性
                  lazyLoader.load(property);
                  log.debug("load one :" + methodName);
                }
              }
            }
          }
        }
        return methodProxy.invoke(enhanced, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
  }

注意事项

1. IDEA调试问题 当配置aggressiveLazyLoading=true，在使用IDEA进行调试的时候，如果断点打到代理执行逻辑当中，你会发现延迟加载的代码永远都不能进入，总是会被提前执行。 主要产生的原因在aggressiveLazyLoading，因为在调试的时候，IDEA的Debuger窗体中已经触发了延迟加载对象的方法。

资料

MyBatis源码解读之延迟加载 (opens new window)