1. Toy模板网首页
  2. > Toy博客

mybatisJava对象、list和json转换

9月前 作者：分享心得 分类：Toy博客 阅读(37) 违法举报

这篇具有很好参考价值的文章主要介绍了mybatisJava对象、list和json转换。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1. 参考mybatis-plus
mybatis Java对象、list和json转换 网上好多不靠谱，参考mybatis-plus中@TableField，mybatis中自定义实现
这样不需要对象中属性字符串接收，保存到表中，都是转义字符，使用时还要手动转换为对象或者List
使用时直接添加注解，比较方便
	//对象，也可以JSONObject
    @TableOperateField(typeHandler = JacksonTypeHandler.class)
    private SysWarnNotesysWarnNote;
	//List，泛型也可以是Object,，这样比较随便了
    @TableOperateField(typeHandler = JacksonListTypeHandler.class)
    private List<SysWarnNote> sysWarnNote;
2. 仿照mybatis-plus自定义注解TableOperateField
package com.yl.cache.annotation;

import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.UnknownTypeHandler;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * TableOperateField注解，用于mybatis insert或者update表时自动给字段赋值
 * <p>使用方法
 *  <pre>
 *  @TableOperateField(value=TableOperateField.OperateType.Insert)
 *   private Date createTime;
 *  </pre>
 *
 * @author liuxubo
 * @date 2023/7/23 14:39
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface TableOperateField {
    /**
     * 操作字段类型
     *
     * @return
     */
    OperateType value() default OperateType.None;

    /**
     * 类型处理器 (该默认值不代表会按照该值生效)
     * @return
     */
    Class<? extends TypeHandler> typeHandler() default UnknownTypeHandler.class;


    /**
     * 操作sql类型
     */
    public enum OperateType {
        None,
        Insert,
        Delete,
        Update,
        Select,
        InsertOrUpdate,
        ;
    }

}
3. 新增、修改日期自动填充

新增、修改时，创建时间和修改时间，手动填充不优雅，使用数据库默认值时间会和系统时间不一致情况 ，这里模仿mybatis-plus实现

package com.yl.cache.interceptor;

import com.yl.cache.annotation.TableOperateField;
import com.yl.cache.annotation.TableOperateField.OperateType;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Properties;

/**
 * 表字段自动填充值拦截类
 *
 * @author liuxubo
 * @date 2023/7/23 14:56
 */
@Slf4j
@Component //使用 mybatis-spring-boot-starter 会自动注入 识别 mybatis的Interceptor 接口实现类
@Intercepts({@Signature(type = org.apache.ibatis.executor.Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
public class TableOperateInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];

        // 获取 SQL 命令
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
//        log.info("{}", sqlCommandType);

        // 获取参数
        Object parameter = invocation.getArgs()[1];

        // 获取私有成员变量
        Field[] declaredFields = parameter.getClass().getDeclaredFields();
        if (parameter.getClass().getSuperclass() != null) {
            Field[] superField = parameter.getClass().getSuperclass().getDeclaredFields();
            declaredFields = ArrayUtils.addAll(declaredFields, superField);
        }
        for (Field field : declaredFields) {
            TableOperateField tableOperateField = field.getAnnotation(TableOperateField.class);
            if (tableOperateField == null) {
                continue;
            }
            // insert
            if (tableOperateField.value().equals(TableOperateField.OperateType.Insert) || tableOperateField.value().equals(OperateType.InsertOrUpdate)) {
                if (SqlCommandType.INSERT.equals(sqlCommandType)) {
                    setFieldDateValue(parameter, field);

                }
            }
            // update
            if (tableOperateField.value().equals(TableOperateField.OperateType.Update) || tableOperateField.value().equals(TableOperateField.OperateType.InsertOrUpdate)) {
                if (SqlCommandType.UPDATE.equals(sqlCommandType)) {
                    field.setAccessible(true);
                    setFieldDateValue(parameter, field);
                }
            }
        }
        return invocation.proceed();
    }

    /**
     * 设置时间值
     *
     * @param parameter bean对象
     * @param field     field对象
     * @throws IllegalAccessException
     */
    private static void setFieldDateValue(Object parameter, Field field) throws IllegalAccessException {
        field.setAccessible(true);
        if (field.getType().equals(LocalDateTime.class)) {
            field.set(parameter, LocalDateTime.now());
        } else if (field.getType().equals(LocalDate.class)) {
            field.set(parameter, LocalDate.now());
        } else {
            field.set(parameter, new Date());
        }
    }


    /**
     * 生成MyBatis拦截器代理对象
     */
    @Override
    public Object plugin(Object target) {
        if (target instanceof org.apache.ibatis.executor.Executor) {
            return Plugin.wrap(target, this);
        }
        return target;
    }


    /**
     * 设置插件属性（直接通过Spring的方式获取属性，所以这个方法一般也用不到）
     * 项目启动的时候数据就会被加载
     */
    @Override
    public void setProperties(Properties properties) {
    }
}
4. 测试新增、修改日期自动填充
@Data
public class User {
    /**
     * 创建时间
     */
    @TableOperateField(value = TableOperateField.OperateType.Insert)
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    @TableOperateField(value = OperateType.InsertOrUpdate)
    private LocalDateTime updateTime;
}
5. Java实体类、List和表中json转换处理器
package com.yl.cache.handler;

import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;

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

/**
 * mybatis-plus 内置 AbstractJsonTypeHandler
 *
 * @author liuxubo
 * @date 2023/8/1 0:08
 */
public abstract class AbstractJsonTypeHandler<T> extends BaseTypeHandler<T> {

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

    @Override
    public T getNullableResult(ResultSet rs, String columnName) throws SQLException {
        final String json = rs.getString(columnName);
        return StringUtils.isBlank(json) ? null : parse(json);
    }

    @Override
    public T getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        final String json = rs.getString(columnIndex);
        return StringUtils.isBlank(json) ? null : parse(json);
    }

    @Override
    public T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        final String json = cs.getString(columnIndex);
        return StringUtils.isBlank(json) ? null : parse(json);
    }

    /**
     * 将表中字段值为json字符串解析为Java对象
     *
     * @param json 表中字段值为json字符串
     * @return:T
     */
    protected abstract T parse(String json);

    /**
     * 将Java对象序列化为json字符串保存到表中
     *
     * @param obj Java对象
     * @return:java.lang.String
     */
    protected abstract String toJson(T obj);
}
package com.yl.cache.handler;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yl.cache.annotation.TableOperateField;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * Jackson 实现 JSON 字段类型处理器
 * <p> List、Map、自定义对象，转换为json字符串存储到数据库，查询出来的时候自动转换为相应的对象
 *
 * @author hubin
 * @since 2019-08-25
 */
@Slf4j
@MappedTypes({Object.class})
@MappedJdbcTypes({JdbcType.VARCHAR, JdbcType.CHAR, JdbcType.NCHAR, JdbcType.LONGVARCHAR})
public class JacksonTypeHandler extends AbstractJsonTypeHandler<Object> {
    private static ObjectMapper OBJECT_MAPPER;
    private final Class<?> type;

    /**
     * 构造函数
     *
     * @param type 指定类型
     * @date:2023/7/31 17:52
     */
    public JacksonTypeHandler(Class<?> type) {
        if (log.isTraceEnabled()) {
            log.trace("JacksonTypeHandler(" + type + ")");
        }
        Objects.requireNonNull(type, "Type argument cannot be null");
        this.type = type;
    }

    @Override
    protected Object parse(String json) {
        try {
            return getObjectMapper().readValue(json, type);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected String toJson(Object obj) {
        try {
            return getObjectMapper().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public static ObjectMapper getObjectMapper() {
        if (null == OBJECT_MAPPER) {
            OBJECT_MAPPER = new ObjectMapper();
        }
        return OBJECT_MAPPER;
    }

    public static void setObjectMapper(ObjectMapper objectMapper) {
        Objects.requireNonNull(objectMapper, "ObjectMapper should not be null");
        JacksonTypeHandler.OBJECT_MAPPER = objectMapper;
    }

    /**
     * 查找实体类中含有注解 @TableOperateField(typeHandler = JacksonTypeHandler.class) 的字段
     *
     * @param clazz class
     * @return 实体类中含有注解 @TableOperateField(typeHandler = JacksonTypeHandler.class) 的字段列表
     */
    public static List<Type> findJsonValueFieldName(Class<?> clazz) {
        if (clazz != null) {
            return Arrays.stream(clazz.getDeclaredFields())
                    .filter(field -> field.isAnnotationPresent(TableOperateField.class)
                            && JacksonTypeHandler.class.isAssignableFrom(field.getAnnotation(TableOperateField.class).typeHandler()))
                    .map(Field::getGenericType)
                    .collect(Collectors.toList());
        }
        return Collections.EMPTY_LIST;
    }

}

package com.yl.cache.handler;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yl.cache.annotation.TableOperateField;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * Jackson 实现 JSON 字段类型处理器
 * <p> List、Map、自定义对象，转换为json字符串存储到数据库，查询出来的时候自动转换为相应的对象
 *
 * @author hubin
 * @since 2019-08-25
 */
@Slf4j
@MappedTypes({List.class})
@MappedJdbcTypes({JdbcType.VARCHAR, JdbcType.CHAR, JdbcType.NCHAR, JdbcType.LONGVARCHAR})
public class JacksonListTypeHandler extends AbstractJsonTypeHandler<List<Object>> {
    private static ObjectMapper OBJECT_MAPPER;
    private final Class<?> type;

    /**
     * 构造函数
     *
     * @param type 指定类型
     * @date:2023/7/31 17:52
     */
    public JacksonListTypeHandler(Class<?> type) {
        if (log.isTraceEnabled()) {
            log.trace("JacksonTypeHandler(" + type + ")");
        }
        Objects.requireNonNull(type, "Type argument cannot be null");
        this.type = type;
    }

    @Override
    protected List<Object> parse(String json) {
        try {
            return getObjectMapper().readValue(json, List.class);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected String toJson(List<Object> obj) {
        try {
            return getObjectMapper().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public static ObjectMapper getObjectMapper() {
        if (null == OBJECT_MAPPER) {
            OBJECT_MAPPER = new ObjectMapper();
        }
        return OBJECT_MAPPER;
    }

    public static void setObjectMapper(ObjectMapper objectMapper) {
        Objects.requireNonNull(objectMapper, "ObjectMapper should not be null");
        JacksonListTypeHandler.OBJECT_MAPPER = objectMapper;
    }

    /**
     * 查找实体类中含有注解 @TableOperateField(typeHandler = JacksonTypeHandler.class) 的字段
     *
     * @param clazz class
     * @return 实体类中含有注解 @TableOperateField(typeHandler = JacksonTypeHandler.class) 的字段列表
     */
    public static List<Type> findJsonValueFieldName(Class<?> clazz) {
        if (clazz != null) {
            return Arrays.stream(clazz.getDeclaredFields())
                    .filter(field -> field.isAnnotationPresent(TableOperateField.class)
                            && JacksonListTypeHandler.class.isAssignableFrom(field.getAnnotation(TableOperateField.class).typeHandler()))
                    .map(Field::getGenericType)
                    .collect(Collectors.toList());
        }
        return Collections.EMPTY_LIST;
    }

}
package com.yl.cache.handler;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.yl.cache.annotation.TableOperateField;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * Fastjson 实现 JSON 字段类型处理器
 *
 * @author hubin
 * @since 2019-08-25
 */
@Slf4j
@MappedTypes({Object.class})
@MappedJdbcTypes({JdbcType.VARCHAR, JdbcType.CHAR, JdbcType.NCHAR, JdbcType.LONGVARCHAR})
public class FastjsonTypeHandler extends AbstractJsonTypeHandler<Object> {
    private final Class<?> type;

    public FastjsonTypeHandler(Class<?> type) {
        if (log.isTraceEnabled()) {
            log.trace("FastjsonTypeHandler(" + type + ")");
        }
        Objects.requireNonNull(type, "Type argument cannot be null");
        this.type = type;
    }

    @Override
    protected Object parse(String json) {
        return JSON.parseObject(json, type);
    }

    @Override
    protected String toJson(Object obj) {
        return JSON.toJSONString(obj, SerializerFeature.WriteMapNullValue,
            SerializerFeature.WriteNullListAsEmpty, SerializerFeature.WriteNullStringAsEmpty);
    }

    /**
     * 查找实体类中含有注解 @TableOperateField(typeHandler = FastjsonTypeHandler.class) 的字段
     *
     * @param clazz class
     * @return EnumValue字段
     */
    public static List<Type> findJsonValueFieldName(Class<?> clazz) {
        if (clazz != null) {
            return Arrays.stream(clazz.getDeclaredFields())
                    .filter(field -> field.isAnnotationPresent(TableOperateField.class)
                            && FastjsonTypeHandler.class.isAssignableFrom(field.getAnnotation(TableOperateField.class).typeHandler()))
                    .map(Field::getGenericType)
                    .collect(Collectors.toList());
        }
        return Collections.EMPTY_LIST;
    }
}
6. 注册处理类

自定义配置扫描包type-json-package，指定扫描范围

mybatis:
  mapper-locations: classpath:mappers/*.xml
  type-aliases-package: com.yl.cache.entity
  configuration:
    map-underscore-to-camel-case: true
  type-json-package: com.yl.cache.entity

配置类

package com.yl.cache.config;

import com.yl.cache.handler.FastjsonTypeHandler;
import com.yl.cache.handler.JacksonListTypeHandler;
import com.yl.cache.handler.JacksonTypeHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;

import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * MyBatis配置自定义 typeHandler 推荐实现ConfigurationCustomizer接口配置方式
 *
 * @author liuxb
 * @date 2021/12/19 18:17
 */
@Slf4j
@org.springframework.context.annotation.Configuration
public class CommonMyBatisConfig implements ConfigurationCustomizer {
    private static final ResourcePatternResolver RESOURCE_PATTERN_RESOLVER = new PathMatchingResourcePatternResolver();
    private static final MetadataReaderFactory METADATA_READER_FACTORY = new CachingMetadataReaderFactory();

    @Value("${mybatis.type-json-package:}")
    private String typeJsonPackage;


    @Override
    public void customize(Configuration configuration) {
        // 设置null也返回
        configuration.setCallSettersOnNulls(true);
        // 设置一行都为null也返回
        configuration.setReturnInstanceForEmptyRow(true);
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();

        //如果给定扫描json类包，注册类名为属性含有 @TableOperateField(typeHandler = JacksonTypeHandler.class)的实体类
        if (StringUtils.hasLength(typeJsonPackage)) {
            Set<Class<?>> classes = scanClasses(typeJsonPackage, null);
            if (classes.isEmpty()) {
                log.warn("Can't find class in '[" + typeJsonPackage + "]' package. Please check your configuration.");
                return;
            }

            Set<Type> jacksonTypes = classes.stream().map(cls -> JacksonTypeHandler.findJsonValueFieldName(cls))
                    .flatMap(types -> types.stream())
                    .collect(Collectors.toSet());
            registerTypeHandler(typeHandlerRegistry, jacksonTypes, JacksonTypeHandler.class);

            Set<Type> fastJsonTypes = classes.stream().map(cls -> FastjsonTypeHandler.findJsonValueFieldName(cls))
                    .flatMap(types -> types.stream())
                    .collect(Collectors.toSet());
            registerTypeHandler(typeHandlerRegistry, fastJsonTypes, FastjsonTypeHandler.class);

            Set<Type> jacksonListTypes = classes.stream().map(cls -> JacksonListTypeHandler.findJsonValueFieldName(cls))
                    .flatMap(types -> types.stream())
                    .collect(Collectors.toSet());
            registerTypeHandler(typeHandlerRegistry, jacksonListTypes, JacksonListTypeHandler.class);
        }

    }

    /**
     * 注册自定义类型处理器
     *
     * @param typeHandlerRegistry
     * @param types 类型
     */
    private void registerTypeHandler(TypeHandlerRegistry typeHandlerRegistry, Set<Type> types, Class typeHandlerClass) {
        if (!types.isEmpty()) {
            log.info("mybatis register json type handler {}", types);
            types.forEach(type -> {
                //集合类
                String typeName = type.getTypeName();
                if(typeName.contains("java.util.List<") && typeName.endsWith(">")){
                    Class<?> rawType = ((ParameterizedTypeImpl) type).getRawType();
                    typeHandlerRegistry.register(rawType, typeHandlerClass);
                }else{
                    //实体类
                    Class<?> clazz = (Class<?>) type;
                    if (org.apache.commons.lang3.ClassUtils.isPrimitiveOrWrapper(clazz) || String.class.equals(clazz)) {
                        throw new RuntimeException("请检查@TableOperateField(typeHandler = JacksonTypeHandler.class)标记的属性类型");
                    }
                    typeHandlerRegistry.register(clazz, typeHandlerClass);
                }
            });
        }
    }


    /**
     * 根据包路径和指定类的子类，获取当前包和子包下的全部类
     *
     * @param packagePatterns 指定包
     * @param assignableType  父类
     * @return
     */
    private Set<Class<?>> scanClasses(String packagePatterns, Class<?> assignableType) {
        Set<Class<?>> classes = new HashSet<>();
        try {
            String[] packagePatternArray = StringUtils.tokenizeToStringArray(packagePatterns, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            for (String packagePattern : packagePatternArray) {
                Resource[] resources = RESOURCE_PATTERN_RESOLVER.getResources(ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                        + ClassUtils.convertClassNameToResourcePath(packagePattern) + "/**/*.class");
                for (Resource resource : resources) {
                    try {
                        ClassMetadata classMetadata = METADATA_READER_FACTORY.getMetadataReader(resource).getClassMetadata();
                        Class<?> clazz = Resources.classForName(classMetadata.getClassName());
                        if (assignableType == null || assignableType.isAssignableFrom(clazz)) {
                            classes.add(clazz);
                        }
                    } catch (Throwable e) {
                        log.warn("Cannot load the '" + resource + "'. Cause by " + e.toString());
                    }
                }
            }
        } catch (IOException e) {
            log.warn("scan " + packagePatterns + ", io error");
        }
        return classes;
    }


}
7. 测试 保证增删改查接口都能正常
CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '主键id（自增）',
  `sys_warn_note` varchar(100) DEFAULT NULL COMMENT '系统告警信息',
  `create_time` datetime NOT NULL,
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='测试用户表'

上送json字符串，JSONObject 接收，表字段为varchar,text，json类型都可以，使用mysql8
http://localhost:8080/jobWarnMessage/add
{
        "code": "006",
        "sysWarnNote": {
            "address": "北京大雨了"
        }
    }
@Data
public class User{
    @TableOperateField(typeHandler = JacksonTypeHandler.class)
    private JSONObject sysWarnNote;
}

mybatisJava对象、list和json转换,mybatis
也可以为List文章来源地址https://www.toymoban.com/news/detail-622598.html

@Data
public class SysWarnNote {
    private String name;
    private String content;
}
@Data
public class User{
    @TableOperateField(typeHandler = JacksonListTypeHandler.class)
    private List<SysWarnNote> sysWarnNote;
}

到了这里，关于mybatisJava对象、list和json转换的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java中的List＜T＞对象与Json格式的字符串的相互转换

    在这里我随便举一个例子 OK，以上就是互相转换的过程 我使用的场景是在订单的订单列表项这里，涉及到数据库相应字段数据的存放与提取，我的做法是，将List转换为Json格式字符串存入，取时再将Json格式转为List

    2024年02月15日
    浏览(68)

  • 【mybatis-plus实体类复杂对象字段json自动相互转换，以及自定义字段类型解析器】

    引言： mybatis-plus集合对象字段json如何自动进行相互的转换？ 怎样在使用mybatis-plus操作数据表的时候自动对实体类属性进行自动解析？ 我们平时在做开发的时候，会遇到一个字段保存json串的情况。一般情况下mybatis-plus在做插入/更新之前将对象手动转换成json串，查询要用的时

    2023年04月13日
    浏览(103)

  • Java List对象集合转Json & Json转List对象集合

    使用了阿里巴巴的 fastjson  首先引入依赖 示例如下 输出结果：

    2024年02月15日
    浏览(57)

  • dataTable转成对象、json、list

    datatable转换成list集合 //多行datatable数据转换为对象： datatable转换成json

    2024年02月15日
    浏览(49)
  • 【御控工业物联网】JAVA JSON结构转换、JSON结构重构、JSON结构互换（5）：对象To对象——转换映射方式

    【御控工业物联网】JAVA JSON结构转换、JSON结构重构、JSON结构互换（5）：对象To对象——转换映射方式

    JSON结构转换指的是将一个JSON对象或JSON数组按照一定规则进行重组、筛选、映射或转换，生成新的JSON对象或数组的过程。这种转换可以包括改变JSON数据的结构、提取特定字段、合并多个JSON数据，或者对数据进行计算和处理等操作。 在JSON结构转换中，常见的操作包括： 提取

    2024年04月27日
    浏览(40)
  • Mybatis实现JsonObject对象与JSON之间交互

    Mybatis实现JsonObject对象与JSON之间交互

    项目中使用PostGresql数据库进行数据存储，表中某字段为Json类型，用于存储Json格式数据。PG数据库能够直接存储Json算是一大特色，很多特定情境下使用直接存储Json字段数据能够大量节省开发时间，提高后台数据查询和转换效率。 如果我们有一个JSONObject属性的字段需要与数据

    2024年02月14日
    浏览(53)

  • JAVA 对象转换为JSON

    转载：如何把java对象转换为json java对象怎么转成json_clghxq的技术博客_51CTO博客 1、Java对象列表转换为JSON对象数组，并转为字符串 JSONArray jsonArray = JSONArray.fromObject(list); String jsonArrayStr = jsonArray.toString(); 2、把Java对象转换成JSON对象，并转化为字符串 JSONObject jsonObject = JSONObject.

    2024年02月10日
    浏览(38)

  • Java中 List 和 JSON字符串之间的相互转换

    Java中 List 和 JSON字符串之间的相互转换 List 转 JSON 字符串 前端js将后端的json字符串转对象 JSON字符串转List

    2024年04月23日
    浏览(73)
  • Json对象和Json字符串之间相互转换

    Json对象和Json字符串之间相互转换

    作为前端开发，在和后端进行联调接口时，总会遇到要求传JSON字符串或是JSON对象，或者是返回值里是JSON字符串要在页面上展示JSON对象这种情况，都需要前端开发人员对Json对象和Json对象进行相互转换，得到想要的结果。 废话不多说，直接上干货： 1.首先定义一个Json对象：

    2024年02月11日
    浏览(59)

  • json类型转换对象含有泛型

    接受数据的对象1 对象1里有list 泛型 因为此时接受的是Book类的数据,所以我转换的时候指定了转换类型为Book类型 接受的其他类型的数据,可以转换的时候指定这个类型就可以了 实操代码 输出结果 TypeReference是在运行时指定要转换的类型包括泛型 fastjson的版本 从而实现指定泛型

    2024年02月02日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包