Mybatis源码（六）— TypeHandlerRegistry

已于 2023-08-01 18:08:07 修改
阅读量564 收藏
点赞数
分类专栏： Mybatis源码 文章标签： mybatis
于 2023-05-10 23:26:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43936962/article/details/130611420
版权
文章详细介绍了Mybatis中TypeHandler接口及其作用，它是处理数据库查询结果与Java类型转换的关键。TypeHandlerRegistry是TypeHandler的注册管理器，在Configuration初始化时进行配置，用于不同JdbcType和Java类型的映射。此外，文章还提到了别名处理类TypeAliasRegistry，方便对Java类型使用别名。
摘要由CSDN通过智能技术生成

Type

TypeHandlerRegistry是在Mybatis源码中type包下，该包下主要的类主要都是用来进行类型转换（数据库查询出来结果后，将数据库类型转换成Java类型，原生JDBC时是PareparedStatement.setXXX），其中TypeHandler接口定义了规范。

package org.apache.ibatis.type;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 类型转换器的根接口
 * @author Clinton Begin
 */
public interface TypeHandler<T> {
  //设置参数
  // 在通过PreparedStatement为SQL语句绑定参数时，会将数据由Java类型转换成JdbcType类型
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * 从ResultSet中获取数据时会调用此方法，会将数据由JdbcType类型转换成Java类型
   */
  //获取结果
  T getResult(ResultSet rs, String columnName) throws SQLException;

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

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

}

package org.apache.ibatis.type;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @author Clinton Begin
 */
public class DoubleTypeHandler extends BaseTypeHandler<Double> {

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Double parameter, JdbcType jdbcType)
      throws SQLException {
    ps.setDouble(i, parameter);
  }

  @Override
  public Double getNullableResult(ResultSet rs, String columnName)
      throws SQLException {
    double result = rs.getDouble(columnName);
    return result == 0 && rs.wasNull() ? null : result;
  }

  @Override
  public Double getNullableResult(ResultSet rs, int columnIndex)
      throws SQLException {
    double result = rs.getDouble(columnIndex);
    return result == 0 && rs.wasNull() ? null : result;
  }

  @Override
  public Double getNullableResult(CallableStatement cs, int columnIndex)
      throws SQLException {
    double result = cs.getDouble(columnIndex);
    return result == 0 && cs.wasNull() ? null : result;
  }

}

TypeHandlerRegistry

因为包中需要映射的类型太多，使用时并不能明确知道需要什么类型，所以会将类都放到TypeHandlerRegistry进行管理，TypeHandlerRegistry
则会在Configuration类初始化时进行初始化操作，TypeHandlerRegistry的初始化操作会为各个TypeHandler赋值。

/**
 * 类型处理器注册机
 * @author Clinton Begin
 * @author Kazuki Shimizu
 */
public final class TypeHandlerRegistry {
  // 记录JdbcType与TypeHandler之间的对应关系，其中JdbcType是一个枚举类型，它对应对应的JDBC类型
  // 该集合主要用于从结果集读取数据时，将数据从Jdbc类型转换成Java类型
  private final Map<JdbcType, TypeHandler<?>>  jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);
  // 记录了Java类型向指定JdbcType转换时，需要使用TypeHandler对象
  private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();
  private final TypeHandler<Object> unknownTypeHandler;
  // 记录了全部TypeHandler的类型以及该类型相关的TypeHandler对象
  private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();

  // 空TypeHandler集合的标识
  private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();

  private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;

  /**
   * The default constructor.
   */
  public TypeHandlerRegistry() {
    this(new Configuration());
  }

 public TypeHandlerRegistry(Configuration configuration) {
    //构造函数里注册系统内置的类型处理器
    //以下是为多个类型注册到同一个handler
    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());

    //以下是为同一个类型的多种变种注册到多个不同的handler
    register(Reader.class, new ClobReaderTypeHandler());
    // StringTypeHandler能够将数据从String类型转换成null类型，所以向typeHandlerMap集合注册该对象，并向allTypeHandlersMap集合注册StringTypeHandler
    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());
    // NStringTypeHandler能够将数据从String类型转换成NVARCHAR,所以向typeHandlerMap集合注册该对象，并向allTypeHandlersMap集合注册NStringTypeHandler
    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());
  }
	//省略部分代码。。。
}

Alias

type包下，不仅有typeHandler的处理，还有关于Alias（别名）的处理。因为Java下的数据类型非常多，所以如果使用别名会很方便，而TypeAliasRegistry就是用来进行别名的映射处理。同样，也是在Configuration类加载时进行初始化。如果typeAliases（Map<String, Class<?>>）集合中，找不到对应的alias类型，则也会使用(Class) Resources.classForName(string);进行加载。
如果在mybatis-config.xml配置文件中，配置了Alias标签，则会在加载mybatis-config.xml文件中进行解析，并注册到TypeAliasRegistry中。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Alias {
  /**
   * Return the alias name.
   *
   * @return the alias name
   */
  String value();
}

public class TypeAliasRegistry {

  private final Map<String, Class<?>> typeAliases = new HashMap<>();

  public TypeAliasRegistry() {
    //构造函数里注册系统内置的类型别名
    registerAlias("string", String.class);
    //基本包装类型
    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    //基本数组包装类型
    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    //加个下划线，就变成了基本类型
    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    //加个下划线，就变成了基本数组类型
    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    //日期数字型
    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    //集合型
    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    //还有个ResultSet型
    registerAlias("ResultSet", ResultSet.class);
  }

  @SuppressWarnings("unchecked")
  // throws class cast exception as well if types cannot be assigned
  //解析类型别名
  public <T> Class<T> resolveAlias(String string) {
    try {
      if (string == null) {
        return null;
      }
      // issue #748
      // 先转成小写再解析
      String key = string.toLowerCase(Locale.ENGLISH);
      Class<T> value;
      //从HashMap里找对应的键值，找到则返回类型别名对应的Class
      if (typeAliases.containsKey(key)) {
        value = (Class<T>) typeAliases.get(key);
      } else {
        //找不到，再试着将String直接转成Class(这样怪不得我们也可以直接用java.lang.Integer的方式定义，也可以就int这么定义)
        value = (Class<T>) Resources.classForName(string);
      }
      return value;
    } catch (ClassNotFoundException e) {
      throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
  }

  public void registerAliases(String packageName) {
    registerAliases(packageName, Object.class);
  }

  //扫描并注册包下所有继承于superType的类型别名
  public void registerAliases(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    // 查找指定包下的superType类型类
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for (Class<?> type : typeSet) {
      // 过滤掉内部类、接口以及抽象类
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }

  //注册类型别名
  public void registerAlias(Class<?> type) {
    // 类的简单名称（不包含包名）
    String alias = type.getSimpleName();
    // 读取@Alias注解
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    }
    // 检测此别名不存在后，会将其记录到typeAlias集合中
    registerAlias(alias, type);
  }

  //注册类型别名
  public void registerAlias(String alias, Class<?> value) {
    // 检测alias为null，则直接抛出异常
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    // 将别名转换为小写
    String key = alias.toLowerCase(Locale.ENGLISH);
    // 检测别名是否已经存在
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
    }
    // 注册别名
    typeAliases.put(key, value);
  }

  public void registerAlias(String alias, String value) {
    try {
      registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
      throw new TypeException("Error registering type alias " + alias + " for " + value + ". Cause: " + e, e);
    }
  }

  /**
   * Gets the type aliases.
   *
   * @return the type aliases
   * @since 3.2.2
   */
  public Map<String, Class<?>> getTypeAliases() {
    return Collections.unmodifiableMap(typeAliases);
  }
}
善良的Leexx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TypeHandlerRegistry 注册handler
javalj的博客
09-17 1592
age org.apache.ibatis.type; import java.io.InputStream; import java.io.Reader; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.math....
mybatis底层组件介绍-TypeHandler和TypeHandlerRegistry
lxlneversettle的博客
01-31 996
TypeHandler 因为jdbc中数据的类型和java的数据类型并不是直接对应的，因此需要在jdbc数据类型和java数据类型之间进行转换，转换主要发生在两个场景： 当给sql语句注入参数时，需要将java数据类型转换成jdbc数据类型 当从数据库中查询出记录后，需要将对应的记录转换成DO时，需要将jdbc数据类型转换成jdbc数据类型 而TypeHandler就是用来进行jdbc数据类型和java数据类型之间的转换的 接口方法 首先看下TypeHandler这个接口都有哪些方法 public in
Mybatis 源码学习(9)-类型转换（TypeHandlerRegistry）
teaandnoodle的专栏
11-24 583
历史文章： Mybatis 源码学习(8)-类型转换（TypeHandler） 定义 TypeHandler 后，Mybatis 还需要对这些 TypeHandler 进行管理，Mybatis 是通过 TypeHandlerRegistry 来实现 TypeHandler 的管理的。TypeHandlerRegistry 的初始化是在 Configuration 中，Configuration ...
【Mybatis源码分析】类型处理器（TypeHandler）及其注册
qq_63691275的博客
04-15 1322
写类型处理器，可以选择继承BaseTypeHandler类，也可以选择去实现TypeHandler接口。如果不想在配置文件中去配置对应的Java类型的话，那就使用@MappedTypes注解进行配置（当然可以配置多个，因为一个处理器可以对应多个Java数据类型嘛，可以达到一致效果的也可以配置，从而达到复用）。
mybatis-configuration容器(2)--类型处理注册表--TypeHandlerRegistry
weixin_44053668的博客
07-18 462
        这个handler的主要功能就是完成mysql的列值与java字段相互转换的处理器。那么这里就会出现两个种不同的的类型。 mysql的列类型叫做jdbcType(由jdbc提供); java的字段类型叫做javaType(由jdk提供); 首先我们先看一段熟悉的代码 public static void main(String[] args) { Connection conn = DriverMan
Mybatis的类型转换注册类TypeHandlerRegistry
l688899886的博客
08-07 565
这篇文章主要讲解了类型转换注册类的TypeHandlerRegistry的注册方法和根据Java类型获取对应的TypeHandler实例的功能,注册类是重要的一个类，Mybatis的类型转换都需要在这个类进行注册才能实现类型转换。...
Mybatis源码分析.pdf
08-30
MyBatis是一款优秀的持久层框架，它的源码分析对于深入理解其工作原理和优化数据库操作至关重要。MyBatis的核心设计理念是简化SQL操作，通过XML或注解的方式将SQL与Java代码分离，同时提供强大的动态SQL功能。 首先...
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
mybatis源码笔记.pdf
07-12
阅读mybatis源码所记笔记。 基本： 1.数据源获取 2.mapper的sql语句获取 3.怎么去获得到的resultSet 重点： 1.orm是什么：体现于resultSet的数据库类型和java类型的转换 2.mybatis的一级缓存原理（简单的ifelse判断...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
MyBatis源码详解学习.zip
09-30
《MyBatis源码详解学习》是一份专为对MyBatis源码感兴趣的开发者准备的资料，它旨在帮助读者深入理解这个流行持久层框架的工作原理。MyBatis作为一个轻量级的ORM（对象关系映射）框架，因其简单易用、高度可定制化的...
Mybatis 源码 ④ ：TypeHandler
猫吻鱼的博客
08-14 1509
Mybatis 源码 ① ：开篇Mybatis 源码 ② ：流程分析Mybatis 源码 ③ ：SqlSession书接上文Mybatis 源码 ③ ：SqlSession。我们这里来看下 DefaultParameterHandler 和 DefaultResultSetHandler 的处理过程。创建一个 PwdTypeHandler 类，继承 BaseTypeHandler// 定义加解密方式// 赋值时加密@Override// 取值时解密@Override@Override。
Mybatis源码解析--TypeHandler
KeminaPera的博客
02-26 240
Mybatis源码解析–TypeHandler 背景 Mybatis作为开源的持久层框架，极大的简化了使用JDBC操作数据库的繁琐流程，作为JAVA与数据库之间的桥梁，会存在数据类型转化的问题。我们都知道在java语法中定义了一套数据类型例如String、Integer、Double等，而在数据库中也有自己的一套数据类型VARCHAR、CHAR、INT等。这篇就来探索一下Mybatis是如何解决这一问题的。 提供的功能 Mybatis定义了一个TypeHandler接口，主要负责在添加或更新操作时将JAVA
Mybatis深入剖析 - typeHandlerRegistry parameterHandler resultSetHandler
blue2048
01-09 659
Statement在具体orm的过程总，主要靠这三个类进行参数装配，结果装配和相应的类型转换 parameterHandler resultSetHandler typeHandlerRegistry protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object...
Mybatis系列（六）typeHandler源码解析
Sean'Xu Blogs
04-18 386
文章目录一、typeHandler配置二、typeHandlerElement源码三、系统定义的typeHandler四、自定义typeHandler五、枚举typeHandler六、自定义枚举typeHandler——SexEnumHandler 上篇文章Mybatis系列（五）typeAliases源码解析，主要介绍了mybatis中别名的使用，这一节我们来看TypeHandler节点，翻译成...
mybatis 源码分析六、TypeHandlerRegistry和TypeHandler详解
最新发布
m0_56362438的博客
12-06 318
TypeHandlerRegistry和TypeHandler在mybatis源码type包中，TypeHandler主要的作用是用做JdbcType 和 javaType的类型转换，就是我们常说的数据库类型和java中实体类型的转换。可以看做是正对TypeHandler的缓存，一次性将所有的TypeHandler进行了注册在我们需要使用的时候在重TypeHandlerRegistry注册器中获取。这样我们将我们自定义的TypeHandler注入到了我们的项目中。我们可以看一下执行的结果。
MyBatis3源码解析(7)TypeHandler注册与获取
github_35735591的博客
02-16 848
在上篇文章中，我们介绍了TypeHandler的简单使用和解析了TypeHandler的处理核心，这篇文章中我们接着看到TypeHandler是如注册和获取使用的
【MyBatis】源码学习 03 - 类型处理器 TypeHandler
MichelleChung的星球
02-18 696
第8章 type包 学习笔记。
Mybatis TypeHandler 介绍及使用
Crystalqy的博客
10-19 2626
我们可以直接继承BaseTypeHandler来实现我们自己的类型转换器throw new IllegalArgumentException("输入参数不能为空");@Overridetry {throw new RuntimeException("Json对象转换成String失败", e);@Override@Override@Overridetry {throw new RuntimeException("json转换成Java对象失败", e);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值