Mybatis中的resultMap和resultType 和parameterMap与 parameterType的区别

不念不忘少年蓝@ 2022-01-23 11:15 565阅读 0赞

说实话Mybatis的知识点不少，在之前讲过mybatis的一级缓存与二级缓存（作用于在Executor组件）。而今天的主题是parameterMap 、parameterType、resultType、parameterMap，它们作用于ParameterHandler组件与ResultSetHandler 组件层。如果有人问你这类问题，其实是在考你的基本功（是否知道mybatis的架构或源码），这样才能get到对方关注的点。

在XML 映射文件中随处可用：parameterMap 、parameterType、resultType、parameterMap

  1. <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >
  2.   select 
  3.   <include refid="Base_Column_List" />
  4.   from bas_branchroute
  5.   where branch_route_id = #{branchRouteId,jdbcType=VARCHAR}
  6. </select>
  7. <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >
  8.   delete from bas_branchroute
  9.   where branch_route_id = #{branchRouteId,jdbcType=VARCHAR}
  10. </delete>
  11. <delete id="deleteByExample" parameterType="com.xxx.oms.model.BasBranchrouteExample" >
  12.   delete from bas_branchroute
  13.   <if test="_parameter != null" >
  14.     <include refid="Example_Where_Clause" />
  15.   </if>
  16. </delete>

基本用法

parameterMap

这是引用外部 parameterMap 的已经被废弃的方法。请使用内联参数映射和 parameterType 属性。

parameterType

将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler） 推断出具体传入语句的参数，默认值为未设置（unset）。

resultType

从这条语句中返回的期望类型的类的完全限定名或别名。 注意如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身。可以使用 resultType 或 resultMap，但不能同时使用。

resultMap

外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂映射的情形都能迎刃而解。可以使用 resultMap 或 resultType，但不能同时使用。

数据库不可能永远是你所想或所需的那个样子。 我们希望每个数据库都具备良好的第三范式或 BCNF 范式，而 ResultMap 就是 MyBatis 对这个问题的答案。它支持的元素有constructor（实例化类时注入）、association（关联一个对象）、collection（关联多个对象），可以表示对象间一对一、一对多等关系。更多介绍见官方文档

  1. <!-- 构造方法 -->
  2. <resultMap id="userMap" type="User">
  3.     <constructor>
  4.        <idArg column="id" javaType="int"/>
  5.        <arg column="username" javaType="String"/>
  6.        <arg column="age" javaType="_int"/>
  7.     </constructor>
  8. </resultMap>
  9. <!-- 一对一 -->
  10. <resultMap id="userMap" type="User">
  11.     <id property="id" column="id"></id>
  12.     <result property="username" column="username"></result>
  13.     <result property="password" column="password"></result>
  14.     <result property="address" column="address"></result>
  15.     <result property="email" column="email"></result>
  17.     <association property="role" javaType="Role">
  18.         <id property="id" column="role_id"></id>
  19.         <result property="name" column="role_name"></result>
  20.     </association>
  21. </resultMap>
  22. <!-- 一对多 -->
  23. <resultMap id="userMap" type="User">
  24.     <id property="id" column="id"></id>
  25.     <result property="username" column="username"></result>
  26.     <result property="password" column="password"></result>
  27.     <result property="address" column="address"></result>
  28.     <result property="email" column="email"></result>
  30.     <collection property="roles" ofType="Role">
  31.         <id property="id" column="role_id"></id>
  32.         <result property="name" column="role_name"></result>
  33.     </collection>
  34. </resultMap>
  35. <!-- 一对多：嵌套 Select 查询 -->
  36. <resultMap id="menusMap" type="Menu">
  37.     <id property="id" column="id"></id>
  38.     <result property="name" column="name"></result>
  39.     <result property="url" column="url"></result>
  40.     <result property="m_desc" column="m_desc"></result>
  41.     <result property="parent_id" column="parent_id"></result>
  42.     <!-- ofType="Menu" 对应返回数据的类型-->
  43.     <!--select="getMenus" 指定了SELECT语句的id-->
  44.     <!--column="{parent_id=id}" 则是列的别名，参数的表达式-->
  45.     <collection property="childMenu" ofType="Menu" select="getMenus"  column="{parent_id=id}"></collection>
  46. </resultMap>

系统架构

关键组件

  • SqlSession：selectOne、selectList、selectMap、select、insert、update、delete、commit、rollback、flushStatements、close、clearCache、getConfiguration、getMapper、getConnection
  • Executor：update, query, flushStatements, commit, rollback, getTransaction, close, isClosed
  • StatementHandler：prepare, parameterize, batch, update, query
  • ParameterHandler：getParameterObject, setParameters
  • ResultSetHandler：handleResultSets, handleOutputParameters

内部交互

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70

StatementHandler是非常重要的一层，它主要是对Statement的各种特殊处理（不负责执行），它支持三种Statement、
Prepared、Callable模式，默认值：Prepared。RoutingStatementHandler提供了一种适配模式化的统一入口。

20190625173953308.png

源码解析

你理解了上面的内容，再回头看源码就不复杂了！源码分析基于mybatis-3.4.4版本展开。

ParameterHandler

  1. public interface ParameterHandler {
  2.   //获取参数对象
  3.   Object getParameterObject();
  4.   //设置参数对象
  5.   void setParameters(PreparedStatement ps) throws SQLException;
  6. }
  7. public class DefaultParameterHandler implements ParameterHandler {
  8.     public void setParameters(PreparedStatement ps) {
  9.         ErrorContext.instance().activity("setting parameters").object(this.mappedStatement.getParameterMap().getId());
  10.         List<ParameterMapping> parameterMappings = this.boundSql.getParameterMappings();
  11.         if (parameterMappings != null) {
  12.             for(int i = 0; i < parameterMappings.size(); ++i) {//遍历参数
  13.                 ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);
  14.                 if (parameterMapping.getMode() != ParameterMode.OUT) {
  15.                     String propertyName = parameterMapping.getProperty();//参数名称
  16.                     Object value;//参数值
  17.                     if (this.boundSql.hasAdditionalParameter(propertyName)) {//是否有这个参数
  18.                         value = this.boundSql.getAdditionalParameter(propertyName);//获取参数值
  19.                     } else if (this.parameterObject == null) {
  20.                         value = null;
  21.                     } else if (this.typeHandlerRegistry.hasTypeHandler(this.parameterObject.getClass())) {
  22.                         value = this.parameterObject;
  23.                     } else {
  24.                         MetaObject metaObject = this.configuration.newMetaObject(this.parameterObject);//这个是什么鬼，不急慢慢看
  25.                         value = metaObject.getValue(propertyName);
  26.                     }
  28.                     TypeHandler typeHandler = parameterMapping.getTypeHandler();
  29.                     JdbcType jdbcType = parameterMapping.getJdbcType();
  30.                     if (value == null && jdbcType == null) {
  31.                         jdbcType = this.configuration.getJdbcTypeForNull();
  32.                     }
  34.                     try {
  35.                         typeHandler.setParameter(ps, i + 1, value, jdbcType);
  36.                     } catch (TypeException var10) {
  37.                         throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + var10, var10);
  38.                     } catch (SQLException var11) {
  39.                         throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + var11, var11);
  40.                     }
  41.                 }
  42.             }
  43.         }
  45.     }
  46. }

问题1：确实setParameters()是关键点，它是什么时候被触发的呢？

它分别为 PreparedStatementHandler 和 CallableStatementHandler （执行存储过程）的 parameterize()中被调用。它在构建Statement 时被触发。

  1. public class SimpleExecutor extends BaseExecutor {
  2.   public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  3.     Statement stmt = null;
  4.     try {
  5.       Configuration configuration = ms.getConfiguration();
  6.       StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);
  7.       //构建Statement对象
  8.       stmt = prepareStatement(handler, ms.getStatementLog());
  9.       return handler.<E>query(stmt, resultHandler);
  10.     } finally {
  11.       closeStatement(stmt);
  12.     }
  13.   }
  14.   private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  15.     Statement stmt;
  16.     Connection connection = getConnection(statementLog);
  17.     //此时很关键，最终路径：RoutingStatementHandler.parameterize -> PreparedStatementHandler.parameterize
  18.     stmt = handler.prepare(connection);
  19.     handler.parameterize(stmt);
  20.     return stmt;
  21.   }
  22. }
  23. public class PreparedStatementHandler extends BaseStatementHandler {
  24.   public void parameterize(Statement statement) throws SQLException {
  25.     //最终执行这个
  26.     parameterHandler.setParameters((PreparedStatement) statement);
  27.   }
  28. }

问题2：MetaObject是什么鬼？

MetaObject是将Properties映射为bean属性，实际上就是提供 类|集合|Map 的一种自动识别的访问形式。PropertyTokenizer是的属性分词器，提供了对象和集合的一种概念形式，如: object.parent.name(只是记录了 object 而已,可以通过next方法创建一个对象,返回new PropertyTokenizer(“parent”) 再次调用next 返回new PropertyTokenizer(“name”))。

  1. //基本用法
  2. @Test
  3. public void testGetSet(){
  4.     Animal animal = new Animal();
  5.     //testBean
  6.     MetaObject metaObject = MetaObject.forObject(animal, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
  7.     metaObject.setValue("name","bean");
  8.     System.out.println(animal.getName());
  9.     //testMap
  10.     animal.setName("map");
  11.     Map<String,Animal> map = new HashMap<>();
  12.     metaObject = MetaObject.forObject(map, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
  13.     metaObject.setValue("deer",animal);
  14.     System.out.println(map.get("deer").getName());
  15.     //testCollection
  16.     animal.setName("collection");
  17.     List<Animal> list = new ArrayList<>();
  18.     metaObject = MetaObject.forObject(list, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
  19.     metaObject.add(animal);
  20.     System.out.println(list.get(0).getName());
  21.     //testTokenizer
  22.     animal.setParent(new Animal());
  23.     metaObject = MetaObject.forObject(animal, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
  24.     metaObject.setValue("parent.name","tokenizer");
  25.     System.out.println(animal.getParent().getName());
  26. }
  27. //源码
  28. public class MetaObject {
  29.  private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) {
  30.     this.originalObject = object;//原始对象
  31.     this.objectFactory = objectFactory;
  32.     this.objectWrapperFactory = objectWrapperFactory;
  34.     if (object instanceof ObjectWrapper) {//原始对象为ObjectWrapper
  35.       this.objectWrapper = (ObjectWrapper) object;
  36.     } else if (objectWrapperFactory.hasWrapperFor(object)) {
  37.       this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
  38.     } else if (object instanceof Map) {//原始对象为Map，提供了 object.setName,object.setAge 以及类似 object.getParent().setName(),object.getParent().getParent().setName() 的赋值方式
  39.       this.objectWrapper = new MapWrapper(this, (Map) object);
  40.     } else if (object instanceof Collection) {//原始对象为Collection，提供了集合的add,addAll 方法
  41.       this.objectWrapper = new CollectionWrapper(this, (Collection) object);
  42.     } else {//默认为BeanWrapper，提供的赋值与map相同
  43.       this.objectWrapper = new BeanWrapper(this, object);
  44.     }
  45.   }
  46.   //构建
  47.   public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) {
  48.     if (object == null) {
  49.       return NULL_META_OBJECT;//记录Class相关的getter
  50.     } else {
  51.       return new MetaObject(object, objectFactory, objectWrapperFactory);
  52.     }
  53.   }
  54.   public Object getValue(String name) {
  55.     PropertyTokenizer prop = new PropertyTokenizer(name);
  56.     if (prop.hasNext()) {
  57.       MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
  58.       if (metaValue == MetaObject.NULL_META_OBJECT) {
  59.         return null;
  60.       } else {
  61.         return metaValue.getValue(prop.getChildren());
  62.       }
  63.     } else {
  64.       return objectWrapper.get(prop);
  65.     }
  66.   }
  67.   public void setValue(String name, Object value) {
  68.     //属性分词器，识别属性.符号
  69.     PropertyTokenizer prop = new PropertyTokenizer(name);
  70.     if (prop.hasNext()) {
  71.       MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
  72.       if (metaValue == MetaObject.NULL_META_OBJECT) {
  73.         if (value == null && prop.getChildren() != null) {
  74.           return; // don't instantiate child path if value is null
  75.         } else {
  76.           metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
  77.         }
  78.       }
  79.       metaValue.setValue(prop.getChildren(), value);
  80.     } else {
  81.       objectWrapper.set(prop, value);
  82.     }
  83.   }
  84. }

ResultSetHandler

还是按老的套路，以handleResultSets()为突破口，它主要是对Statement执行后产生的结果集转化成List。

  1. public interface ResultSetHandler {
  2.     //将Statement执行后产生的结果集转化成list
  3.     <E> List<E> handleResultSets(Statement var1) throws SQLException;
  4.     //将Statement执行后产生的结果集转化成cursor
  5.     <E> Cursor<E> handleCursorResultSets(Statement var1) throws SQLException;
  6.     //处理存储过程执行后的输出参数
  7.     void handleOutputParameters(CallableStatement var1) throws SQLException;
  8. }
  9. public class DefaultResultSetHandler implements ResultSetHandler {
  10.   @Override
  11.   public List<Object> handleResultSets(Statement stmt) throws SQLException {
  12.     ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
  14.     final List<Object> multipleResults = new ArrayList<Object>();
  16.     int resultSetCount = 0;
  17.     ResultSetWrapper rsw = getFirstResultSet(stmt);//结果集的第一个结果
  19.     List<ResultMap> resultMaps = mappedStatement.getResultMaps();
  20.     int resultMapCount = resultMaps.size();
  21.     validateResultMapsCount(rsw, resultMapCount);
  22.     while (rsw != null && resultMapCount > resultSetCount) {
  23.       ResultMap resultMap = resultMaps.get(resultSetCount);
  24.       //根据resultMap处理rsw生成java对象，最关键的一步，最终调用getRowValue
  25.       handleResultSet(rsw, resultMap, multipleResults, null);
  26.       //获取结果集的下一个结果
  27.       rsw = getNextResultSet(stmt);
  28.       cleanUpAfterHandlingResultSet();
  29.       resultSetCount++;
  30.     }
  32.     String[] resultSets = mappedStatement.getResultSets();
  33.     if (resultSets != null) {//和resultMaps的遍历处理类似
  34.       while (rsw != null && resultSetCount < resultSets.length) {
  35.         ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
  36.         if (parentMapping != null) {
  37.           String nestedResultMapId = parentMapping.getNestedResultMapId();
  38.           ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
  39.           handleResultSet(rsw, resultMap, null, parentMapping);
  40.         }
  41.         rsw = getNextResultSet(stmt);
  42.         cleanUpAfterHandlingResultSet();
  43.         resultSetCount++;
  44.       }
  45.     }
  47.     return collapseSingleResultList(multipleResults);
  48.   }
  49.   private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
  50.     try {
  51.       if (parentMapping != null) {
  52.         handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
  53.       } else {
  54.         if (resultHandler == null) {
  55.           DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
  56.           //最终会调用getRowValue
  57.           handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
  58.           multipleResults.add(defaultResultHandler.getResultList());
  59.         } else {//最终会调用getRowValue
  60.           handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
  61.         }
  62.       }
  63.     } finally {
  64.       // issue #228 (close resultsets)
  65.       closeResultSet(rsw.getResultSet());
  66.     }
  67.   }
  68.   private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
  69.     final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  70.     //生成对象
  71.     Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
  72.     if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
  73.       final MetaObject metaObject = configuration.newMetaObject(rowValue);
  74.       boolean foundValues = this.useConstructorMappings;
  75.       if (shouldApplyAutomaticMappings(resultMap, false)) {//自动映射
  76.         foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
  77.       }
  78.       //property映射,ResultLoaderMap属性嵌套查询且懒加载
  79.       foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
  80.       foundValues = lazyLoader.size() > 0 || foundValues;
  81.       rowValue = (foundValues || configuration.isReturnInstanceForEmptyRow()) ? rowValue : null;
  82.     }
  83.     return rowValue;
  84.   }
  85.   private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
  86.       throws SQLException {
  87.     final Class<?> resultType = resultMap.getType();
  88.     final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
  89.     final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
  90.     if (hasTypeHandlerForResultObject(rsw, resultType)) {//存在适用的typeHanlder类，事实上一般为基本数据类型或者其封装类
  91.       return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
  92.     } else if (!constructorMappings.isEmpty()) {//有参构造函数的constructor映射
  93.       return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);
  94.     } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {//接口或者无参构造函数
  95.       return objectFactory.create(resultType);
  96.     } else if (shouldApplyAutomaticMappings(resultMap, false)) {//有参构造函数的自动映射
  97.       return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix);
  98.     }
  99.     throw new ExecutorException("Do not know how to create an instance of " + resultType);
  100.   }
  101. }

它的被调用链不复杂，基本上可以直接定位到SimpleStatementHandler。

此外还有一点细节：在xml中select的查询中配置的不是resultMap而是resultType，在mybatis中也是按照resultMap进行存储的，具体验证可看下面源码分析。

  1. public class SimpleStatementHandler extends BaseStatementHandler {
  2.   @Override
  3.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  4.     String sql = boundSql.getSql();
  5.     statement.execute(sql);
  6.     return resultSetHandler.<E>handleResultSets(statement);//直接调用我们关注的方法
  7.   }
  8. }
  9. public class MapperBuilderAssistant extends BaseBuilder {
  10.   //在addMappedStatement方法（构建MappedStatement，它非常关键）中被调用
  11.   private List<ResultMap> getStatementResultMaps(
  12.       String resultMap,
  13.       Class<?> resultType,
  14.       String statementId) {
  15.     resultMap = applyCurrentNamespace(resultMap, true);
  17.     List<ResultMap> resultMaps = new ArrayList<ResultMap>();
  18.     if (resultMap != null) {//resultMap配置支持多个用,分割的resultMap 
  19.       String[] resultMapNames = resultMap.split(",");
  20.       for (String resultMapName : resultMapNames) {
  21.         try {
  22.           resultMaps.add(configuration.getResultMap(resultMapName.trim()));
  23.         } catch (IllegalArgumentException e) {
  24.           throw new IncompleteElementException("Could not find result map " + resultMapName, e);
  25.         }
  26.       }
  27.     } else if (resultType != null) {//resultType会构建一个inlineResultMap
  28.       ResultMap inlineResultMap = new ResultMap.Builder(
  29.           configuration,
  30.           statementId + "-Inline",
  31.           resultType,
  32.           new ArrayList<ResultMapping>(),
  33.           null).build();
  34.       resultMaps.add(inlineResultMap);
  35.     }
  36.     return resultMaps;
  37.   }
  38. }
  39. /**
  40. * StatementHandler中通过它可以获取关于Statement所有细节
  41. **/
  42. public final class MappedStatement {
  44.   private String resource;
  45.   private Configuration configuration;//配置
  46.   private String id;//mapper中的id
  47.   private Integer fetchSize;//batch需要
  48.   private Integer timeout;//超时
  49.   private StatementType statementType;
  50.   private ResultSetType resultSetType;
  51.   private SqlSource sqlSource;//数据源
  52.   private Cache cache;
  53.   private ParameterMap parameterMap;
  54.   private List<ResultMap> resultMaps;
  55.   private boolean flushCacheRequired;
  56.   private boolean useCache;
  57.   private boolean resultOrdered;
  58.   private SqlCommandType sqlCommandType;
  59.   private KeyGenerator keyGenerator;
  60.   private String[] keyProperties;
  61.   private String[] keyColumns;
  62.   private boolean hasNestedResultMaps;
  63.   private String databaseId;
  64.   private Log statementLog;
  65.   private LanguageDriver lang;
  66.   private String[] resultSets;
  67.   public BoundSql getBoundSql(Object parameterObject) {//可执行的sql
  68.   ...
  69.   }
  70. }

看源码其实没有什么技巧，要大胆提问+你的猜想，然后去验证，并从中体会学习优秀的设计。88174217

发表评论

表情：
评论列表 （有 0 条评论，565人围观）

还没有评论，来说两句吧...

相关阅读