classe d'outils fastjson2

Pourquoi avons-nous besoin de classes d’outils auto-encapsulées ? En prenant fastjson dans cet article comme exemple, dans le développement quotidien, lors de l'utilisation de fastjson, il est écrit directement comme suit :

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

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

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

Il n'y a aucun problème de cette façon, mais lors de la transformation du système et de la mise à niveau ultérieure, j'ai décidé de mettre à niveau fastjson vers fastjson2. Toutes les classes qui utilisent fastjson et les endroits où le package est importé doivent être modifiés. Bien qu'il puisse être remplacé globalement, il Il y a beaucoup de fichiers à modifier. , vous devez toujours le vérifier après avoir effectué les modifications. Mais s'il existe une classe d'outils unifiée, il vous suffit de changer la classe d'outils. Les autres endroits où cette classe d'outils est utilisée n'ont pas besoin d'être modifiés. C'est très pratique et sans erreur.

Il existe d'autres exemples, tels que log. Dans Springboot, la journalisation par défaut est utilisée, et certains endroits ou autres projets utilisent log4j. Afin de l'unifier plus tard, il doit être remplacé par l'un d'entre eux. S'il existe une classe d'outil de journalisation , puis passez à une autre. Pour le journal, changez simplement la classe d'outil, sinon vous devez modifier les fichiers un par un.

Ce qui suit est une classe d'outils fastjson simple qui peut être copiée et utilisée directement : 

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);
    }

}