Mybatis查询参数解析与查询结果处理

最新推荐文章于 2024-07-21 00:18:35 发布

氵奄不死的鱼

最新推荐文章于 2024-07-21 00:18:35 发布

阅读量1.7k

点赞数

分类专栏： mybatis 文章标签： mybatis java 数据库

本文链接：https://blog.csdn.net/qq_37436172/article/details/127511514

版权

mybatis 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

查询入参解析

在编写*Mapper.xml时

<insert id="insert" parameterType="com.mybatis.cache.mybatiscache.domain.User">
    insert into user (id, user_name, pass_word, 
      real_name, name)
    values (#{id,jdbcType=INTEGER}, #{userName,jdbcType=VARCHAR}, #{passWord,jdbcType=VARCHAR}, 
      #{realName,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR})
  </insert>

一般会写一个parameterType和jdbcType
那么这个parameterType起什么作用?
那么看这个insert过程来研究
直接看关键方法
org.apache.ibatis.scripting.defaults.DefaultParameterHandler#setParameters

  public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }

ParameterMapping

public class ParameterMapping {

  private Configuration configuration;

  private String property;
  private ParameterMode mode;
  private Class<?> javaType = Object.class;
  private JdbcType jdbcType;
  private Integer numericScale;
  private TypeHandler<?> typeHandler;
  private String resultMapId;
  private String jdbcTypeName;
  private String expression;

有两个重要的属性，分别是javaType，和jdbcType
javaType代表入参java类型
jdbcType是对应数据库类型
可以分别指定

 #{userName,javaType=java.lang.String, jdbcType=VARCHAR}

那么这两个type的作用是什么
用于根据入参和反参获取对用的TypeHandler
那么问题来了，什么是TypeHandler

TypeHandler

public interface TypeHandler<T> {

  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * Gets the result.
   *
   * @param rs
   *          the rs
   * @param columnName
   *          Colunm name, when configuration <code>useColumnLabel</code> is <code>false</code>
   * @return the result
   * @throws SQLException
   *           the SQL exception
   */
  T getResult(ResultSet rs, String columnName) throws SQLException;

  T getResult(ResultSet rs, int columnIndex) throws SQLException;

  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

其中 setParameter 方法用于把 java 对象设置到 PreparedStatement 的参数中，getResult 方法用于从 ResultSet（根据列名或者索引位置获取）或 CallableStatement（根据存储过程获取）中取出数据转换为 java 对象。

主要是实现从resultSet中根据columnName或者columnIndex来获取数据
当我们在javabean中自定义了枚举类型或者其它某个类型，但是在数据库中存储时往往需要转换成数据库对应的类型，并且在从数据库中取出来时也需要将数据库类型转换为javabean中的对应类型。比如：javabean中字段类型为Date，数据库中存储的是varchar类型；javabean中字段类型是Enum，数据库中存储的是String或者Integer。

因为有大量类似数据的转换，手动转换类型进行存储和查询已经过于麻烦。MyBatis为我们提供了解决办法：TypeHandler类型处理器。

MyBatis 中的 TypeHandler 类型处理器用于 JavaType 与 JdbcType 之间的转换，用于 PreparedStatement 设置参数值和从 ResultSet 或 CallableStatement 中取出一个值。MyBatis 内置了大部分基本类型的类型处理器，所以对于基本类型可以直接处理，当我们需要处理其他类型的时候就需要自定义类型处理器。

MyBatis 内置的 TypeHandler

在 MyBatis 的 TypeHandlerRegistry 类型中，可以看到内置的类型处理器。内置处理器比较多，这里整理常见的一些。
BooleanTypeHandler：用于 java 类型 boolean，jdbc 类型 bit、boolean
ByteTypeHandler：用于 java 类型 byte，jdbc 类型 TINYINT
ShortTypeHandler：用于 java 类型 short，jdbc 类型 SMALLINT
IntegerTypeHandler：用于 INTEGER 类型
LongTypeHandler：用于 long 类型
FloatTypeHandler：用于 FLOAT 类型
DoubleTypeHandler：用于 double 类型
StringTypeHandler：用于 java 类型 string，jdbc 类型 CHAR、VARCHAR
ArrayTypeHandler：用于 jdbc 类型 ARRAY
BigDecimalTypeHandler：用于 java 类型 BigDecimal，jdbc 类型 REAL、DECIMAL、NUMERIC
DateTypeHandler：用于 java 类型 Date，jdbc 类型 TIMESTAMP
DateOnlyTypeHandler：用于 java 类型 Date，jdbc 类型 DATE
TimeOnlyTypeHandler：用于 java 类型 Date，jdbc 类型 TIME
对于常见的 Enum 类型，内置了 EnumTypeHandler 进行 Enum 名称的转换和 EnumOrdinalTypeHandler 进行 Enum 序数的转换。这两个类型处理器没有在 TypeHandlerRegistry 中注册，如果需要使用必须手动配置。

自定义 TypeHandler

自定义类型处理器是通过实现 org.apache.ibatis.type.TypeHandler 接口实现的。这个接口定义了类型处理器的基本功能，接口定义如下所示。
其中 setParameter 方法用于把 java 对象设置到 PreparedStatement 的参数中，getResult 方法用于从 ResultSet（根据列名或者索引位置获取）或 CallableStatement（根据存储过程获取）中取出数据转换为 java 对象。
实际开发中，我们可以继承 org.apache.ibatis.type.BaseTypeHandler 类型来实现自定义类型处理器。这个类型是抽象类型，实现了 TypeHandler 的方法进行通用流程的封装，做了异常处理，并定义了几个类似的抽象方法，如下所示。继承 BaseTypeHandler 类型可以极大地降低开发难度。
在这里插入图片描述
实现BaseTypeHandler 指定泛型就是对应的javaType
把TypeHandler配置到程序中有三种方法：
1.在Mapper.xml中声明

<result column="enum1" jdbcType="INTEGER" property="enum1" typeHandler="com.xxx.handler.EnumTypeHandler"/>

2.在mybatis配置文件中设置

<typeHandlers>
        <typeHandler handler="com.xxx.handler.EnumTypeHandler"/>
    </typeHandlers>

3.在springboot的yml配置文件中设置类型处理器所在的包名

mybatis:
  type-handlers-package: com.xxx.handler

注册TypeHandler可以指定jdbcType也可以不指定
org.apache.ibatis.type.TypeHandlerRegistry#register(java.lang.reflect.Type, org.apache.ibatis.type.JdbcType, org.apache.ibatis.type.TypeHandler<?>)

private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) {
      Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {
        map = new HashMap<>();
      }
      map.put(jdbcType, handler);
      typeHandlerMap.put(javaType, map);
    }
    allTypeHandlersMap.put(handler.getClass(), handler);
  }

mybatis内置了很多typeHandler在启动时注册

public TypeHandlerRegistry(Configuration configuration) {
    this.unknownTypeHandler = new UnknownTypeHandler(configuration);

    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    register(Object.class, unknownTypeHandler);
    register(Object.class, JdbcType.OTHER, unknownTypeHandler);
    register(JdbcType.OTHER, unknownTypeHandler);

    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());

    register(Instant.class, new InstantTypeHandler());
    register(LocalDateTime.class, new LocalDateTimeTypeHandler());
    register(LocalDate.class, new LocalDateTypeHandler());
    register(LocalTime.class, new LocalTimeTypeHandler());
    register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
    register(OffsetTime.class, new OffsetTimeTypeHandler());
    register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
    register(Month.class, new MonthTypeHandler());
    register(Year.class, new YearTypeHandler());
    register(YearMonth.class, new YearMonthTypeHandler());
    register(JapaneseDate.class, new JapaneseDateTypeHandler());

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

匹配TypeHandler

private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
    if (ParamMap.class.equals(type)) {
      return null;
    }
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler<?> handler = null;
    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
      if (handler == null) {
        // #591
        handler = pickSoleHandler(jdbcHandlerMap);
      }
    }
    // type drives generics here
    return (TypeHandler<T>) handler;
  }

先通过javaType获取对应的，所有的handler，在根据jdbcType进一步匹配。也就是说，不同 javaType，jdbcType可以指定不同的handler。如果没注册对应的jdbcType，那么使用key为null（通用）的handler处理

parameterType作用

前面说了每个字段可以指定javaType，和jdbcType
那么parmeterType的作用就是自动指定javaType,例如

 <insert id="insert" parameterType="com.mybatis.cache.mybatiscache.domain.User">
    insert into user (id, user_name, pass_word, 
      real_name, name)
    values (#{id,jdbcType=INTEGER}, #{userName,jdbcType=VARCHAR}, #{passWord,jdbcType=VARCHAR},
      #{realName,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR})
  </insert>

public class User {
    private Integer id;

    private String userName;

    private String passWord;

    private String realName;

    private String name;

那么这些字段的javaType会自动匹配到语句的字段上，不需要挨个指定。

不指定javaType和jdbcType

不指定javaType，会自动根据参数类型进行推断

  private TypeHandler<?> resolveTypeHandler(Object parameter, JdbcType jdbcType) {
    TypeHandler<?> handler;
    if (parameter == null) {
      handler = OBJECT_TYPE_HANDLER;
    } else {
      handler = typeHandlerRegistrySupplier.get().getTypeHandler(parameter.getClass(), jdbcType);
      // check if handler is null (issue #270)
      if (handler == null || handler instanceof UnknownTypeHandler) {
        handler = OBJECT_TYPE_HANDLER;
      }
    }
    return handler;
  }

也就是说javaType不指定也没什么关系，只是后面每次执行都要判断一次，从效率的角度看，还是在xml中能够指定的好，指定jdbcType后也会对入参类型进行检查，如果类型步匹配会报错。

 nested exception is org.apache.ibatis.type.TypeException: Could not set parameters for mapping: 
····

不指定jdbcType

根据前面的分析。mybatis不会自动推断jdbcType，如果不指定就会尝试使用jdbcType对应默认的typeHandler处理。因此dbcType还是有必要指定的

查询结果解析

resultMap处理

对结果转换处理时根据resultMap进行转换的

 <resultMap id="BaseResultMap" type="com.mybatis.cache.mybatiscache.domain.User">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="user_name" jdbcType="VARCHAR" property="userName" />
    <result column="pass_word" jdbcType="VARCHAR" property="passWord" />
    <result column="real_name" jdbcType="VARCHAR" property="realName" />
    <result column="name" jdbcType="VARCHAR" property="name" />
  </resultMap>

 <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from user
    where id = #{id,jdbcType=INTEGER}
  </select>

可见，对于结果的处理，也是根据jdbcType和JavaType进行处理
type实体类解析出每个字段的javaType,同时指定了jdbcType

ResultSetHandler

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleResultSets

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

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

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

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

  ·····
  }

获取ResultMap和行记录进行处理
先看org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleRowValuesForSimpleResultMap

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

先介绍下rowBounds是mybatis提供的分页工具用法如下

定义：List<A> testLimit(RowBounds rowBounds); 
使用：testMapper.testLimit(new RowBounds(0, 10))

先根据RowBounds的offset跳过行
对于每一行数据，调用getRowValue进行处理

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    //根据type创建实例
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix)
    foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnP
    return rowValue;
  }

创建实例之后，进入applyPropertyMappings

 private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {
    final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
  
    final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
    for (ResultMapping propertyMapping : propertyMappings) {
      String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
    
        Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);

          // gcode issue #377, call setter on nulls (value is not 'found')
          metaObject.setValue(property, value);
        }
      }
    }
    return foundValues;
  }

简化来看就是根据propertyMappings处理resultSet中的数据。根据javaType和jdbcType完成数据转换
完成之后设置值到对象上
处理完一行记录后

 storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);

ResultHandler

public class DefaultResultHandler implements ResultHandler<Object> {

  private final List<Object> list;

  public DefaultResultHandler() {
    list = new ArrayList<>();
  }

  @SuppressWarnings("unchecked")
  public DefaultResultHandler(ObjectFactory objectFactory) {
    list = objectFactory.create(List.class);
  }

  @Override
  public void handleResult(ResultContext<?> context) {
    list.add(context.getResultObject());
  }

  public List<Object> getResultList() {
    return list;
  }

}

默认的实现就是将结果放到list中
最终返回的就是这个list中的数据。

resultType处理

resultType是sql映射文件中定义一行返回值类型，返回值有基本类型，对象类型，List类型，Map类型等。

基本类型

resultType=基本类型（使用resultSet的每一行的第一列数据作为jdbcType，javaType就是指定的基本类型）

<select id="selectAll" resultType="java.lang.Integer">
    select
    <include refid="Base_Column_List" />
    from user
  </select>

在这里插入图片描述

这样的返回值是每一行的第一列Id值

List类型

： resultType=List中元素的类型

    List<User> selectAll();

 <select id="selectAll" resultType="com.mybatis.cache.mybatiscache.domain.User">
    select
    <include refid="Base_Column_List" />
    from user
  </select>

Map类型

对于map类型那么缺失了javaType，那么返回的字段类型都是根据jdbcTyp推断来的
单条记录：resultType =map

    Map selectAll();

 <select id="selectAll" resultType="java.util.Map">
    select
    <include refid="Base_Column_List" />
    from user
  </select>

               多条记录：resultType =Map中value的类型

    List<Map> selectAll();

对象类型：

对于对象类型resultType直接写对象的全类名就可以了
不过需要注意的是对于返回对象没有resultMapping，mybatis会自动建立映射，但是只有resultType指定的类中的字段与resultSet中的字段完全对上的时候才会生成对应映射

氵奄不死的鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis查询参数解析与查询结果处理

一般会写一个parameterType和jdbcType那么这个parameterType起什么作用? 那么看这个insert过程来研究
复制链接

扫一扫

专栏目录