您现在的位置是:门户> 编程语言> Java

mybatis查询语句揭秘之参数解析
2020-08-29 78人围观 0条评论
简介这篇文章主要给大家介绍了关于mybatis查询语句之参数解析的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用mybatis具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧

    一、前言

    通过前面我们也知道,通过getMapper方式来进行查询,最后会通过mapperMehod类,对接口中传来的参数也会在这个类里面进行一个解析,随后就传到对应位置,与sql里面的参数进行一个匹配,最后获取结果。对于mybatis通常传参(这里忽略掉Rowbounds和ResultHandler两种类型)有几种方式。

    1、javabean类型参数

    2、非javabean类型参数

    注意,本文是基于mybatis3.5.0版本进行分析。

    1、参数的存储

    2、对sql语句中参数的赋值

    下面将围绕这这两方面进行

    二、参数的存储

    先看下面一段代码

    @Test
     public void testSelectOrdinaryParam() throws Exception{
     SqlSession sqlSession = MybatisUtil.getSessionFactory().openSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     List userList = mapper.selectByOrdinaryParam("张三1号");
     System.out.println(userList);
     sqlSession.close();
     }
     List selectByOrdinaryParam(String username); // mapper接口
     
     select
     
     from user
     where username = #{username,jdbcType=VARCHAR}
     

    或许有的人会奇怪,这个mapper接口没有带@Param注解,怎么能在mapper配置文件中直接带上参数名呢,不是会报错吗,

    在mybatis里面,对单个参数而言,直接使用参数名是没问题的,如果是多个参数就不能这样了,下面我们来了解下,mybatis的解析过程,请看下面代码,位于MapperMehod类的内部类MethodSignature构造函数中

    public MethodSignature(Configuration configuration, Class mapperInterface, Method method) {
     Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
     if (resolvedReturnType instanceof Class) {
     this.returnType = (Class) resolvedReturnType;
     } else if (resolvedReturnType instanceof ParameterizedType) {
     this.returnType = (Class) ((ParameterizedType) resolvedReturnType).getRawType();
     } else {
     this.returnType = method.getReturnType();
     }
     this.returnsVoid = void.class.equals(this.returnType);
     this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
     this.returnsCursor = Cursor.class.equals(this.returnType);
     this.returnsOptional = Optional.class.equals(this.returnType);
     this.mapKey = getMapKey(method);
     this.returnsMap = this.mapKey != null;
     this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
     this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
     // 参数解析类
     this.paramNameResolver = new ParamNameResolver(configuration, method);
     }

    参数的存储解析皆由ParamNameResolver类来进行操作,先看下该类的构造函数

    /**
     * config 全局的配置文件中心
     * method 实际执行的方法,也就是mapper接口中的抽象方法
     * 
     */
    public ParamNameResolver(Configuration config, Method method) {
     // 获取method中的所有参数类型
     final Class[] paramTypes = method.getParameterTypes();
     // 获取参数中含有的注解,主要是为了@Param注解做准备
     final Annotation[][] paramAnnotations = method.getParameterAnnotations();
     final SortedMap map = new TreeMap<>();
     // 这里实际上获取的值就是参数的个数。也就是二维数组的行长度
     int paramCount = paramAnnotations.length;
     // get names from @Param annotations
     for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
     // 排除RowBounds和ResultHandler两种类型的参数
     if (isSpecialParameter(paramTypes[paramIndex])) {
     // skip special parameters
     continue;
     }
     String name = null;
     // 如果参数中含有@Param注解,则只用@Param注解的值作为参数名
     for (Annotation annotation : paramAnnotations[paramIndex]) {
     if (annotation instanceof Param) {
      hasParamAnnotation = true;
      name = ((Param) annotation).value();
      break;
     }
     }
     // 即参数没有@Param注解
     if (name == null) {
     // 参数实际名称,其实这个值默认就是true,具体可以查看Configuration类中的该属性值,当然也可以在配置文件进行配置关闭
     // 如果jdk处于1.8版本,且编译时带上了-parameters 参数,那么获取的就是实际的参数名,如methodA(String username)
     // 获取的就是username,否则获取的就是args0 后面的数字就是参数所在位置
     if (config.isUseActualParamName()) {
      name = getActualParamName(method, paramIndex);
     }
     // 如果以上条件都不满足,则将参数名配置为 0,1,2../
     if (name == null) {
      // use the parameter index as the name ("0", "1", ...)
      // gcode issue #71
      name = String.valueOf(map.size());
     }
     }
     map.put(paramIndex, name);
     }
     names = Collections.unmodifiableSortedMap(map);
     }

    这个构造函数的作用就是对参数名称进行一个封装,得到一个  “参数位置-->参数名称 “ 的一个map结构,这样做的目的是为了替换参数值,我们也清楚,实际传过来的参数就是一个一个Object数组结构,我们也可以将它理解为map结构。即 index --> 参数值,此就和之前的 map结构有了对应,也就最终可以得到一个 参数名称  --->  参数值 的一个对应关系。

    public Object execute(SqlSession sqlSession, Object[] args) {
     Object result;
     switch (command.getType()) {
     // 其它情况忽略掉
     case SELECT:
     // 这里参数中含有resultHandler,暂不做讨论
     if (method.returnsVoid() && method.hasResultHandler()) {
      executeWithResultHandler(sqlSession, args);
      result = null;
     } else if (method.returnsMany()) {// 1、 返回结果为集合类型或数组类型,这种情况适用于大多数情况
      result = executeForMany(sqlSession, args);
     } else if (method.returnsMap()) {// 返回结果为Map类型
      result = executeForMap(sqlSession, args);
     } else if (method.returnsCursor()) {
      result = executeForCursor(sqlSession, args);
     } else {// 2、返回结果javabean类型,或普通的基础类型及其包装类等 
      Object param = method.convertArgsToSqlCommandParam(args);
      result = sqlSession.selectOne(command.getName(), param);
      // 对java8中的optional进行了支持
      if (method.returnsOptional() &&
      (result == null || !method.getReturnType().equals(result.getClass()))) {
      result = Optional.ofNullable(result);
      }
     }
     break;
     default:
     throw new BindingException("Unknown execution method for: " + command.getName());
     }
     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;
     }

    这里主要分析1情况。对于2情况也就是接下来要说的参数赋值情况,不过要先介绍下method.convertArgsToSqlCommandParam这代码带来的一个结果是怎么样的

    public Object convertArgsToSqlCommandParam(Object[] args) {
     return paramNameResolver.getNamedParams(args);
     }
    
    public Object getNamedParams(Object[] args) {
     final int paramCount = names.size();
     if (args == null || paramCount == 0) {
     return null;
     } else if (!hasParamAnnotation && paramCount == 1) {// 1
     return args[names.firstKey()];
     } else {
     final Map param = new ParamMap<>();
     int i = 0;
     for (Map.Entry entry : names.entrySet()) {
     param.put(entry.getValue(), args[entry.getKey()]);
     // add generic param names (param1, param2, ...)
     final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
     // ensure not to overwrite parameter named with @Param
     if (!names.containsValue(genericParamName)) {
      param.put(genericParamName, args[entry.getKey()]);
     }
     i++;
     }
     return param;
     }
     }

    可以很清楚的知道最后又调用了ParamNameResolver类的getNamedPaams方法,这个方法的主要作用就是,将原来的参数位置 -->  参数名称  映射关系转为  参数名称 --->参数值 ,并且新加一个参数名和参数值得一个对应关系。即

    param1  ->参数值1

    param2 -->参数值2

    当然如果只有一个参数,如代码中的1部分,若参数没有@Param注解,且只有一个参数,则不会加入上述的一个对象关系,这也就是前面说的,对于单个参数,可以直接在sql中写参数名就ok的原因。下面回到前面

    private  Object executeForMany(SqlSession sqlSession, Object[] args) {
     List result;
     // 获取对应的一个映射关系,param类型有可能为map或null或参数实际类型
     Object param = method.convertArgsToSqlCommandParam(args);
     if (method.hasRowBounds()) {
     RowBounds rowBounds = method.extractRowBounds(args);
     result = sqlSession.selectList(command.getName(), param, rowBounds);
     } else {
     result = sqlSession.selectList(command.getName(), param);
     }
     // 如果返回结果类型和method的返回结果类型不一致,则进行转换数据结构
     // 其实就是result返回结果不是List类型,而是其他集合类型或数组类型
     if (!method.getReturnType().isAssignableFrom(result.getClass())) {
     if (method.getReturnType().isArray()) {// 为数组结果
     return convertToArray(result);
     } else {// 其他集合类型
     return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
     }
     }
     return result;
     }

    代码也不复杂,就是将得到的参数对应关系传入,最终获取结果,根据实际需求进行结果转换。

    3、对sql语句中参数的赋值

    其实前面一篇博客中也有涉及到。参数赋值的位置在DefaultParameterHandler类里面,可以查看前面一篇博客,这里不做过多介绍,传送门  mybatis查询语句的背后之封装数据

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对脚本之家的支持。

分享:

文章评论

    • wxpython 学习笔记 第一天
    • python文本数据处理学习笔记详解