SpringBoot使用Json序列化(jackson-fastjson-gson等)

已于 2023-12-05 23:40:41 修改
阅读量1.6k 收藏 1
点赞数
文章标签： java spring boot json
于 2022-06-20 12:52:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QingChunBuSanChang/article/details/125370687
版权

Springboot+json序列化

  • jackson方案
  • fastjson方案
  • gson方案

一、Jackson方案

  • 注意：Springboot默认的json持久化是jackson
1、添加依赖
  • 注意:除了jackson-core 其他都是选填
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.9</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.9.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.9</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.9</version>
</dependency>
2、配置
2。1、配置项
#时间戳统一转换 
spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
2.1 配置类
@Configuration
public class JacksonConfig {

    @Value("${spring.jackson.data-format:yyyy-MM-dd HH:mm:ss}")
    private String pattern;
    // 日期序列化器
    @Bean
    public LocalDateTimeSerializer localDateTimeSerializer(){
        return new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(pattern));
    }
    // 日期反序列化器
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer(){
        return builder->builder
        		.serializerByType(LocalDateTime.class,localDateTimeSerializer());
    }
}
3、Jackson注解使用
2.1、序列化注解：
  • @JsonAnyGetter 将对象Map作为属性
  • @JsonGetter 方法注解:将getter结果作为属性
  • @JsonPropertyOrder 类注解:指定序列化后属性栓
  • @JsonRawValue 序列化时将属性原样输出
  • @JsonValue 方法注解：将方法的结果序列化
  • @JsonRootName 类注解：为json加一个根属性
  • @JsonSerialize 自定义序列化器
  • @JsonInclude 类注解：序列化时排除null值
  • @JsonAppend 序列化时增加一个虚拟属性
2.2、反序列化注解：
  • @JacksonInject 注入属性
  • @JsonDeserialize 自定义反序列化器
  • @JsonAlias 反序列化别名
  • @JsonIgnoreProperties 类注解，忽略属性
2.2、序列化和反序列化共用：
  • @JsonIgnore 忽略属性
  • @JsonIgnoreType 类注解，忽略属性类型，统一变成String
  • @JsonInclude 类和属性：排除空属性
  • @JsonProperty 方法注解：设置别名
  • @JsonFormat 属性格式化，可格式化日期和金额，以及自定义格式化
  • @JsonUnwrapped 去掉外包装根节点名称
  • @JsonView 指定序列化和反序列化的视图级别
  • @JsonManagedReference 解决不同属性的依赖关系
  • @JsonBackReference 解决不同属性的依赖关系，防止循环调用
  • @JsonFilter 序列化时指定一个过滤器
  • @JsonNaming 属性明明方式设置，例如驼峰，中华线，首字母小写，首字母大写等
  • @Transient 不序列化字段
2.3 注解使用示例
@Data
public class User<T> {
	@JsonIgnore // 忽略序列化字段
    private String pid;  
    @Transient  // 不序列化字段
    private String remark;
    private Role role;
    @JsonProperty("userName")   //转换属性名称
	private String account;
    //反序列化--格式化日期
	@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
	private LocalDateTime createTime;
    //自定义序列化 
    @JsonSerialize(using = Date2LongSerialize.class)
	private Date operaterTime;
    //自定义反序列化处理
    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date eventDate;
}
2.4、jackson和xml序列化与反序列化
//（15）xml的序列化
@Data
@JacksonXmlRootElement(localName = "root")
public class RootXml {
 
    private String k1;
 
    @JacksonXmlProperty(localName = "k-2")
    private Integer k2;
 
    @JacksonXmlElementWrapper(localName = "k3")
    private Collection<String> ki;
 
    @JacksonXmlElementWrapper(localName = "k4")
    @JacksonXmlProperty(localName = "ka")
    private Collection<String> k4;
 
    @JacksonXmlElementWrapper(localName = "k5", useWrapping = false)
    private Collection<String> k5;
    
    @JacksonXmlProperty(isAttribute = true)
    private Integer k6;
    
    @Data
    public static class Value1 {
 
        @JacksonXmlText
        private String a;
    }
 
    private Value1 k7;
 
    @Data
    public static class Value2 {
 
        @JacksonXmlText(value = false)
        private String a;
    }
 
    private Value2 k8;
 
    @JacksonXmlCData(value = true) // 序列化时是否总是使用 CDATA 块
    private String k9;
}
 //反序列化
 //ReqMessage reqMessage = JacksonUtil.readValueXml(json, RootXml.class);
4、各种自定义的示例
4.1、自定义序列化器示例

// Date自定义序列化
public class CustomDateSerializer extends StdSerializer<Date> {
    private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
    public CustomDateSerializer() { this(null); } 
    public CustomDateSerializer(Class<Date> t) { super(t); }
    @Override
    public void serialize(Date value, JsonGenerator gen, SerializerProvider arg2) 
    	throws IOException, JsonProcessingException {
        gen.writeString(formatter.format(value));
    }
}

// LocalDateTime 自定义序列化
public class MyLocalDateTimeDeserializer  extends JsonDeserializer<LocalDateTime> {

  @Override
  public LocalDateTime deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    String dateStr = parser.getText();
    DateTime dateTime = null;
    try{
      dateTime = DateUtil.parse(dateStr);
    }catch (Exception e){
      dateTime = DateUtil.parseDateTime(dateStr.replaceAll("T"," "));
    }
    LocalDateTime localDateTime = dateTime.toJdkDate().toInstant()
            .atZone(ZoneId.systemDefault()).toLocalDateTime();
    return localDateTime;
  }

  @Override
  public Class<?> handledType() {
    return LocalDateTime.class;
  }
}
4.2 自定义反序列化器
// Date反序列化器
public class CustomDateDeserializer  extends StdDeserializer<Date> { 
    private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
     public CustomDateDeserializer() { 
        this(null); 
    }  
    public CustomDateDeserializer(Class<?> vc) { 
        super(vc); 
    }
    @Override
    public Date deserialize(JsonParser jsonparser, DeserializationContext context) throws IOException {         
        String date = jsonparser.getText();
        try {
            return formatter.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

// LocalDateTime反序列化器
public class MyLocalDateTimeDeserializer  extends JsonDeserializer<LocalDateTime> {
  @Override
  public LocalDateTime deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    String dateStr = parser.getText();
    DateTime dateTime = null;
    try{
      dateTime = DateUtil.parse(dateStr);
    }catch (Exception e){
      dateTime = DateUtil.parseDateTime(dateStr.replaceAll("T"," "));
    }
    Date date = dateTime.toJdkDate();
    Instant instant = date.toInstant();
    ZoneId zoneId = ZoneId.systemDefault();
    LocalDateTime localDateTime = instant.atZone(zoneId).toLocalDateTime();
    return localDateTime;
  }
  @Override
  public Class<?> handledType() {
    return LocalDateTime.class;
  }
}
4.2 自定义过滤器
FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter",
        SimpleBeanPropertyFilter.filterOutAllExcept("name"));
5、Jackson工具类
public class JacsonUtils {
    public static final ObjectMapper MAPPER;
    static {
        MAPPER = new ObjectMapper();
        MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }
    //===============================序列化================//
    @SneakyThrows
    public static String toString(Object obj) {
        if (obj == null) return null;
        if (obj.getClass() == String.class)  return Convert.toStr(obj);
        return MAPPER.writeValueAsString(obj);
    }
    //==========================反序列化===============//
    //对象反序列化
    @SneakyThrows(value={IOException.class})
    public static <T> T toBean(String json, Class<T> tClass) {
        if(StrUtil.isEmpty(json)) return null;
        return MAPPER.readValue(json, tClass);
    }
 	//集合反序列化
    @SneakyThrows(value={IOException.class})
    public static <E> List<E> toList(String json, Class<E> eClass) {
        if(StrUtil.isEmpty(json)) return null;
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, Bean.class);
        return MAPPER.readValue(json,javaType);
    }
 	//Map集合反序列化
    @SneakyThrows(value={IOException.class})
    public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
        if(StrUtil.isEmpty(json)) return null;
        JavaType javaType = MAPPER.getTypeFactory()
                .constructParametricType(HashMap.class,String.class, Bean.class);
        return MAPPER.readValue(json, javaType);
    }
 	//复杂对象反序列化
    @SneakyThrows(value={IOException.class})
    public static <T> T nativeRead(String json, TypeReference<T> type) {
        if(StrUtil.isEmpty(json)) return null;
        return MAPPER.readValue(json, type);
    }
}

二、fastJson方案

1、添加依赖
<!-- fastjson -->
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.1</version>
</dependency>
2、配置类
  • 一般场景下可以不需要配置类，采用默认的方式即可
@Configuration
public class FJsonConfig {
    
    @Bean
    public HttpMessageConverter configureMessageConverters() {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(
                // 可以配置不同的属性序列化方式
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteNullStringAsEmpty,
                SerializerFeature.WriteNullNumberAsZero,
                SerializerFeature.WriteNullListAsEmpty,
                SerializerFeature.WriteNullBooleanAsFalse,
                SerializerFeature.DisableCircularReferenceDetect);

        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> mediaTypeList = new ArrayList<>();
        mediaTypeList.add(MediaType.APPLICATION_JSON);
        converter.setSupportedMediaTypes(mediaTypeList);
      return converter;
    }
}
2、fastjson使用注解自定义序列化
  • @JSONField(name = “AGE”)
    • name 设置序列后别名
    • format 格式化输出日期
    • ordinal 输出排列顺序
    • serialize 是否序列化输出
    • deserialize 是否反序列化
@Data
public class Person {
    @JSONField(name = "AGE")
    private int age;
    @JSONField(name = "FULL NAME")
    private String fullName;
    @JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)
    private Date dateOfBirth;
    @JSONField(name="CREATEDATE", serialize=false)
    private Data createDate;
}
3、json工具类整理

调用时，可以直接使用fastJsonApi

  • JSON 作为fastjson的json处理入口，相当于一个工具类，提供parseObject,parseArray,toJsonString,toJsonBytes等序列化和反序列化的
  • JSONObject/JSONArray 解析后的对象或数组
  • JSONPath采用path方式获取json值
  • JSONReader json的读取器，
public class FastJsonUtil {
    private static SerializeConfig config;
		
    static {
        config = new SerializeConfig();
        config.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
        config.put(LocalDateTime.class, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }
	//设置属性
    private static final SerializerFeature[] features = {
            SerializerFeature.WriteMapNullValue,
            SerializerFeature.WriteNullListAsEmpty,
            SerializerFeature.WriteNullNumberAsZero,
            SerializerFeature.WriteNullBooleanAsFalse,
            SerializerFeature.WriteNullStringAsEmpty
    };

    //=========================序列化==========================//
    /** 对象转json */
    public static String toJSON(Object object) {
        if(object==null) return null;
        return JSON.toJSONString(object, config, features);
    }
    //===================反序列化================================
    /** Json 转为 Jave Bean */
    public static <T> T toBean(String text, Class<T> clazz) {
        if(StrUtil.isEmpty(text)) return null;
        return JSON.parseObject(text, clazz);
    }
    /** json转对象数组 */
    public static Object[] toArray(String text) {
        if(StrUtil.isEmpty(text)) return null;
        return toArray(text, null);
    }
    public static <T> Object[] toArray(String text, Class<T> clazz) {
        if(StrUtil.isEmpty(text)) return null;
        return JSON.parseArray(text, clazz).toArray();
    }
    public static Map<?, ?> toMap(String json) {
        if(StrUtil.isEmpty(json)) return null;
        return JSON.parseObject(json);
    }
    public static <T> List<T> toList(String text, Class<T> clazz) {
        if(StrUtil.isEmpty(text)) return null;
        return JSON.parseArray(text, clazz);
    }
    public static Object getValueFromJson(final String json, final String key) {
        if(StrUtil.isEmpty(json)) return null;
        return JSON.parseObject(json).getString(key);
    }
}

三、GSON方案

添加依赖
<!-- 添加Gson依赖 -->
<dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <version>${gson.version}</version>
</dependency>
1、Gson注解Bean
  • @SerializedName(value = “nameB”, alternate = {“nameC”, “nameD”})
    • value 序列化别名
    • alternate 发序列化的备用名
  • @Expose(serialize = true, deserialize = false)
  • serialize 是否可以序列化
  • deserialize 是否可以反序列化
@Data
public class MyClass {
    
    @SerializedName("nameA")
    String a;
    
    @SerializedName(value = "nameB", alternate = {"nameC", "nameD"})
    String b;
    
    @Expose(serialize = true, deserialize = false)
    String c;
}
2、Gson工具类
@Configuration
@EnableWebMvc
public class GsonUtils extends WebMvcConfigurationSupport {
    
    //无参的私有构造方法
    private  GsonUtils() { }
    
    //不用创建对象,直接使用Gson.就可以调用方法
    private static Gson gson = null;
    
    //判断gson对象是否存在了,不存在则创建对象
    static {
        if (gson == null) {
            //gson = new Gson();
            gson= new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        }
    }
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.removeIf(httpMessageConverter -> 
                httpMessageConverter instanceof MappingJackson2HttpMessageConverter);
        converters.add(new GsonHttpMessageConverter());
        super.extendMessageConverters(converters);
    }
    //==============================序列化======================//
    public static String toString(Object object) {
        if(gson==null) return null;
        return gson.toJson(object);
    }
    //=============================反序列化===================//
    @SneakyThrows
    public static <T> T toBean(String gsonString, Class<T> cls) {
        if(gson==null) return null;
        return gson.fromJson(gsonString, cls);
    }
    @SneakyThrows
    public static <T> List<T> toList(String gsonString, Class<T> cls) {
        if(gson==null) return null;
        return  gson.fromJson(gsonString, new TypeToken<List<T>>() { }.getType());
    }
    @SneakyThrows
     public static <T> List<T> toList2(String json, Class<T> cls) {
         if(gson==null) return null;
         ArrayList<T> mList = new ArrayList<T>();
         JsonArray array = new JsonParser().parse(json).getAsJsonArray();
         for(final JsonElement elem : array){
             mList.add(gson.fromJson(elem, cls));
         }
         return mList;
    }
    @SneakyThrows
    public static <T> List<Map<String, T>> toListMap(String gsonString) {
        if(gson==null) return null;
        return gson.fromJson(gsonString, new TypeToken<List<Map<String, T>>>() { }.getType());
    }
    @SneakyThrows
    public static <T> Map<String, T> toMap(String gsonString) {
        if(gson==null) return null;
        return gson.fromJson(gsonString, new TypeToken<Map<String, T>>() { }.getType());
    }
    
}
四、JsonPath工具

http://www.ibloger.net/article/2329.html

添加依赖
<!--json-path工具-->
<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.2.0</version>
</dependency>
1、JSONPath的使用
  • jsonpath主要就是通过类似地址的方式直接获取对象，目前不常用，fastjson有对应的功能
相关API使用

参照jsonpath语法

public class JsonFileUtil {
    // 直接读取json
    public static void  readjson(String json,String jsonPath){
        TypeRef<List<String>> typeRef = new TypeRef<List<String>>(){};
        List<String> titles = JsonPath.parse(json).read("$.store.book[*].title", typeRef);
        List<String> authors =  JsonPath.read(json, "$.store.book[*].author",typeRef);
        Date date = JsonPath.parse(json1).read("$['date_as_long']", Date.class);
        Book book = JsonPath.parse(json).read("$.store.book[0]", Book.class);
    }
    //通过Configuration读取并解析文件，获取某个值，可以多次获取
    public static void  readConfiguration(){
        Object document = Configuration.defaultConfiguration().jsonProvider().parse(json);
        String author0 = JsonPath.read(document, "$.store.book[0].author");
    }
    public static void readContext(){
        ReadContext ctx = JsonPath.parse(json);
            List<String> authorsOfBooksWithISBN = ctx.read("$.store.book[?(@.isbn)].author");
            Configuration configuration = Configuration.defaultConfiguration();
            List<Map<String, Object>> expensiveBooks = JsonPath
                    .using(configuration)
                    .parse(json)
                    .read("$.store.book[?(@.price > 10)]", List.class);
    }
    //支持语法
    public static void readfilter(){
          List<Map<String, Object>> books =  JsonPath.parse(json).read("$.store.book[?(@.price < 10)]");
            //过滤
            Filter cheapFictionFilter = Filter.filter(
                    Criteria.where("category").is("fiction").and("price").lte(10D)
            );
            List<Map<String, Object>> books1 = JsonPath.parse(json).read("$.store.book[?]", cheapFictionFilter);
    }
}

https://www.cnblogs.com/baiqiantao/p/7512336.html

天道酬勤的博客
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot 中使用 ObjectMapper 进行 JSON 序列化和反序列化
小子宝丁的博客
05-31 5384
在 Java 中，可以使用各种 JSON 序列化和反序列化工具将 Java 对象转换为 JSON 字符串或者将 JSON 字符串转换为 Java 对象。其中，Jackson 库是比较常用的 JSON 序列化和反序列化工具之一，它提供了 `ObjectMapper` 类，用于将 Java 对象转换为 JSON 字符串，或者将 JSON 字符串转换为 Java 对象。
【springboot进阶】springboot集成fastjson（二）自定义序列化/反序列化
06-15 1万+
介绍fastjson2如何使用自定义序列化和反序列化，配合日常接触的场景举例代码中如何实现，如日期型转化为毫秒数、单位元转分等。
SpringBoot使用Jackson
最新发布
username00000的博客
04-28 719
Springboot配置JackSon处理类属性，JavaBean序列化为JSON格式，常用框架：阿里fastjson，谷歌gson、Jackson等。① 性能：Jackson > Fastjson > Gson >同个结构② Jackson、Fastjson、Gson 类库各有特点，各有自己的专长Jackson是spring-boot-starter-json依赖的一部分，spring-boot-starter-web中包含spring-boot-starter-json。也就是说当项目中引入了。
Spring(24) Json序列化的三种方式（Jackson、FastJSON、Gson）史上最全！
ACGkaka的博客
04-16 1476
Spring(24) Json序列化的三种方式（Jackson、FastJSON、Gson）史上最全！
Spring Boot实现全局序列化配置（Jackson、FastJson）
旭东怪的博客
10-01 4265
1JsonConfig 序列化配置类。 package com.config; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.databind..
springboot自定义json序列化
qq_41444226的博客
04-14 1200
今天在使用spring boot的json自定义序列化器时，碰到一个大坑；就是在序列化对象里的对象不能为null，否则报空指针异常
java如何利用FastJSON、Gson、Jackson三种Json格式工具自定义时间序列化
10-19
这个问题可以通过使用FastJSON、Gson和Jackson这三种流行的JSON库来解决，每种库都有其特性和方法来实现自定义时间序列化。 1. **FastJSON**： FastJSON是阿里巴巴开发的高性能JSON处理器。尽管它在解析速度上表现...
JSON中fastjson、jackson、gson如何选择.docx
01-20
Java 中有多种 JSON 解析方式，例如 fastjson（阿里）、Gson（谷歌）、jackson 等。那么，在选择 JSON 解析器时，需要考虑哪些因素？本文将从性能、功能、易用性和社区支持四个方面比较 fastjson、jackson 和 gson...
fastjson、gson、jackson序列化和反序列化所用 json
05-22
fastjson、gson、jackson序列化和反序列化所用json文件
JsonPerformanceVS:mson，jackson，FastJson，Gson，Json-Smart，org.json，json-lib
04-30
JSON序列化(Object => JSON) JSON反序列化(JSON => Object) 预告结论：Conclusion pre： 1、 当数据小于 100K 的时候，建议使用 GSON。 2、 当数据100K 与 1M 的之间时候，建议使用各个JSON引擎性能差不多 3、 当...
springboot整合Jackson实例项目-附工具类
03-21
与其他 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比较快；Jackson 运行时占用内存比较低，性能比较好；Jackson 有灵活的 API，可以很容易进行扩展和定制。 额外了解： Jackson 的 1.x ...
SpringBoot Jackson序列化规则
qq_40548538的博客
08-12 577
spring Jackson
SpringBoot配置跨域 修改默认json序列化
laow的博客
07-26 671
SpringBoot配置跨域 修改默认json序列化 修改跨域 //解决跨域问题 @Override public void addCorsMappings(CorsRegistry registry) { registry.addMapping("/**") .allowedOrigins("*") .allowCredentials(true) .allowed
springboot利用fastjson序列化输出(默认是jackson)
weixin_33725722的博客
06-22 708
在@SpringBootApplication类中添加 @Bean public HttpMessageConverters fastJsonHttpMessageConverters() { //创建FastJson信息转换对象 FastJsonHttpMessageConverter fastJsonHttpMessageConver...
springboot之Fastjson实现复杂对象序列化
weixin_44390164的博客
09-22 521
1. 在pom文件中添加以下依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.15</version> </dependency> 2. 序列化与反序列化 Teacher teacher = ne
springboot内置序列化工具Jackson
Jay的博客
08-07 2190
JackSon介绍 本文使用的JackSon版本为2.9.6。 JackSon是解析JSON和XML的一个框架，优点是简单易用，性能较高。 JackSon处理JSON的方式 JackSon提供了三种JSON的处理方式。分别是数据绑定，树模型，流式API。下面会分别介绍这三种方式。 完整数据绑定 /** * 下面是最常用的场景，将json字符串映射为对象，或者是将对象转化为json字符串。这是完整数据绑定。 缺点:这种方法十分方便，但是扩展性不强，增加一个字段便要修改POJO对象，这个操作有一定风险性。
springBoot的序列化与反序列化
热门推荐
a1902890406的博客
09-06 1万+
小D在练习搭建springMvc框架时，遇到一个Controller接收实体参数问题：method为post，content-type为application/json; charset=utf-8的http请求，Controller接收 是@RequestBody ，但无法序列化为Object类型，其它类型却可以，并且报415错误Unsupported Media Type，可以排除注解未开启...
springboot自定义jackson序列化，默认null值个性化处理返回值
leipf的博客
12-24 1726
转载：https://www.cnblogs.com/guoxiaoyu/p/13667961.html 　　最近在项目中遇到，返回对象和属性为null时，接口不返回这个字段，但在实际中即使这个字段为null也是需要返回的，也试了好多，加json注解什么的，都没效果，最后通过下面的方式实现了，特此记录一下 第一步：写配置类 @Configuration public class WebConfiguration extends WebMvcConfigurationSupport { @Overr
【IDEA开发SpringBoot2.0】使用Jackson对JSON数据序列化与反序列化#04
MoLi blog
08-22 1706
文章目录前言什么是Jackson？正题Jackson的常用注解@JsonIgnore注解使用讲解【排除属性不做序列化与反序列化】不加该注解时请求接口的返回结果加上注解之后的请求接口返回结果@JsonProperty注解使用讲解【更改属性名称】不加该注解时请求接口的返回结果加上注解之后的请求接口返回结果@JsonPropertyOrder注解使用讲解 【改变json子元素的顺序】不加该注解时请求接...
fastjson和gson以及jackson
09-05
根据测试结果，FastJson在JSON序列化和反序列化方面的速度接近于Jackson，比Gson快得多。 Gson是Google开发的另一种流行的JSON库，它提供了简单易用的API，能够将Java对象序列化为JSON字符串，以及将JSON字符串反...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值