1、序列化之Java序列化工具详解

Java的序列化与反序列化工具详解

文章目录

    • Java的序列化与反序列化工具详解
    • 1、序列化和反序列化定义
    • 2、工具介绍
      • 2.1、Jackson(即ObjectMapper)
        • 2.1.1概述:
        • 2.1.2、优点:
        • 2.1.3、使用方法:
        • 2.1.4、工具类:
      • 2.2、Gson
        • 2.2.1、概述:
        • 2.2.2、优点:
        • 2.2.3、使用方法:
        • 2.2.4、工具类:
      • 2.3、Fastjson
        • 2.3.1、概述:
        • 2.3.2、优点:
        • 2.3.3、JSON、JSONObject、javabean关系的解析:
        • 2.3.4、使用方法:
      • 2.4、性能对比及选择

1、序列化和反序列化定义

序列化:Java序列化是指把Java对象转换为可传输的字节序列的过程;

反序列化:而Java反序列化是指把传输的字节序列恢复为Java对象的过程。这两个过程使我们非常方便的存储和传输数据。

2、工具介绍

2.1、Jackson(即ObjectMapper)

2.1.1概述:
	Jackson 是当前用的比较广泛的,用来序列化和反序列化 json 的 Java 的开源框架。Jackson 社区相对比较活跃,更新速度也比较快, 从 Github 中的统计来看,Jackson 是最流行的 json 解析器之一 。 
2.1.2、优点:
	Spring MVC 的默认 json 解析器便是 Jackson。 
	Jackson 所依赖的 jar 包较少 ,简单易用。
	与其他 Java 的 json 的框架 Gson 等相比, Jackson 解析大的 json 文件速度比较快;
	Jackson 运行时占用内存比较低,性能比较好;
	Jackson 有灵活的 API,可以很容易进行扩展和定制。
2.1.3、使用方法:
jackson
//maven依赖
//该依赖同时会将如下库添加到项目路径中:
//jackson-annotations-2.9.8.jar
//jackson-core-2.9.8.jar
//jackson-databind-2.9.8.jar
<!-- json数据的解析包 -->
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.9.3</version>
  </dependency>
   
//导包: 
import com.fasterxml.jackson.databind.ObjectMapper;

//序列化
ObjectMapper mapper = new ObjectMapper();
String s = mapper.writeValueAsString(all);
//反序列化
ObjectMapper mapper = new ObjectMapper();
List list = mapper.readValue(categories, List.class);
2.1.4、工具类:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @author :
 * @date :Created in 19:30 2022/7/18
 * @description :
 * @version: 1.0
 */
public class ObjectMapperUtils {

    public static final ObjectMapper mapper = new ObjectMapper();

    private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);

    public static String toString(Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj.getClass() == String.class) {
            return (String) obj;
        }
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("json序列化出错:" + obj, e);
            return null;
        }
    }

    public static <T> T toBean(String json, Class<T> tClass) {
        try {
            return mapper.readValue(json, tClass);
        } catch (IOException e) {
            logger.error("json解析出错:" + json, e);
            return null;
        }
    }

    public static <E> List<E> toList(String json, Class<E> eClass) {
        try {
            return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
        } catch (IOException e) {
            logger.error("json解析出错:" + json, e);
            return null;
        }
    }

    public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
        } catch (IOException e) {
            logger.error("json解析出错:" + json, e);
            return null;
        }
    }

    public static <T> T nativeRead(String json, TypeReference<T> type) {
        try {
            return mapper.readValue(json, type);
        } catch (IOException e) {
            logger.error("json解析出错:" + json, e);
            return null;
        }
    }
}

2.2、Gson

2.2.1、概述:
	Gson是一个Java库,可用于将Java对象转换为JSON表示,它也可以用来将JSON字符串转换为等效的Java对象。使用的主要类是Gson,可以通过调用创建new Gson(),Gson实例在调用Json操作时不保持任何状态,所以,你可以自由地重复使用同一个对象来进行多个Json序列化和反序列化操作。
2.2.2、优点:
1.gson默认支持LocalData;
2.如果字段被标记为transient,(默认情况下)它会被忽略并且不包含在 JSON 序列化或反序列化中;
3.此实现正确处理空值,序列化时,从输出中跳过空字段反序列化时,JSON 中缺少条目导致将对象中的相应字段设置为 null;
4.如果字段是synthetic的,则它会被忽略并且不包括在 JSON 序列化或反序列化中。
2.2.3、使用方法:
//maven依赖
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.6</version>
</dependency>
       
//需要导包
import com.google.gson.Gson;

//序列化
String s = new Gson().toJson(setMealDetails);
//反序列化
Setmeal setmeal = new Gson().fromJson(json, Setmeal.class);
2.2.4、工具类:

import cn.hutool.core.date.DatePattern;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author :
 * @date :Created in 20:12 2022/7/18
 * @description :Gson序列化工具类
 * @version: 1.0
 */
@Slf4j
public class GsonSerializeUtils {

    public static final Gson gsonToJson = new GsonBuilder()
            .registerTypeAdapter(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
                @Override
                public JsonElement serialize(LocalDateTime localDateTime, Type type, JsonSerializationContext jsonSerializationContext) {
                    return new JsonPrimitive(localDateTime.format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
                }
            })
            .registerTypeAdapter(LocalDate.class, new JsonSerializer<LocalDate>() {
                @Override
                public JsonElement serialize(LocalDate localDate, Type typeOfSrc, JsonSerializationContext context) {
                    return new JsonPrimitive(localDate.format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
                }
            })
            .registerTypeAdapter(Date.class, new JsonSerializer<Date>() {
                @Override
                public JsonElement serialize(Date date, Type typeOfSrc, JsonSerializationContext context) {
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
                    String dateString = simpleDateFormat.format(date);
                    return new JsonPrimitive(dateString);
                }
            })
            .serializeNulls()
            .create();


    public static final  Gson gsonToBean = new GsonBuilder()
            .registerTypeAdapter(LocalDateTime.class, new JsonDeserializer() {
                @Override
                public LocalDateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                    return LocalDateTime.parse(json.getAsJsonPrimitive().getAsString(), DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN));
                }
            })
            .registerTypeAdapter(LocalDate.class, new JsonDeserializer() {
                @Override
                public LocalDate deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                    return LocalDate.parse(json.getAsJsonPrimitive().getAsString(), DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
                }
            })
            .registerTypeAdapter(Date.class, new JsonDeserializer() {
                @SneakyThrows
                @Override
                public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
                    return simpleDateFormat.parse(json.getAsJsonPrimitive().getAsString());
                }
            })
            .create();

    public static String toString(Object obj) {
        if (obj.getClass() == String.class) {
            return (String) obj;
        }
        try {
            return gsonToJson.toJson(obj);
        } catch (Exception e) {
            log.error("json序列化出错:" + obj, e);
            return null;
        }
    }

    public static <T> T toBean(String json, Class<T> tClass) {
        if(json == null || json.equals("")){
            return null;
        }
        try {
            return gsonToBean.fromJson(json, tClass);
        } catch (Exception e) {
            log.error("json解析Bean出错:" + json, e);
            return null;
        }
    }

    public static <E> List<E> toList(String json, Class<E> eClass) {
        try {
            return gsonToBean.fromJson(json, new TypeToken<List<E>>(){}.getType());
        } catch (Exception e) {
            log.error("json解析List出错:" + json, e);
            return null;
        }
    }

    public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return gsonToBean.fromJson(json, new TypeToken<Map<K, V>>(){}.getType());
        } catch (Exception e) {
            log.error("json解析出错:" + json, e);
            return null;
        }
    }

    public static <T> T nativeRead(String json,  TypeToken typeToken) {
        try {
            return gsonToBean.fromJson(json, typeToken.getType());
        } catch (Exception e) {
            log.error("json解析出错:" + json, e);
            return null;
        }
    }

}

2.3、Fastjson

2.3.1、概述:
	JSON、JSONObject都是FastJson框架中的东西,JSON协议使用方便,越来越流行,JSON的处理器有很多,这里先介绍一下FastJson,FastJson是阿里的开源框架,被不少企业使用,是一个极其优秀的Json框架。
2.3.2、优点:

​ 1.FastJson数度快,无论序列化和反序列化,都是当之无愧的fast

​ 2.功能强大(支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum)

​ 3.零依赖(没有依赖其它任何类库)

2.3.3、JSON、JSONObject、javabean关系的解析:

​ 首先JSON、JSONObject是属于FastJson框架的类,它们就是普通的类只不过在FastJson框架赋予了它们对json格式字符的处理能力。

JSON:fastJson的解析器,用于JSON格式字符串与JSON对象及javaBean之间的转换。

JSONObject:fastJson提供处理对象样子的json字符的类。

2.3.4、使用方法:
//maven依赖
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.58</version>
</dependency>

//导包
import com.alibaba.fastjson.JSONObject;


//序列化
String jsonString = JSON.toJSONString(updateResponse)
//反序列化
Student student = JSON.parseObject("对象样子的json字符", new TypeReference<Student>() {});

//反序列化 json格式数据(需要是最外层为{}包裹的)转换为Map集合
//如果最外层是[]包裹的,则需要使用parseArray()方法来处理转换为List集合
Map<String, String> spec = JSON.parseObject(sku.getSpec(), Map.class);

//将json格式字符串转换成List集合, 如果json字符串最外层是方括号[]使用这个方法
//JSON.parseArray();

2.4、性能对比及选择

当数据量较小的时候(1~100),建议使用 Gson;
当数据量较大的时候,建议使用Jackson;
在大数据量的时候,虽然FastJson优势上来了,但是因为有漏洞,不得不放弃。

你可能感兴趣的:(认证授权服务实战(鉴权),java,spring,开发语言)