MyBatis（技术NeiMu）：基础支持层（类型转换模块与ObjectFactory）

最新推荐文章于 2024-06-12 23:40:32 发布
最新推荐文章于 2024-06-12 23:40:32 发布
阅读量401 收藏
点赞数
分类专栏： MyBatis 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GDUT_Trim/article/details/121456619
版权

回顾

前面我们已经看到了解析器模块和反射模块，下面来看一下类型转换模块

类型转换模块

TypeParameterResolver

TypeParameterResolver是一个工具类，负责提供一系列静态方法来解析指定类中的字段、方法返回值或方法参数的类型

可能有人觉得为什么要进行解析呢？类型直接通过反射不就可以获取了吗？

的确是这样，对于一般类型来说，使用反射就可以获取了，但如果是对于泛型呢？你压根不知道泛型是什么类型？此时就要去进行解析了
在这里插入图片描述
在这里插入图片描述
主要的方法有三个

  • resolveFieldType：解析字段类型的
  • resolverParamTypes：解析方法参数列表中各个参数的类型
  • resolverReturnType：解析方法的返回值类型的
解析字段类型的——resolveFieldType

源码如下

public static Type resolveFieldType(Field field, Type srcType) {
    //获取字段的声明类型，也就是字段的数据类型
    Type fieldType = field.getGenericType();
    //获取字段所在的类的Class对象
    Class<?> declaringClass = field.getDeclaringClass();
    //调用resolveType方法
    return resolveType(fieldType, srcType, declaringClass);
  }

可以看到，对于字段类型的处理主要是交由resolveType方法来处理的

解析方法参数列表中各个参数的类型——resolverParamTypes

源码如下

public static Type[] resolveParamTypes(Method method, Type srcType) {
    //获取方法里面的参数列表
    Type[] paramTypes = method.getGenericParameterTypes();
    //获取方法定义所在的类
    Class<?> declaringClass = method.getDeclaringClass();
    //结果集
    Type[] result = new Type[paramTypes.length];
    //遍历每一个参数
    for (int i = 0; i < paramTypes.length; i++) {
        //每一个参数都使用resolveType进行处理
        //将处理结果存放到结果集中
      result[i] = resolveType(paramTypes[i], srcType, declaringClass);
    }
    //返回结果集
    return result;
  }

可以看到，对于方法参数列中各个参数的类型，也是交由resolveType方法来处理的

解析方法返回值的类型——resolverReturnType

源码如下

public static Type resolveReturnType(Method method, Type srcType) {
    //获取方法的返回值类型
    Type returnType = method.getGenericReturnType();
    //获取方法定义所在的类的Class对象
    Class<?> declaringClass = method.getDeclaringClass();
    //使用resolveType来解析
    return resolveType(returnType, srcType, declaringClass);
  }

可以看到，对于解析返回值类型的，也是交由resolveType方法来解析的！！！

从上面可以知道，无论是字段、方法的参数列表还是方法的返回值，都是交由resolveType方法来处理的，并且这里为什么要进行解析呢？直接反射不就能获取类型了吗？

resolveType

下面就来看看这个resolveType做了什么事情

源码如下

private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
   
    if (type instanceof TypeVariable) {
        //解析TypeVariable类型
      return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
    } else if (type instanceof ParameterizedType) {
        //解析ParameterizedType（）
      return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
    } else if (type instanceof GenericArrayType) {
        //解析GenericArrayType
      return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
    } else {
        //不是上面三种类型的，直接返回Type
      return type;
    }
  }

可以看到，resolveType采用了一个简单的工厂模式，调用不同的方法去解析各种Type，所以首先我们得认识Type接口

Type接口

在这里插入图片描述
可以看到，这是一个JDK1.5出现的接口（用来表明类型的），并且有4个接口继承它，Class类实现了Type接口

  • ParameterizedType：表示的是参数化的类型，既带有泛型的类型，比如List、Map，因为这种通常带有多种类型
    • getRawType：返回参数化类型中的原始类型，比如List，返回的就是List
    • getActualTypeArguments：获取参数化类型的类型变量列表，既相当于获取里面的泛型，比如Map<Integer,String>获取的列表就是Integer和String
    • getOwnerType：返回类型所属的类型，这个是针对内部类的，可以根据内部类去获取外部类的Type，如果本身就是最外部类，获取的就为Null
  • TypeVariable：表示的是类型变量，用来反映JVM编译该泛型前的信息（要注意，这是泛型前的信息，是不知道后续使用时的具体信息的！！！！）
    • getBounds：获取类型变量的上边界，也就是父类，如果没有声明父类那就是为Object，比如Test，那么T的上边界就是Person
    • getGenericDeclaration：获取声明该类型变量的原始类型，比如List，那么获取的就是List
    • getName：获取类型变量在源码中的名字，比如T、K这些
  • GenericArrayType：表示的是数组类型并且组成元素的类型是Parameterized或者TypeVariable的
    • getGenericComponentType：返回数组中的组成元素
  • WildcardType：通配符类型

现在回到我们的resolveType

在这里插入图片描述
可以看到，其仅仅对于下面三种类型做特殊处理

  • TypeVariable：泛型
  • ParameterizedType：带有泛型的类型
  • GenericArrayType：数组类型，并且数组里面是泛型或者带有泛型的类型

对于其他的类型，说白就是与泛型无关的类型，都是直接返回

下面就来看看，是如何对泛型进行处理的

首先我们要理清楚三个参数

  • type：字段、方法参数、方法的返回值的Type
  • declaringClass：字段所属类的类型、方法所属类的类型（Class类型）
  • srcType：来源Type，也就是说从哪个Type里面进行解析，其代表的就是要进行解析的类
resolverParameterizedType

先来看看如何对带有泛型的类型来进行处理的

源码如下

private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) {
    //获取类型变量里面的原始类型
    Class<?> rawType = (Class<?>) parameterizedType.getRawType();
    //获取类型变量里面的泛型类型列表
    Type[] typeArgs = parameterizedType.getActualTypeArguments();
    Type[] args = new Type[typeArgs.length];
    //遍历泛型类型列表
    for (int i = 0; i < typeArgs.length; i++) {
       //如果泛型类型是TypeVariable类型的
      if (typeArgs[i] instanceof TypeVariable) {
          //交由resolveTypeVar方法负责处理
        args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);
      } else if (typeArgs[i] instanceof ParameterizedType) {
          //如果泛型类型又是ParameterizedType的，既又是一个带有泛型的类型
          //交由resolveParameterizedType处理
        args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
      } else if (typeArgs[i] instanceof WildcardType) {
          //如果是wildcardType
          //交由resolveWildcardType方法处理
        args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
      } else {
          //都不是就不进行处理了
        args[i] = typeArgs[i];
      }
    }
    //返回ParameterizedTypeImpl
    return new ParameterizedTypeImpl(rawType, null, args);
  }

可以看到，对于ParameterizedType类型是对类型变量里面的泛型类型列表继续进行拆分的，因为带有类型变量的

resolverTypeVar

再来看看如何解析TypeVariable的

该方法源码如下

private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {
    Type result;
    //clazz存储srcType自身的Class类型
    Class<?> clazz;
    
    //判断srcType是不是Class类型
    //如果是Class类型，那就不带有泛型列表了
    if (srcType instanceof Class) {
        //直接强转成Class类型
      clazz = (Class<?>) srcType;
    } 
    //如果srcType是ParameterizedType
    //证明srcType是一个类型变量
    else if (srcType instanceof ParameterizedType) {
      ParameterizedType parameterizedType = (ParameterizedType) srcType;
        //获取类型变量的原始类型
      clazz = (Class<?>) parameterizedType.getRawType();
    } 
    //其他类型就抛错
    //所以srcType这里只能是Class或者ParameterizedType
    else {
      throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());
    }
	//如果srcType的类型等于declaringClass（声明的类型）
    //这里是判断有没有嵌套了
    //如果clazz == declaringClass
    //代表当前要解析的字段、参数、返回值其实就定义在当前类上
    if (clazz == declaringClass) {
        //如果就位于当前类上，而typeVar是来自于字段的
        //这就说明了字段是来自于当前类的，
        //获取要解析的泛型的上界
      Type[] bounds = typeVar.getBounds();
        //如果有上界
      if (bounds.length > 0) {
          //返回第一个，既第一个父类
          //此时就确认了泛型的类型了！！！！！
          //类型是跟随第一个父类的
        return bounds[0];
      }
        //如果没有上界，返回Object类型
        //代表该泛型为Object.class类型？？？？
        //为什么会返回Object.class？
        //如果判断是在当前类的化，不应该是要从当前类中比较筛选吗？
      return Object.class;
    }
	//如果不是在当前类上，则需要去寻找父类
    Type superclass = clazz.getGenericSuperclass();
    //从父类中进行解析
    result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass);
    if (result != null) {
      return result;
    }
	//父类中没找到，就找接口
    Type[] superInterfaces = clazz.getGenericInterfaces();
    //遍历所有的接口，去进行查找
    for (Type superInterface : superInterfaces) {
      result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface);
      if (result != null) {
        return result;
      }
    }
    return Object.class;
  }

可以看到，其实所谓的解析字段、解析方法参数、解析方法返回值，其实就是去弄清楚这个泛型代表的是什么类型！

首先要解决第一件事，找到这个字段、方法参数或者方法返回值位于的解析类中的哪里？是位于当前解析类上了，还是解析类的父类上了？

  • 判断当前解析类的类型
    • 如果是Class类型，直接转化为Class
    • 如果是ParameterizedType类型，则要转化为RawType（既原始类型）
  • 然后通过比较解析类的类型与字段、方法参数或者方法返回值位于的类的类型是否一致
    • 如果一致，代表就要从字段、方法参数或方法返回值的类型就位于当前解析类中
      • 因为是位于当前类中，所以直接Type
    • 如果不一致，则还要继续往下找
      • 先递归找父类
      • 最后找接口
  • 如果最后都没有，返回Object类型，代表要解析的字段、方法参数或方法返回值为Object类型

下面就来看看是怎么递归找父类的，对应的方法为scanSuperTypes

该方法源码如下

private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) {
    //如果父类也是ParameterizedType类型
    if (superclass instanceof ParameterizedType) {
      ParameterizedType parentAsType = (ParameterizedType) superclass;
        //获取父类的变量类型的原始类型
      Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();
        //获取泛型列表
      TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters();
        //判断要解析的类是不是ParameterizedType
      if (srcType instanceof ParameterizedType) {
          //如果是，要进行translateParentTypeVars方法解析
        parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);
      }
        //如果此时父类是泛型所在类
      if (declaringClass == parentAsClass) {
          //遍历父类的泛型列表
        for (int i = 0; i < parentTypeVars.length; i++) {
            //找到对应的泛型
          if (typeVar.equals(parentTypeVars[i])) {
              //从泛型类型列表里面面返回对应的类型
            return parentAsType.getActualTypeArguments()[i];
          }
        }
      }
        //如果泛型所在类是父类的父类
      if (declaringClass.isAssignableFrom(parentAsClass)) {
          //递归执行resolveTypeVar，继续找下一个父类
        return resolveTypeVar(typeVar, parentAsType, declaringClass);
      }
    }
    //如果父类是一个Class类型，并且泛型所在的类是父类的父类
    //为Class类型就证明没有类型变量了，也就是没有泛型类型列表
    else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) {
        //仍然递归执行resolveTypeVar去再往下寻找
      return resolveTypeVar(typeVar, superclass, declaringClass);
    }
    return null;
  }

//泛型解析看的裂开。。。。。。

ObjectFactory

MyBatis通常使用ObjectFactory来创建指定类型的对象，并且调用的是里面的create方法

在这里插入图片描述
在这里插入图片描述
可以看到ObjectFactory提供了两种create方式

  • 根据Class对象进行Create，猜测应该是无参构造
  • 根据Class对象、指定的参数类型、对应参数类型的值来进行Create，说白了就是指定使用哪个构造器来create，通过参数类型顺序来限制

在这里插入图片描述
而且可以看到，ObjectFactory只有DefaultObjectFactory一个实现类

下面就来看看是如何创建的

在这里插入图片描述

create(Class type)

源码如下

public <T> T create(Class<T> type) {
    return create(type, null, null);
  }

可以看到，其直接调用了重载的指定构造器的方法，并且传的参数类型顺序，类型顺序对应的值为Null而已，所以我们只需要看懂如何根据指定参数类型顺序来创建对象的方法即可

create(Class type,List…)

源码如下

public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    //对接口类型的Class进行处理
    //为什么要处理接口类型呢？之前我们在dao文件里面去接收一个List集合的时候
    //我们给的方法返回值仅仅只是一个List接口，而当查询完数据库，返回数据时，却发现变成了一个ArrayList
    //而这里就是做了这一层的处理
    Class<?> classToCreate = resolveInterface(type);
    // we know types are assignable
    //调用instantiateClass来创建对象
    return (T) instantiateClass(classToCreate, constructorArgTypes, constructorArgs);
  }
处理集合接口

resolveInterface是处理集合理性的接口的

protected Class<?> resolveInterface(Class<?> type) {
    Class<?> classToCreate;
    //如果是List接口、Collection接口、Iterable接口
    if (type == List.class || type == Collection.class || type == Iterable.class) {
        //默认返回一个ArrayList
      classToCreate = ArrayList.class;
    } 
    //如果是Map接口
    else if (type == Map.class) {
        //返回HashMap
      classToCreate = HashMap.class;
    } 
    //如果是SortedSet接口
    else if (type == SortedSet.class) { 
        //返回TreeSet
      classToCreate = TreeSet.class;
    }
    //如果是Set接口
    else if (type == Set.class) {
        //返回一个HashSet
      classToCreate = HashSet.class;
    } 
    //其他类型的就不做处理了
    else {
      classToCreate = type;
    }
    return classToCreate;
  }

规则如下

  • List、Collection、Iterable接口，默认就是ArrayList
  • Map接口默认是HashMap
  • SortedSet接口默认是TreeSet
  • Set接口默认是HashSet
  • 其他接口不做处理
确定好类型后创建对象

对应的方法源码如下

private  <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    try {
      Constructor<T> constructor;
        //如果传进来的构造参数为Null
      if (constructorArgTypes == null || constructorArgs == null) {
          //获取无参构造器
        constructor = type.getDeclaredConstructor();
        try {
            //使用构造器来创建对象
          return constructor.newInstance();
        } catch (IllegalAccessException e) {
            //捕捉构造器为不可以访问的错误
            //Reflector决定是不是可以控制开放权限
          if (Reflector.canControlMemberAccessible()) {
              //修改为可访问
              //继续创建
            constructor.setAccessible(true);
            return constructor.newInstance();
          } else {
            throw e;
          }
        }
      }
        //如果构造参数、构造类型顺序不为空
        //根据传来的构造参数类型顺序找到构造器
      constructor = type.getDeclaredConstructor(constructorArgTypes.toArray(new Class[0]));
      try {
          //使用对应的构造参数来进行创建对象
        return constructor.newInstance(constructorArgs.toArray(new Object[0]));
      } catch (IllegalAccessException e) {
          //同样处理
        if (Reflector.canControlMemberAccessible()) {
          constructor.setAccessible(true);
          return constructor.newInstance(constructorArgs.toArray(new Object[0]));
        } else {
          throw e;
        }
      }
    } catch (Exception e) {
      String argTypes = Optional.ofNullable(constructorArgTypes).orElseGet(Collections::emptyList)
          .stream().map(Class::getSimpleName).collect(Collectors.joining(","));
      String argValues = Optional.ofNullable(constructorArgs).orElseGet(Collections::emptyList)
          .stream().map(String::valueOf).collect(Collectors.joining(","));
      throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + e, e);
    }
  }

可以看到，逻辑非常简单，直接利用反射，根据构造参数的类型顺序来获取构造器，反射来创建对象而已

当然，我们也可以自定义我们的ObjectFactory实现类

GDUT_Ember
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis返回树形结构
BushRo
09-28 6103
在返回json数据时常常需要返回树形的结构，自己去写递归来构建树的话又太麻烦了。 下面介绍一种使用mybatis来返回树形结构的好方法 表结构展示 表里面需要记录父级Id Mybatis xml语句 第一次用过org_id找到符合的数据，返回给orgTreeMap,关键就在这个resultMap里面，有一个集合，集合又去调用了getOrgByParentId方法，该方法把查询的到的org_id，...
Mybatis的结果集处理
weixin_34267123的博客
04-21 3281
2019独角兽企业重金招聘Python工程师标准>>> ...
mybatis中返回结果类型为集合类型（List、Map）
热门推荐
qq_37776015的博客
05-07 3万+
本章节主要讲解如果Mapper接口的返回类型为集合（List、Map）时，如何定义 一、返回结果类型为List Mapper接口的方法： List<Employee> getAll(); EmployeeMapper.xml映射文件： <select id="getAll" resultType="com.wcg.mybatis.entity.Employee"&...
Cannot resolve org.mybatis:mybatis:3.4.5
weixin_41425956的博客
07-02 1万+
最近看黑马的SSM框架视频的时候注意到了这个给问提 maven工程无法导入这个jar包，自己按照mybatis的官方（http://mybatis.org/spring/zh/getting-started.html）把这段dependency修改成了如下所示，结果在之后的代码里面无法使用一些类，就放弃使用官方推荐的方法。 <dependency> <groupId>org.mybatis</groupId> <artifactId>myba
（五）MyBatis源码阅读： MyBatis基础模块-类型转换模块
weixin_55229531的博客
04-05 9163
MyBatis是一个持久层框架ORM框架，实现数据库中数据和Java对象中的属性的双向映射，那么不可避免的就会碰到类型转换的问题，在PreparedStatement为SQL语句绑定参数时，需要从Java类型转换为JDBC类型，而从结果集中获取数据时，则需要从JDBC类型转换为Java类型，所以我们来看下在MyBatis中是如何实现类型的转换的。
Dependency ‘org.mybatis:mybatis:x.x.x‘ not found问题解决方法
weixin_43900321的博客
11-14 7505
在mybatis创建工程时，出现Dependency ‘org.mybatis:mybatis:x.x.x’ not found问题。采用如下链接的解决方案。将最后一步改为reload即可。 maven项目中，添加依赖后，出现"Dependency 'xxxx‘ not found"解决方案 - 程序员大本营 https://www.pianshen.com/article/58841040644/ 侵删 ...
mybatis中的 mybatis-generator:generate 代码生成器的使用
baidu_24545901的博客
03-27 1万+
mybatis当中 有 非常方便快捷使用的 generator，代码生成器，方便开发者使用具体使用方法如下：首先，我们创建一个maven项目，如下图所示：pom.xml 文件中进行如下的配置:&lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan...
springboot整合mybatis-generator报错：Failed to execute goal org.mybatis.generator:mybatis-generator-maven
生命不息，奋斗不止
04-11 1万+
整合时遇到了两个错误： 错误1： Failed to execute goal org.mybatis.generator:mybatis-generator-maven-plugin:1.3.2: generate (default-cli) on project XXX: Execution default-cli of goal org.mybatis.generator:mybatis-...
Cannot resolve plugin org.mybatis.generator:mybatis-generator-maven-plugin:1.3.7.RELEASE
zhihu000的博客
03-10 8267
spring-boot-maven-plugin maven找不到怎么办？ 首先你得确认它有没有版本号， 确认了版本号还不行， 需要确认版本号和 父工程是否一致，需要一直才行 这是我的解决方法。
Mybatis类型转换器使用
Linging_24的博客
04-23 5043
1、mybatis类型转换器，就是Java类型与数据库的类型之间转换的一个中介，由这个转换器可以对类型进行映射，mybatis对于基础类型都有默认类型转换器，你可以自定义类型转换器替代默认的转换器，大多数情况下你无需替代它，但是对于Java中的复杂类型，比如对象想要映射成数据库的json字符串，那么你就可以自定义类型转换器。 mybatis自定义类型转换器可以继承TypeHandler或BaseTypeHandler两个接口，并实现其中的方法。 BaseTypeHandler继承TypeHandler，它们
MyBatis-Flex： 一个优雅的 MyBatis 增强框架
08-04
高性能，MyBatis-Flex 采用独特的技术架构、相比许多同类框架，MyBatis-Flex 的在增删改查等方面的性能均超越其 5~10 倍或以上。更灵动，MyBatis-Flex 支持多主键、多表查询、逻辑删除、乐观锁、数据脱敏、数据加密...
Mybatis实现自定义类型转换器TypeHandler的方法
09-01
Mybatis实现自定义的转换器非常的简单，只需要三步就可以实现自定义类型转换器TypeHandler，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
MyBatis使用自定义TypeHandler转换类型的实现方法
08-26
主要介绍了MyBatis使用自定义TypeHandler转换类型的实现方法，本文介绍使用TypeHandler 实现日期类型的转换，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
generate-mybatis-project:java持久层的mybatis实现代码生成工具
06-13
generate-mybatis-projectjava持久层的mybatis实现代码生成工具
Mybatis自定义类型转换器的使用技巧
08-26
主要介绍了Mybatis自定义类型转换器的使用技巧,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
简单的项目部署脚本（转载）
u010230019的博客
06-09 603
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1232
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 393
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
修改菜品——后端Java
weixin_53717695的博客
06-09 408
修改菜品——后端Java
cannot resolve org.mybatis:mybatis:3.5.7
09-09
问题出现在使用org.mybatis:mybatis:3.5.7时无法解决依赖。这个问题可能有以下几个原因。 首先，我们要确保在构建或部署项目时，配置文件的仓库中包含了指定版本的MyBatis。如果我们正在使用像Maven这样的构建工具，我们需要在pom.xml中添加正确的依赖。 其次，如果我们的网络连接不稳定，或者仓库正在维护中，可能会导致无法解析依赖。我们可以尝试更换镜像源，或者等待网络恢复正常后再次尝试。另外，我们也可以尝试删除本地缓存的依赖，以便重新下载。 另外，还有可能是由于我们所使用的版本与依赖库的版本不兼容造成的。我们应该仔细检查我们所使用的MyBatis版本和其所依赖的其他库的版本是否兼容。我们可以查看MyBatis的官方文档或社区来获取这些信息。 最后，如果以上方法都无效，我们可以尝试手动下载并安装MyBatis库。我们可以从MyBatis的官方网站或其他可信的仓库下载相应版本的库，并将其放入我们项目的依赖文件夹中。然后，我们需要手动在项目中配置该依赖以确保其正确被引入。 总结来说，要解决无法解析org.mybatis:mybatis:3.5.7的问题，我们应该检查依赖配置、网络连接、版本兼容性，并可以尝试手动下载和配置依赖。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值