mybatis3.4.1源代码 - ReturnType、ResultMap.getType()

最新推荐文章于 2022-02-27 15:34:35 发布
最新推荐文章于 2022-02-27 15:34:35 发布
阅读量195 收藏
点赞数
分类专栏： mybatis Java 文章标签： java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiande/article/details/113645438
版权
Java 同时被 2 个专栏收录
133 篇文章 1 订阅
订阅专栏
mybatis
14 篇文章 0 订阅
订阅专栏

ReturnType == ResultMap.getType()
1、实例类
2、list、map的value值类型

 

package cn.java.demo.ibatis.internal.resolve_return_type;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public interface UserMapper {

    // --- void
    void methodRespVoid();

    // --- entity
    UserEntity methodRespEntity();

    // --- array
    UserEntity[] selectListRespArray();

    // --- List
    List<UserEntity> methodRespList();

    List<List<UserEntity>> methodRespListNest1();

    List<List> methodRespListNest2();

    List<UserEntity[]> methodRespListNestArray();

    List<ArrayList> methodRespListNestArrayList0();

    List<ArrayList<UserEntity>> methodRespListNestArrayList1();

    List<ArrayList<?>> methodRespListNestArrayList2();

    List<ArrayList<? extends UserEntity>> methodRespListNestArrayList3();

    List<byte[]> methodRespListNestArrayList4(); // 无效

    // --- Map
    Map<Long, UserEntity> methodRespMap();

    Map<Long, Map<Long, UserEntity>> methodRespMapNest();

}

测试代码

package cn.java.demo.ibatis.internal.resolve_return_type;

import org.apache.ibatis.builder.annotation.MapperAnnotationBuilder;
import org.apache.ibatis.reflection.TypeParameterResolver;
import org.apache.ibatis.session.Configuration;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.lang.reflect.*;
import java.util.Collection;
import java.util.Map;

public class Test {

    public static void main(String[] args) throws Exception {
        Class clazz = UserMapper.class;


        if (false) {
            Method method = clazz.getMethod("insertOne");
            parseParams(method);
        }

        if (true) {
            // void
            {
                if (true) {
                    System.out.println("------方法定义 void methodRespVoid() ------");
                    Method method = clazz.getMethod("methodRespVoid");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType); // class cn.java.demo.ibatis.internal.reflection.UserEntity
                    getReturnType(method, clazz);
                }
            }

            // entity
            {
                if (true) {
                    System.out.println("------方法定义 UserEntity methodRespEntity() ------");
                    Method method = clazz.getMethod("methodRespEntity");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType); // class cn.java.demo.ibatis.internal.reflection.UserEntity
                    getReturnType(method, clazz);
                }
            }

            // array
            {
                if (true) {
                    System.out.println("------方法定义 UserEntity[] selectListRespArray() ------");
                    Method method = clazz.getMethod("selectListRespArray");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType); // class cn.java.demo.ibatis.internal.reflection.UserEntity
                    getReturnType(method, clazz);
                }
            }

            // list
            {
                if (true) {
                    System.out.println("------方法定义 List<UserEntity> methodRespList() ------");
                    Method method = clazz.getMethod("methodRespList");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.reflection.UserEntity]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<List<UserEntity>> methodRespListNest1() ------");
                    Method method = clazz.getMethod("methodRespListNest1");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.reflection.UserEntity]]]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<List> methodRespListNest2() ------");
                    Method method = clazz.getMethod("methodRespListNest2");
                    // ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[interface java.util.List]]
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<UserEntity[]> methodRespListNestArray() ------");
                    Method method = clazz.getMethod("methodRespListNestArray");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[interface java.util.List]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<ArrayList> methodRespListNestArrayList0() ------");
                    Method method = clazz.getMethod("methodRespListNestArrayList0");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[interface java.util.List]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<ArrayList<UserEntity>> methodRespListNestArrayList1() ------");
                    Method method = clazz.getMethod("methodRespListNestArrayList1");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<ArrayList<?>> methodRespListNestArrayList2() ------");
                    Method method = clazz.getMethod("methodRespListNestArrayList2");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<ArrayList<? extends UserEntity>> methodRespListNestArrayList3() ------");
                    Method method = clazz.getMethod("methodRespListNestArrayList3");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 List<byte[]> methodRespListNestArrayList4() ------");
                    Method method = clazz.getMethod("methodRespListNestArrayList4");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }
            }

            // map
            {
                if (true) {
                    System.out.println("------方法定义 Map<Long,UserEntity> methodRespMap() ------");
                    Method method = clazz.getMethod("methodRespMap");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, class cn.java.demo.ibatis.internal.reflection.UserEntity]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }

                if (true) {
                    System.out.println("------方法定义 Map<Long,Map<Long,UserEntity>> methodRespMapNest() ------");
                    Method method = clazz.getMethod("methodRespMapNest");
                    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, clazz);
                    // ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, class cn.java.demo.ibatis.internal.reflection.UserEntity]]]]
                    System.out.println(resolvedReturnType);
                    getReturnType(method, clazz);
                }
            }
        }

        if (false) {
            /**
             * @see org.apache.ibatis.builder.annotation.MapperAnnotationBuilder#parseResultMap(java.lang.reflect.Method)
             * @see org.apache.ibatis.builder.annotation.MapperAnnotationBuilder#getReturnType(java.lang.reflect.Method)
             */
            Method mapperMethod = clazz.getMethod("selectListRespList");

            Method builderMethod = getReturnTypeMethod(MapperAnnotationBuilder.class, "getReturnType");
            if (builderMethod != null) {
                if (!Modifier.isPublic(builderMethod.getModifiers())) {
                    builderMethod.setAccessible(true);
                }

                Configuration configuration = new Configuration();
                MapperAnnotationBuilder parser = new MapperAnnotationBuilder(configuration, clazz);
                Class<?> returnType = (Class<?>) builderMethod.invoke(parser, mapperMethod);
                System.out.println(returnType); // class cn.java.demo.ibatis.internal.reflection.UserEntity
            }
        }
    }


    /**
     * @param method
     * @param type
     * @see org.apache.ibatis.builder.annotation.MapperAnnotationBuilder#getReturnType(java.lang.reflect.Method)
     */
    private static void getReturnType(Method method, Class type) {
        Class<?> returnType = method.getReturnType();
        Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, type);
        if (resolvedReturnType instanceof Class) { //
            // UserEntity methodRespEntity()
            System.out.println("resolvedReturnType instanceof Class");
            returnType = (Class<?>) resolvedReturnType;
            if (returnType.isArray()) {
                // UserEntity[] selectListRespArray()
                System.out.println("returnType.isArray(),returnType = " + returnType);
                returnType = returnType.getComponentType();
                System.out.println("returnType.getComponentType() = " + returnType); // cn.java.demo.ibatis.internal.reflection.UserEntity
            }

            // gcode issue #508
            if (void.class.equals(returnType)) { // 空返回
                // void methodRespVoid()
                System.out.println("void.class.equals(returnType)");
            }
        } else if (resolvedReturnType instanceof ParameterizedType) {
            System.out.println("resolvedReturnType instanceof ParameterizedType");
            ParameterizedType parameterizedType = (ParameterizedType) resolvedReturnType;
            Class<?> rawType = (Class<?>) parameterizedType.getRawType();
            System.out.println("rawType = " + rawType);
            if (Collection.class.isAssignableFrom(rawType)) { // 集合类型
                System.out.println("Collection.class.isAssignableFrom(rawType)");
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                if (actualTypeArguments != null && actualTypeArguments.length == 1) {
                    Type returnTypeParameter = actualTypeArguments[0]; // 元素的类型
                    System.out.println("returnTypeParameter.getTypeName() = " + returnTypeParameter.getTypeName());
                    if (returnTypeParameter instanceof Class<?>) {
                        // List<UserEntity> methodRespList();
                        // List<List> methodRespListNest2();
                        // List<UserEntity[]> methodRespListNestArray();
                        // List<ArrayList> methodRespListNestArrayList0();
                        System.out.println("returnTypeParameter instanceof Class<?>");
                        returnType = (Class<?>) returnTypeParameter;
                    } else if (returnTypeParameter instanceof ParameterizedType) {
                        // List<List<UserEntity>> methodRespListNest1();
                        // List<ArrayList<UserEntity>> methodRespListNestArrayList1()
                        // List<ArrayList<?>> methodRespListNestArrayList2()
                        // List<ArrayList<? extends UserEntity>> methodRespListNestArrayList3()
                        // List<ArrayList[]> methodRespListNestArrayList4()
                        System.out.println("returnTypeParameter instanceof ParameterizedType");
                        returnType = (Class<?>) ((ParameterizedType) returnTypeParameter).getRawType();
                        System.out.println(returnType);
                    } else if (returnTypeParameter instanceof GenericArrayType) { // 这个很难命中
                        // List<java.util.ArrayList<UserEntity>[]>  能命中，会报错；java.util.ArrayList<UserEntity> 不是具体类型
                        // List<T[]> methodName() 能命中，会报错; T 不是具体类型
                        // List<byte[]>  methodName()  框架是为了命中这种类型，但是，实际走不到这个case；(byte[]  instanceof Class<?> ) 会为true
                        System.out.println("((GenericArrayType) returnTypeParameter).getGenericComponentType() = " + ((GenericArrayType) returnTypeParameter).getGenericComponentType().getTypeName());
                        System.out.println("returnTypeParameter instanceof GenericArrayType");
                        Class<?> componentType = (Class<?>) ((GenericArrayType) returnTypeParameter).getGenericComponentType(); // 去掉最右边的 []
                        returnType = Array.newInstance(componentType, 0).getClass();
                    }
                }
            } else if (Map.class.isAssignableFrom(rawType)) { // map类型
                System.out.println("Map.class.isAssignableFrom(rawType)");
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                if (actualTypeArguments != null && actualTypeArguments.length == 2) {
                    Type returnTypeParameter = actualTypeArguments[1]; // value 类型
                    if (returnTypeParameter instanceof Class<?>) {
                        // Map<Long,UserEntity> methodRespMap()
                        System.out.println("returnTypeParameter instanceof Class<?>");
                        returnType = (Class<?>) returnTypeParameter;
                        System.out.println(returnType);
                    } else if (returnTypeParameter instanceof ParameterizedType) {
                        // Map<Long,Map<Long,UserEntity>> methodRespMapNest()
                        System.out.println("returnTypeParameter instanceof ParameterizedType");
                        returnType = (Class<?>) ((ParameterizedType) returnTypeParameter).getRawType();
                        System.out.println(returnType);
                    }
                }
            }
        }
        System.out.println("returnType = " + returnType);
        System.out.println();
    }

    /**
     * 获取指定方法
     */
    private static Method getReturnTypeMethod(Class clazz, String methodName) {
        // Method[] methods = clazz.getMethods(); // 获取所有public
        Method[] methods = clazz.getDeclaredMethods(); // 获取所有声明的方法，包括private
        for (Method method : methods) {
            if (methodName.equals(method.getName())) {
                if ((method.getParameterCount() == 1) && method.getParameterTypes()[0] == Method.class) {
                    return method;
                }
            }
        }
        return null;
    }

    /**
     * 获取指定方法
     */
    private static Method getReturnTypeMethodCannotPrivate(Class clazz, String methodName) throws Exception {
        BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
        MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
        for (MethodDescriptor methodDescriptor : methodDescriptors) {
            Method method = methodDescriptor.getMethod();
            System.out.println(method.getName());
            if (methodName.equals(method.getName())) {
                if ((method.getParameterCount() == 1) && method.getParameterTypes()[0] == Method.class) {
                    return method;
                }
            }
        }
        return null;
    }

    private static void parseParams(Method method) {
        System.out.println(method.getParameterTypes()[0]); // interface java.util.List

        Type genericType = method.getGenericParameterTypes()[0];
        if (!(genericType instanceof ParameterizedType)) { // 泛型类型是：可以参数化的类型，如 List<?>
            return;
        }

        ParameterizedType parameterizedType = (ParameterizedType) genericType;
        System.out.println(parameterizedType); // java.util.List<cn.java.demo.ibatis.internal.reflection.UserEntity>

        Class<?> clazz = (Class<?>) parameterizedType.getActualTypeArguments()[0]; // 具体类型
        System.out.println(clazz); // class cn.java.demo.ibatis.internal.reflection.UserEntity
    }

}

 

 

执行结果

------方法定义 void methodRespVoid() ------
void
resolvedReturnType instanceof Class
void.class.equals(returnType)
returnType = void

------方法定义 UserEntity methodRespEntity() ------
class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity
resolvedReturnType instanceof Class
returnType = class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity

------方法定义 UserEntity[] selectListRespArray() ------
class [Lcn.java.demo.ibatis.internal.resolve_return_type.UserEntity;
resolvedReturnType instanceof Class
returnType.isArray(),returnType = class [Lcn.java.demo.ibatis.internal.resolve_return_type.UserEntity;
returnType.getComponentType() = class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity
returnType = class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity

------方法定义 List<UserEntity> methodRespList() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = cn.java.demo.ibatis.internal.resolve_return_type.UserEntity
returnTypeParameter instanceof Class<?>
returnType = class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity

------方法定义 List<List<UserEntity>> methodRespListNest1() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]
returnTypeParameter instanceof ParameterizedType
interface java.util.List
returnType = interface java.util.List

------方法定义 List<List> methodRespListNest2() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[interface java.util.List]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = java.util.List
returnTypeParameter instanceof Class<?>
returnType = interface java.util.List

------方法定义 List<UserEntity[]> methodRespListNestArray() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class [Lcn.java.demo.ibatis.internal.resolve_return_type.UserEntity;]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = cn.java.demo.ibatis.internal.resolve_return_type.UserEntity[]
returnTypeParameter instanceof Class<?>
returnType = class [Lcn.java.demo.ibatis.internal.resolve_return_type.UserEntity;

------方法定义 List<ArrayList> methodRespListNestArrayList0() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class java.util.ArrayList]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = java.util.ArrayList
returnTypeParameter instanceof Class<?>
returnType = class java.util.ArrayList

------方法定义 List<ArrayList<UserEntity>> methodRespListNestArrayList1() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]
returnTypeParameter instanceof ParameterizedType
class java.util.ArrayList
returnType = class java.util.ArrayList

------方法定义 List<ArrayList<?>> methodRespListNestArrayList2() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[org.apache.ibatis.reflection.TypeParameterResolver$WildcardTypeImpl@7a81197d]]]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[org.apache.ibatis.reflection.TypeParameterResolver$WildcardTypeImpl@5ca881b5]]
returnTypeParameter instanceof ParameterizedType
class java.util.ArrayList
returnType = class java.util.ArrayList

------方法定义 List<ArrayList<? extends UserEntity>> methodRespListNestArrayList3() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[org.apache.ibatis.reflection.TypeParameterResolver$WildcardTypeImpl@24d46ca6]]]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = ParameterizedTypeImpl [rawType=class java.util.ArrayList, ownerType=null, actualTypeArguments=[org.apache.ibatis.reflection.TypeParameterResolver$WildcardTypeImpl@4517d9a3]]
returnTypeParameter instanceof ParameterizedType
class java.util.ArrayList
returnType = class java.util.ArrayList

------方法定义 List<byte[]> methodRespListNestArrayList4() ------
ParameterizedTypeImpl [rawType=interface java.util.List, ownerType=null, actualTypeArguments=[class [B]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.List
Collection.class.isAssignableFrom(rawType)
returnTypeParameter.getTypeName() = byte[]
returnTypeParameter instanceof Class<?>
returnType = class [B

------方法定义 Map<Long,UserEntity> methodRespMap() ------
ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.Map
Map.class.isAssignableFrom(rawType)
returnTypeParameter instanceof Class<?>
class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity
returnType = class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity

------方法定义 Map<Long,Map<Long,UserEntity>> methodRespMapNest() ------
ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, ParameterizedTypeImpl [rawType=interface java.util.Map, ownerType=null, actualTypeArguments=[class java.lang.Long, class cn.java.demo.ibatis.internal.resolve_return_type.UserEntity]]]]
resolvedReturnType instanceof ParameterizedType
rawType = interface java.util.Map
Map.class.isAssignableFrom(rawType)
returnTypeParameter instanceof ParameterizedType
interface java.util.Map
returnType = interface java.util.Map

 

 

 

 

_jan_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis详解-(15)返回结果封装
jinjin603的博客
12-17 2169
前面介绍的内容查询结果基本都是返回一个数据，然后将数据对应某一个对象。本篇探索一下多种不同类型的返回结果，mybatis是如何封装的。1.返回list创建Employee对象package org.mybatis.returntype;import org.apache.ibatis.type.Alias;@Alias("empp") public class Employee { priv
ibatis使用枚举类型的用法
Robert_mm的专栏
09-23 4090
ibatis，鸟菜的理解就是：为java对象(通常是javabean)和数据库之间建立的一种映射关系。这种关系的存在，使得DBA不用去花时间了解JAVA代码，仅需要对sqlmap.xml文件进行审阅；同样使得java程序员不必过分关心于JDBC编写，只需要一种简单的映射关系，即可实现高效稳定的数据库操作。 差点跑题。对于DO(DataObject)中的枚举类型，如何实现同普通类型一样存取呢？刚接
mybatis中resultType返回类型
现役码农的博客
09-13 8万+
mybatis中resultType可选类型: 1，java的基础类型及其包装类int,double和java.lang.Integer,java.lang.Double等 2，实体类，自己定义的实体类 3，map类型，如果使用resultMap这里可以使用自定义map，本文只介绍resultType 4，集合，即返回的时一个List集合，其中该集合的类型可以为1,2,3中提到的类型 ...
mybatis中returnType以及returnMap之间的区别
西油骄子--Debug
06-12 8415
源码下载地址一、概念认识returnType和returnMap都是mybatis查询标签select用于结果映射结果的标签，既然我们讲到select映射，那我们首先了解下select标签到底是什么？包含哪些属性？select主要包含：returnType:将查询结果直接映射到实体对象中，原理中其实mybatis幕后创建一个returnMap且会自动将结果映射到returnType指向的类中。re...
深入理解Mybatis中的resultType和resultMap
09-01
给大家介绍了mybatis中的resultType和resultMap的用法实例讲解，MyBatis中在查询进行select映射的时候，返回类型可以用resultType，也可以用resultMap，至于两种用法区别，通过本文一起学习吧
mybatis-3-config.dtd mybatis-3-mapper.dtd
10-13
在MyBatis中，`mybatis-3-config.dtd` 和 `mybatis-3-mapper.dtd` 是两个至关重要的文件，它们定义了MyBatis配置文件的DTD（Document Type Definition），是理解和使用MyBatis的基础。 `mybatis-3-config.dtd` 文件...
mybatis-plus-boot-starter-3.5.1-API文档-中文版.zip
05-09
赠送源代码：mybatis-plus-boot-starter-3.5.1-sources.jar； 赠送Maven依赖信息文件：mybatis-plus-boot-starter-3.5.1.pom； 包含翻译后的API文档：mybatis-plus-boot-starter-3.5.1-javadoc-API文档-中文(简体)版...
从零搭建SpringBoot+MyBatis+MySQL
xfxuezhang.cn
05-08 1万+
目录创建工程了解MVC模型属性配置文件.ymlspringboot里的数据库布局创建包创建数据表创建实体类DAO（model）创建mapper语句直接写在class中（全注解方式）语句写...
【java】Mybatis返回int类型为空时报错 attempted to return null from a method with a primitive return type (int）
哈士奇
09-02 6万+
一、前言      在往常敲代码的时候没有留意过int和Integer的区别，今天在敲代码的时候，ORM框架使用的是Mybatis，一个简单的查询，返回查询的条数。当查询为null的时候，就报错了。二、报的错误      试图从具有原始返回类型（int）的方法返回nullorg.apache.ibatis.binding.BindingException: Mapper method 'com.dm
深入了解MyBatis返回值
偶尔记一下 - mybatis.io
06-10 12万+
深入了解MyBatis返回值想了解返回值，我们需要了解resultType,resultMap以及接口方法中定义的返回值。我们先看resultType和resultMapresultType和resultMap大家应该都知道在MyBatis的<select>标签中有两种设置返回值的方式，分别是resultMap和resultType。处理resultMap和resultType的代码如下：priva
mybatis resultType 返回类型汇总：
是我，君柳下
03-27 8314
1.返回List&lt;Map&lt;String,Object&gt;&gt; &lt;select id="getMyCredit"  parameterType="java.util.Map" resultType="java.util.HashMap"&gt;&lt;/select&gt;这样设置返回类型为resultClass="java.util.HashMap&
org.apache.ibatis.binding.BindingException:( Mapper method has an unsupported return type)
WHYW13的博客
02-27 4887
一.因为是org.apache.ibatis.binding.BindingException错误，所以一直以为的原因以下几种 1.mapper接口(GoodsMapper.java)是否与mapper.xml(GoodsMapper)是否在同一个包下，但因为我写的是SpringBoot项目，所以说，是肯定不在一起的，只需要在mapper.xml中引入mapper接口的即可，如下： mapper namespace="com.wonderment.assembly.mapper.GoodsMappe..
ibatis的查询操作
weixin_34121304的博客
06-23 140
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis源码解析之查询流程
0xZzzz的博客
01-20 5631
阅读须知 Mybatis源码版本：3.4.4 注释规则： //单行注释做普通注释 /**/多行注释做深入分析 建议配合Mybatis源码阅读 正文 上篇文章中我们分析mapper的创建，Mybatis用JDK动态代理为mapper创建代理类，其中MapperProxy作为InvocationHandler角色，所以调用目标mapper方法时会执行其invoke方法，我们来分析Mapp
MyBatis中ResultMap详解
z19799100的博客
02-24 1万+
简介： MyBatis的每一个查询映射的返回类型都是ResultMap，只是当我们提供的返回类型属性是resultType的时候，MyBatis对自动的给我们把对应的值赋给resultType所指定对象的属性，而当我们提供的返回类型是resultMap的时候，将数据库中列数据复制到对象的相应属性上，可以用于复制查询，两者不能同时用。 resultMap 元素是 MyBatis 中最重要最强大的元素...
Spring 泛型处理
通往神秘的道路的专栏
09-23 1453
Java 泛型基础 • 泛型类型 泛型类型是在类型上参数化的泛型类或接口 • 泛型使用场景 编译时强类型检查 避免类型强转 实现通用算法 Java 泛型基础 泛型类型擦写 泛型被引入到 Java 语言中，以便在编译时提供更严格的类型检查并支持泛型编程。类型擦除确保不会为参数化类型创建新类；因此，泛型不会产生运行时开销。为了实现泛型，编译器将类型擦除应用于： • 将泛型类型中的所有类型参数替换为其边界，如果类型参数是无边界的，则将其替换为 “Object”。因此，生成的字节码只包含普通类、接口和方法。
Mybatis中的resultType和resultMap
热门推荐
JAVA前线技术专栏
05-29 16万+
一、概述 MyBatis中在查询进行select映射的时候，返回类型可以用resultType，也可以用resultMap，resultType是直接表示返回类型的，而resultMap则是对外部ResultMap的引用，但是resultType跟resultMap不能同时存在。 在MyBatis进行查询映射时，其实查询出来的每一个属性都是放在一个对应的Map里面的，其中键是属性名，值则是其对
跟着小马哥学系列之 Spring IoC（进阶篇：泛型处理）
qq_42419406的博客
06-03 436
学成路更宽，吊打面试官。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring核心编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 分为基础篇、进阶篇、源码篇。玩游戏看颜色，学技术看版本，本系列以 Spring 5.2.0.RELEASE 版本为基础进行介绍。 祝小伙伴早日学有所成。 ...
- src - main - java - com.example - controller - UserController.java - dao - UserDAO.java - pojo - User.java - service - UserService.java - UserServiceImpl.java - resources - mybatis - MyBatisConfig.xml - mapper - UserMapper.xml - spring - SpringConfig.xml - SpringMVCConfig.xml - applicationContext.xml - webapp - WEB-INF - pages - login.jsp - register.jsp - userList.jsp - updateUser.jsp - web.xml
最新发布
06-08
其中的src目录是Java源代码的根目录，包含了MVC模式中的控制器（controller）、数据访问对象（dao）、实体类（pojo）和服务接口（service），以及配置文件（resources目录下的mybatis、spring）。同时，webapp目录下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值