clase de herramienta fastjson2

¿Por qué necesitamos algunas clases de herramientas autoencapsuladas? Tomando fastjson en este artículo como ejemplo, en el desarrollo diario, cuando se usa fastjson, se escribe directamente de la siguiente manera:

// ****** 常见的用法 ******

// 把对象转成json字符串
JSON.toJSONString(response);

// 把json字符串转成对象
Response response = JSON.parseObject(str, Response.class);

No hay ningún problema de esta manera, pero al realizar la transformación y actualización del sistema más tarde, decidí actualizar fastjson a fastjson2. Todas las clases que usan fastjson y los lugares donde se importa el paquete deben cambiarse. Aunque se puede reemplazar globalmente, hay Hay muchos archivos para cambiar. Aún debe verificarlo después de realizar los cambios. Pero si hay una clase de herramienta unificada, solo necesita cambiar la clase de herramienta, y no es necesario cambiar otros lugares donde se usa esta clase de herramienta, lo cual es muy conveniente y sin errores.

Hay otros ejemplos, como log. En springboot se usa el logback predeterminado, y algunos lugares u otros proyectos usan log4j. Para unificarlo más tarde, se debe cambiar a uno de ellos. Si hay una clase de herramienta de registro , luego cambie a diferente Para el registro, simplemente cambie la clase de herramienta; de lo contrario, tendrá que cambiar los archivos uno por uno.

La siguiente es una clase de herramienta fastjson simple que se puede copiar y usar directamente: 

package com.xxxx.xxxx;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

import java.util.List;

public class JsonUtil {

    /**
     * 将对象转换为JSON字符串
     * @param obj 要转换为JSON的对象
     * @return JSON字符串
     */
    public static String toJSONString(Object obj) {
        return JSON.toJSONString(obj);
    }

    /**
     * 将对象转换为byte[]
     * @param obj 要转换为JSON的对象
     * @return byte[]
     */
    public static byte[] toJSONBytes(Object obj) {
        return JSON.toJSONBytes(obj);
    }

    /**
     * 将JSON字符串转换为指定类型的对象
     * @param jsonString JSON字符串
     * @param clazz 目标对象类型的Class
     * @param <T> 目标对象的类型
     * @return 转换后的目标对象
     */
    public static <T> T parseObject(String jsonString, Class<T> clazz) {
        return JSON.parseObject(jsonString, clazz);
    }

    /**
     * 将JSON字符串转换为指定类型的list
     * @param jsonString JSON字符串
     * @param clazz 目标对象类型的Class
     * @param <T> 目标对象的类型
     * @return 转换后的目标对象
     */
    public static <T> List<T> parseArray(String jsonString, Class<T> clazz) {
        return JSON.parseArray(jsonString, clazz);
    }

    /**
     * 将JSON字符串转换为JSONObject对象
     * @param jsonString JSON字符串
     * @return 转换后的JSONObject对象
     */
    public static JSONObject parseJSONObject(String jsonString) {
        return JSON.parseObject(jsonString);
    }

    /**
     * 将JSON字符串转换为JSONArray对象
     * @param jsonString JSON字符串
     * @return 转换后的JSONArray对象
     */
    public static JSONArray parseJSONArray(String jsonString) {
        return JSON.parseArray(jsonString);
    }

    /**
     * 将Java对象转换为JSONObject对象
     * @param obj Java对象
     * @return 转换后的JSONObject对象
     */
    public static JSONObject toJSONObject(Object obj) {
        return (JSONObject) JSON.toJSON(obj);
    }

    /**
     * 将Java对象转换为JSONArray对象
     * @param obj Java对象
     * @return 转换后的JSONArray对象
     */
    public static JSONArray toJSONArray(Object obj) {
        return (JSONArray) JSON.toJSON(obj);
    }

}