文档章节

Mybatis3.4.x技术内幕(二十一):参数设置、结果封装、级联查询、延迟加载原理分析

祖大俊
 祖大俊
发布于 2016/09/16 11:00
字数 3059
阅读 1798
收藏 7

Mybatis在执行查询时,其参数设置、结果封装、级联查询、延迟加载,是最基本的功能和用法,我们有必要了解其工作原理,重点阐述级联查询和延迟加载。

1、MetaObject

MetaObject用于反射创建对象、反射从对象中获取属性值、反射给对象设置属性值,参数设置和结果封装,用的都是这个MetaObject提供的功能。

public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
    if (object == null) {
      return SystemMetaObject.NULL_META_OBJECT;
    } else {
      return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
    }
  }
public Object getValue(String name) {
//...
}
public void setValue(String name, Object value) {
// ...
}

Object object:要反射的对象,比如Student。

ObjectFactory objectFactory:通过Class对象反射创建对象实例的工厂类,比如创建一个Student对象。

ObjectWrapperFactory :对目标对象进行包装,比如可以将Properties对象包装成为一个Map并返回Map对象。

ReflectorFactory :为了避免多次反射同一个Class对象,ReflectorFactory提供了Class对象的反射结果缓存。

getValue(String name):属性取值。

setValue(String name, Object value):属性赋值。

2、参数设置实现原理

<insert id="insertStudent" parameterType="Student" >
		INSERT INTO
		STUDENTS(STUD_ID, NAME, EMAIL, DOB, PHONE)
		VALUES(#{studId}, #{name},
		#{email}, #{dob}, #{phone})
</insert>

Mybatis解析后,上面的#{studId}, #{name}占位符都会被替换为?号占位符,然后给?号设置参数值,Mybatis通过一个反射工具类MetaObject,从Student对象中,反射获取studId、name属性值,并赋值给?号参数。

如果是占位符是#{item.studId},也是一样,通过getValue("item.studId")取值。

详情请参见DefaultParameterHandler.java。

3、结果封装实现原理

Mybatis的结果封装,分为两种,一种是有ResultMap映射表,明确定义了结果集列名与对象属性名的配对关系,另外一种是对象类型,没有明确定义结果集列名与对象属性名的配对关系,如resultType是Student对象。

    <resultMap type="Teacher" id="TeacherResult">
		<id property="id" column="t_id"/>
		<result property="name" column="t_name" />
	</resultMap>
	
	<select id="findAllTeachers" resultMap="TeacherResult">
		SELECT t_id, t_name FROM TEACHERS
	</select>

原理非常简单:使用ObjectFactory ,创建一个Teacher对象实例。

teacher.setId(resultSet.getInt("t_id"));

teacher.setName(resultSet.getString("t_name"));

如果是对象类型,如Student对象类似,原理也非常简单。

<select id="findStudentById" parameterType="int" resultType="Student">
		SELECT STUD_ID AS STUDID, NAME, EMAIL, DOB, PHONE
		FROM STUDENTS WHERE STUD_ID = #{Id}
</select>

原理:使用ObjectFactory ,创建一个Student对象实例。

student.setStudId(resultSet.getInt("STUDID"));

student.setName(resultSet.getString("NAME"));

问题:

1、Student对象只有studId属性,根本没有STUDID属性;Student对象只有name属性,根本没有NAME属性;Java是大小写敏感的编程语言,我凭什么说原理是这样的?瞎说的吧?

2、resultSet.getInt("STUDID"),resultSet.getString("NAME"),我怎么知道一个是Integer,一个是String?

好的博客文章,价值就体现在这些地方,下面我们就来解开谜团。

未映射的结果集列名为[STUDID, NAME, EMAIL, DOB, PHONE]。

public class Reflector {
  private Map<String, String> caseInsensitivePropertyMap = new HashMap<String, String>();
//...
  caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
//...
}

于是caseInsensitivePropertyMap = {STUDID=studId, DOB=dob, PHONE=phone, EMAIL=email, NAME=name}。

于是,resultSet结果集列名和对象属性名之间,就建立起了一对一对应关系。因此,哪怕你把列名写成NaME、pHoNe,它都可以“智能”找到对象属性名,进行赋值操作,Mybatis不愧是一款伟大的开源产品。

caseInsensitive的含义就是忽略结果集列名大小写。

正确找到对象属性名之后,反射获取属性studId的java类型,得到Integer类型,反射获取属性name的java类型得到String类型,Integer类型对应IntegerTypeHandler,String类型对应StringTypeHandler。

于是,resultSet.getInt("STUDID"),resultSet.getString("NAME")就是这么确定的。

详情请参看DefaultResultSetHandler.java源码。

4、级联查询实现原理

级联查询,主要分为一对一关联查询和一对多集合查询,我们研究一下Mybatis是如何实现的。

1、一对一关联查询实现原理(association)

一对一,一个Studen对应一个班级。

举例:假设一个Student对应一个Teacher,如下:

    <resultMap id="studentResult" type="Student">
		<association property="teacher" column="teacher_id"
			javaType="Teacher" select="selectTeacher" />
	</resultMap>
	
	<select id="selectStudent" parameterType="int" resultMap="studentResult">
		SELECT STUD_ID AS STUDID, NAME, EMAIL, DOB, PHONE, TEACHER_ID FROM STUDENTS WHERE STUD_ID = #{id}
	</select>
	
	<select id="selectTeacher" parameterType="int" resultType="Teacher">
		SELECT * FROM TEACHERS WHERE ID = #{id}
	</select>

首先查询Student对象,想要获得该Student对象的属性Teacher teacher对象,那么需要该Student对象的teacher_id值,作为查询Teacher对象的参数,这个语意是易懂的,所以,上面的一对一关联查询,应该很容易看得懂。

作为resultMap标签,其下面的association标签,也会被解析为一个ResultMapping对象。

public class ResultMapping {
  private String property;
  private String column;
  private String nestedQueryId;
//...
}

对于xml配置,ResultMapping={property=teacher, column=teacher_id, nestedQueryId=selectTeacher},其属性nestedQueryId就是用来存储另外一个select查询的id值的。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler.getPropertyMappingValue(ResultSet, MetaObject, ResultMapping, ResultLoaderMap, String)源码。

  private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {
    if (propertyMapping.getNestedQueryId() != null) {
      // 执行另外一个select查询,把查询结果赋值给属性值,比如Student对象的teacher属性。
      return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
    } else if (propertyMapping.getResultSet() != null) {
      addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
      return DEFERED;
    } else {
      final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();
      final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
      return typeHandler.getResult(rs, column);
    }
  }

org.apache.ibatis.executor.resultset.DefaultResultSetHandler.getNestedQueryMappingValue(ResultSet, MetaObject, ResultMapping, ResultLoaderMap, String)源码。

  private Object getNestedQueryMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {
    final String nestedQueryId = propertyMapping.getNestedQueryId();
    final String property = propertyMapping.getProperty();
    final MappedStatement nestedQuery = configuration.getMappedStatement(nestedQueryId);
    final Class<?> nestedQueryParameterType = nestedQuery.getParameterMap().getType();
    final Object nestedQueryParameterObject = prepareParameterForNestedQuery(rs, propertyMapping, nestedQueryParameterType, columnPrefix);
    Object value = null;
    if (nestedQueryParameterObject != null) {
      final BoundSql nestedBoundSql = nestedQuery.getBoundSql(nestedQueryParameterObject);
      final CacheKey key = executor.createCacheKey(nestedQuery, nestedQueryParameterObject, RowBounds.DEFAULT, nestedBoundSql);
      final Class<?> targetType = propertyMapping.getJavaType();
      if (executor.isCached(nestedQuery, key)) {
        executor.deferLoad(nestedQuery, metaResultObject, property, key, targetType);
        value = DEFERED;
      } else {
        // ResultLoader保存了关联查询所需要的所有信息
        final ResultLoader resultLoader = new ResultLoader(configuration, executor, nestedQuery, nestedQueryParameterObject, targetType, key, nestedBoundSql);
        if (propertyMapping.isLazy()) {
          // 执行延迟加载
          // 语意:resultLoader的查询结果将赋值给metaResultObject源对象的property属性,resultLoader的查询参数值来自于metaResultObject源对象属性中。
          // 举例:查询Teacher,赋值给Student的teacher属性,参数来自于查询Student的ResultSet的teacher_id列的值。
          // 由于需要执行延迟加载,将查询相关信息放入缓存,但不执行查询,使用该属性时,自动触发加载操作。
          lazyLoader.addLoader(property, metaResultObject, resultLoader);
          value = DEFERED;
        } else {
          // 不执行延迟加载,立即查询并赋值
          value = resultLoader.loadResult();
        }
      }
    }
    return value;
  }
public ResultLoader(Configuration config, Executor executor, MappedStatement mappedStatement, Object parameterObject, Class<?> targetType, CacheKey cacheKey, BoundSql boundSql) {}

看看ResultLoader的构造函数,它保存了执行一个select查询所需要的所有信息。

2、延迟加载

mybatis-config.xml内全局配置。

<setting name="lazyLoadingEnabled" value="false|true" />
public class ResultLoaderMap {

  private final Map<String, LoadPair> loaderMap = new HashMap<String, LoadPair>();
}

private LoadPair(final String property, MetaObject metaResultObject, ResultLoader resultLoader) {
//...
}

ResultLoader保存了一个select查询所需要的所有信息,那么,将查询结果赋值给metaResultObject源对象的property属性,这些基本信息都缓存至loaderMap内,这就是语意。

举例:查询Teacher,赋值给Student的teacher属性。为了实现延迟加载,产生了一个loaderMap缓存,缓存了查询所需要的所有信息,如果lazyLoadingEnabled=true,先不执行查询。如果lazyLoadingEnabled=false,那么立即执行查询。

我们看看lazyLoadingEnabled=true时的工作原理。

  private static class EnhancedResultObjectProxyImpl implements MethodHandler {
    @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 = null;
            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 {
            // 此处完成延迟加载功能
            if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
              if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                lazyLoader.loadAll();
              } else if (PropertyNamer.isProperty(methodName)) {
                final String property = PropertyNamer.methodToProperty(methodName);
                if (lazyLoader.hasLoader(property)) {
                  lazyLoader.load(property);
                }
              }
            }
          }
        }
        return methodProxy.invoke(enhanced, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
}

JavassistProxyFactory会使用CGLib创建一个Student代理对象,所有调用Student对象方法,都会经过EnhancedResultObjectProxyImpl.invoke()方法的拦截。

于是当调用Student.getTeacher()方法时,才真正去执行查询Teacher的动作并把结果赋值给Student的teacher属性。

如果lazyLoadingEnabled=false,压根就不会创建Student代理对象,直接就是Student对象,并立即执行Teacher查询,然后赋值给Student的teacher属性。

延迟加载原理,就是这么简单。

3、一对多查询原理(collection)

	<resultMap type="Teacher" id="TeacherResult">
		<collection property="students" javaType="ArrayList" column="id" ofType="Student" select="selectStudents"/>
	</resultMap>
	
	<select id="findTeacherById" parameterType="int" resultMap="TeacherResult">
		SELECT * FROM TEACHERS where ID = #{ID}
	</select>
	
	<select id="selectStudents" parameterType="int" resultType="Student">
		SELECT STUD_ID AS STUDID, NAME, EMAIL, DOB, PHONE FROM STUDENTS WHERE TEACHER_ID = #{id}
	</select>

一对多查询原理,和一对一查询原理是一模一样的,都是将结果以List的形式返回,如果是一对一查询,就取List的第0个元素,如果是一对多查询,就直接返回List。

org.apache.ibatis.executor.loader.ResultLoader.loadResult()源码。

  public Object loadResult() throws SQLException {
    List<Object> list = selectList();
    resultObject = resultExtractor.extractObjectFromList(list, targetType);
    return resultObject;
  }

org.apache.ibatis.executor.ResultExtractor.extractObjectFromList(List<Object>, Class<?>)源码。

public Object extractObjectFromList(List<Object> list, Class<?> targetType) {
    Object value = null;
    if (targetType != null && targetType.isAssignableFrom(list.getClass())) {
      value = list;
    } else if (targetType != null && objectFactory.isCollection(targetType)) {
      value = objectFactory.create(targetType);
      MetaObject metaObject = configuration.newMetaObject(value);
      metaObject.addAll(list);
    } else if (targetType != null && targetType.isArray()) {
      Class<?> arrayComponentType = targetType.getComponentType();
      Object array = Array.newInstance(arrayComponentType, list.size());
      if (arrayComponentType.isPrimitive()) {
        for (int i = 0; i < list.size(); i++) {
          Array.set(array, i, list.get(i));
        }
        value = array;
      } else {
        value = list.toArray((Object[])array);
      }
    } else {
      if (list != null && list.size() > 1) {
        throw new ExecutorException("Statement returned more than one row, where no more than one was expected.");
      } else if (list != null && list.size() == 1) {
        value = list.get(0);
      }
    }
    return value;
  }

4、嵌套查询原理

上面的一对一、一对多查询,都需要单独发送额外的sql进行关联对象查询操作,那么嵌套查询,解决的是只需要一个sql,就可以将关联对象也查询出来。

	<resultMap id="studentResult" type="Student">
		<id property="studId" column="stud_id" />
		<association property="teacher" column="teacher_id"
			javaType="Teacher">
			<id property="id" column="teacher_id" />
			<result property="name" column="T_NAME" />
		</association>
	</resultMap>

	<select id="selectStudent" parameterType="int" resultMap="studentResult">
		SELECT
			s.STUD_ID
			,s.TEACHER_ID
			,t.NAME AS T_NAME
		FROM STUDENTS s
			LEFT JOIN TEACHERS t ON s.TEACHER_ID = t.ID
		WHERE s.STUD_ID = #{id}
	</select>

 ResultMapping的属性nestedResultMapId就是用来做这个的。

public class ResultMapping {
  private String nestedResultMapId;
//..
}

org.apache.ibatis.executor.resultset.DefaultResultSetHandler.getRowValue(ResultSetWrapper, ResultMap, CacheKey, String, Object)源码。

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, CacheKey combinedKey, String columnPrefix, Object partialObject) throws SQLException {
    final String resultMapId = resultMap.getId();
    Object resultObject = partialObject;
    if (resultObject != null) {
      final MetaObject metaObject = configuration.newMetaObject(resultObject);
      putAncestor(resultObject, resultMapId, columnPrefix);
      applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, false);
      ancestorObjects.remove(resultMapId);
    } else {
      final ResultLoaderMap lazyLoader = new ResultLoaderMap();
      resultObject = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
      if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final MetaObject metaObject = configuration.newMetaObject(resultObject);
        boolean foundValues = !resultMap.getConstructorResultMappings().isEmpty();
        if (shouldApplyAutomaticMappings(resultMap, true)) {
          foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
        }
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
        putAncestor(resultObject, resultMapId, columnPrefix);
        // 解析NestedResultMappings并封装结果,赋值给源对象的关联查询属性上
        foundValues = applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
        ancestorObjects.remove(resultMapId);
        foundValues = lazyLoader.size() > 0 || foundValues;
        resultObject = foundValues ? resultObject : null;
      }
      if (combinedKey != CacheKey.NULL_CACHE_KEY) {
        nestedResultObjects.put(combinedKey, resultObject);
      }
    }
    return resultObject;
  }

applyNestedResultMappings()方法负责从ResultSet结果集中,封装association映射为指定对象,赋值给metaObject源对象的属性对象上。

一对多嵌套查询。

	<resultMap id="teacherResult" type="Teacher">
		<id property="id" column="TEACHER_ID" />
		<result property="name" column="TEACHER_NAME" />
		<collection property="students" ofType="Student">
			<id property="studId" column="STUD_ID" />
		</collection>
	</resultMap>

	<select id="findTeacherById" parameterType="int" resultMap="teacherResult">
		SELECT
			s.STUD_ID
			,t.ID AS TEACHER_ID
			,t.NAME AS TEACHER_NAME
		FROM TEACHERS t
		LEFT JOIN STUDENTS s ON s.TEACHER_ID = t.ID
		WHERE t.ID = #{id}
	</select>

原理和一对一嵌套查询是一样的。

问题:left join查询,一对一没问题,但是,一对多时,返回记录像下面这样,也就是说一的一端其实也是N条记录,但是它代表的是一个Teacher对象,Mybatis是如何去重的呢?下面的记录,代表1个老师有6个学生,而不是6个老师6个学生。

|          1 | teacher      |      38 |
|          1 | teacher      |      39 |
|          1 | teacher      |      40 |
|          1 | teacher      |      41 |
|          1 | teacher      |      42 |
|          1 | teacher      |      43 |

5、一对多嵌套查询一的一端去重复原理

<id property="studId" column="stud_id" />
public class ResultMap {
  private List<ResultMapping> idResultMappings;
//...
}
public class DefaultResultSetHandler implements ResultSetHandler {
  private final Map<CacheKey, Object> nestedResultObjects = new HashMap<CacheKey, Object>();
//...
}

<id>和<result>标签的区别就在于此,<id>表示唯一标识一条记录的属性,可以有多个<id>标签,代表联合主键。Map<CacheKey, Object> nestedResultObjects就是用来缓存嵌套查询中,记录去重复功能的。

对于上面的6条结果记录,根据<id>标签生成的CacheKey是相同的,类似下面的值:

-540526625:-2232742192:com.mybatis3.mappers.TeacherMapper.teacherResult:TEACHER_ID:1
-540526625:-2232742192:com.mybatis3.mappers.TeacherMapper.teacherResult:TEACHER_ID:1

每次遍历结果集ResultSet时,获取到的Teacher对象,都是第一次生成的Teacher对象,所以,Teacher是同一个,Student则是6个。

  private void handleRowValuesForNestedResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    //...
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      //...
      Object partialObject = nestedResultObjects.get(rowKey);
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject); 
}

详情请参看DefaultResultSetHandler.java。

至此,Mybatis的参数设置、结果封装、级联查询、延迟加载原理就分析结束了。

版权提示:文章出自开源中国社区,若对文章感兴趣,可关注我的开源中国社区博客(http://my.oschina.net/zudajun)。(经过网络爬虫或转载的文章,经常丢失流程图、时序图,格式错乱等,还是看原版的比较好)

© 著作权归作者所有

祖大俊
粉丝 802
博文 32
码字总数 52477
作品 0
昌平
私信 提问
加载中

评论(1)

YIF422
YIF422
mybatis3.4.x不再需要导入cglib和asm包,那mybatis是在哪里实现的延迟加载呢?
Mybatis3.4.x技术内幕(二十三):Mybatis面试问题集锦(大结局)

Mybatis技术内幕系列博客,从原理和源码角度,介绍了其内部实现细节,无论是写的好与不好,我确实是用心写了,由于并不是介绍如何使用Mybatis的文章,所以,一些参数使用细节略掉了,我们的目...

祖大俊
2016/09/17
15.5K
36
MyBatis 源码分析-技术分享

MyBatis 源码分析 这张图总结的很到位:: MyBatis的主要成员 Configuration SqlSession Executor StatementHandler ParameterHandler ResultSetHandler TypeHandler MappedStatement SqlSo......

Java搬砖工程师
03/07
22
0
Mybatis3.4.x技术内幕(二十):PageHelper分页插件源码及原理剖析

PageHelper是一款好用的开源免费的Mybatis第三方物理分页插件,其实我并不想加上好用两个字,但是为了表扬插件作者开源免费的崇高精神,我毫不犹豫的加上了好用一词作为赞美。 原本以为分页插...

祖大俊
2016/09/10
9.2K
6
hibernate annotation

我们都知道hibernate3可以调用存储过程或函数,但是有一定的限制(具体可以查看hibernate官方手册)。 据我分析这段代码应该是用来分析字符串是否是调用存储过程或函数的语句。 解决方法: 1....

blooms
2012/11/15
193
0
MyBatis 源码分析 - SQL 的执行过程

* 本文速览 本篇文章较为详细的介绍了 MyBatis 执行 SQL 的过程。该过程本身比较复杂,牵涉到的技术点比较多。包括但不限于 Mapper 接口代理类的生成、接口方法的解析、SQL 语句的解析、运行...

田小波⊰
2018/08/20
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Java Web 中对 ServletRequest 的一些非常规操作解决方案

1. 前言 ServletRequest 是我们搞 Java Web 经常接触的 Servlet Api 。有些时候我们要经常对其进行一些操作。这里列举一些经常的难点操作。 2. 提取 body 中的数据 前后端交互我们会在 body...

码农小胖哥
37分钟前
2
0
《Dual Encoding U-Net for Retinal Vessel Segmentation》阅读笔记-MICCAI2019

作者:Bo Wang1,2, Shuang Qiu2, and Huiguang He1,2,3 目的:Retinal Vessel Segmentation is an essential step for the early diagnosis of eye-related diseases, such as diabetes and ......

JungleKing
39分钟前
2
0
一次看懂 Https 证书认证

TLS > 传输层安全性协定 TLS(Transport Layer Security),及其前身安全套接层 SSL(Secure Sockets Layer)是一种安全协议,目的是为网际网路通信,提供安全及数据完整性保障。 如图,TLS...

极客收藏夹
54分钟前
5
0
https证书买哪家好?有哪些供应商

在选购https证书前除了要了解类型外,还需要了解https证书供应商,毕竟不同的供应商,提供的产品质量与服务也是有差异的。今天小编就为大家讲讲https证书供应商方面的内容,希望各位会喜欢。...

安信证书
55分钟前
6
0
Zuul 配置

概述:zuul底层是基于servlet,是由一系列的filter链构成。 1、路由配置 a、单例serverId映射 zuul: routes: client-a: path: /client/** serviceId: client-a 意思是...

java框架开发者
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部