【Java】Fastjson2Utils(Fastjson2 工具类)

Java Fastjson2 工具类

import com.alibaba.fastjson2.*;
import com.alibaba.fastjson2.reader.ObjectReaderProvider;
import com.alibaba.fastjson2.util.ParameterizedTypeImpl;
import com.alibaba.fastjson2.util.TypeUtils;
import lombok.NonNull;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;

/**
 * @since 2.0.4
 */
public class Fastjson2Utils {

    private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
    private static final ThreadLocal<SimpleDateFormat> __dateFormatter
            = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    private static final Function<LocalDateTime, String> dateTimeSerializer
            = dateTimeFormatter::format;
    private static final Function<LocalDate, String> dateSerializer
            = dateFormatter::format;
    private static final Function<LocalTime, String> timeSerializer
            = timeFormatter::format;
    private static final Function<Date, String> __dateSerializer
            = json -> __dateFormatter.get().format(json);

    private static final Function<String, LocalDateTime> dateTimeDeserializer
            = json -> LocalDateTime.parse(json, dateTimeFormatter);
    private static final Function<String, LocalDate> dateDeserializer
            = json -> LocalDate.parse(json, dateFormatter);
    private static final Function<String, LocalTime> timeDeserializer
            = json -> LocalTime.parse(json, timeFormatter);
    private static final Function<String, Date> __dateDeserializer
           = json -> {
               try { return __dateFormatter.get().parse(json); }
               catch (Exception e) { throw new RuntimeException(e); }
           };

    private static final ObjectReaderProvider provider;

    static {
        provider = JSONFactory.getDefaultObjectReaderProvider();
        provider.registerTypeConvert(String.class, Date.class, __dateDeserializer);
        provider.registerTypeConvert(String.class, LocalDateTime.class, dateTimeDeserializer);
        provider.registerTypeConvert(String.class, LocalDate.class, dateDeserializer);
        provider.registerTypeConvert(String.class, LocalTime.class, timeDeserializer);
        provider.registerTypeConvert(Date.class, String.class, __dateSerializer);
        provider.registerTypeConvert(LocalDateTime.class, String.class, dateTimeSerializer);
        provider.registerTypeConvert(LocalDate.class, String.class, dateSerializer);
        provider.registerTypeConvert(LocalTime.class, String.class, timeSerializer);
    }

    public static ParameterizedType makeJavaType(Type rawType, Type... typeArguments) {
        return new ParameterizedTypeImpl(typeArguments, null, rawType);
    }

    public static String toString(Object value) {
        if (Objects.isNull(value)) {
            return null;
        }
        if (value instanceof String) {
            return (String) value;
        }
        return toJSONString(value);
    }

    public static String toJSONString(Object value) {
        return JSON.toJSONString(value);
    }

    public static String toPrettyString(Object value) {
        return JSON.toJSONString(value, JSONWriter.Feature.PrettyFormat);
    }

    public static Object fromJavaObject(Object value) {
        Object result = null;
        if (Objects.nonNull(value) && (value instanceof String)) {
            result = parseObject((String) value);
        } else {
            result = JSON.toJSON(value);
        }
        return result;
    }

    public static Object parseObject(String content) {
        /*
        try {
            return JSON.parseObject(content);
        } catch (JSONException ex) {
            Throwable cause = ex.getCause();
            if (Objects.nonNull(cause)
                    && cause instanceof ClassCastException
                    && cause.getMessage().contains("JSONArray")) {
                return JSON.parseArray(content);
            }
            throw ex;
        }
        */
        return JSON.parseObject(content, Object.class);
    }

    public static Object getJsonElement(JSONObject node, String name) {
        return node.get(name);
    }

    public static Object getJsonElement(JSONArray node, int index) {
        return node.get(index);
    }

    public static <T> T toJavaObject(Object node, Class<T> clazz) {
        return JSON.to(clazz, node);
    }

    @SuppressWarnings("unchecked")
    public static <T> T toJavaObject(@NonNull Object node, Type type) {
        if (node instanceof JSONObject) {
            return ((JSONObject) node).to(type);
        }
        if (node instanceof JSONArray) {
            return ((JSONArray) node).to(type);
        }
        if (node instanceof String) {
            return JSON.parseObject((String) node, type);
        }
        return (T) TypeUtils.cast(node, TypeUtils.getClass(type));
    }

    @SuppressWarnings("unchecked")
    public static <T> T toJavaObject(@NonNull Object node, TypeReference<T> typeReference) {
        if (node instanceof JSONObject) {
            return typeReference.to((JSONObject) node);
        }
        if (node instanceof JSONArray) {
            return typeReference.to((JSONArray) node);
        }
        if (node instanceof String) {
            return JSON.parseObject((String) node, typeReference);
        }
        return (T) TypeUtils.cast(node, typeReference.getRawType());
    }

    public static <E> List<E> toJavaList(Object node, Class<E> clazz) {
        return toJavaObject(node, makeJavaType(List.class, clazz));
    }

    public static List<Object> toJavaList(Object node) {
        return toJavaObject(node, new TypeReference<List<Object>>(){});
    }

    public static <V> Map<String, V> toJavaMap(Object node, Class<V> clazz) {
        return toJavaObject(node, makeJavaType(Map.class, String.class, clazz));
    }

    public static Map<String, Object> toJavaMap(Object node) {
        return toJavaObject(node, new TypeReference<Map<String, Object>>(){});
    }

    public static <T> T toJavaObject(String content, Class<T> clazz) {
        return JSON.parseObject(content, clazz);
    }

    public static <T> T toJavaObject(String content, Type type) {
        return JSON.parseObject(content, type);
    }

    public static <T> T toJavaObject(String content, TypeReference<T> typeReference) {
        return JSON.parseObject(content, typeReference);
    }

    public static <E> List<E> toJavaList(String content, Class<E> clazz) {
        return JSON.parseObject(content, makeJavaType(List.class, clazz));
    }

    public static List<Object> toJavaList(String content) {
        return JSON.parseObject(content, new TypeReference<List<Object>>(){});
    }

    public static <V> Map<String, V> toJavaMap(String content, Class<V> clazz) {
        return JSON.parseObject(content, makeJavaType(Map.class, String.class, clazz));
    }

    public static Map<String, Object> toJavaMap(String content) {
        return JSON.parseObject(content, new TypeReference<Map<String, Object>>(){});
    }

}
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用 Fastjson 解析 JSON 文件很简单,只需要按照以下步骤操作即可: 1. 导入 Fastjson 的 jar 包 在你的项目中导入 Fastjson 的 jar 包,你可以从官网 https://github.com/alibaba/fastjson/releases 下载最新版本的 jar 包。 2. 创建 JSON 对象 使用 FastjsonJSON 类可以创建一个 JSON 对象,可以是一个 JSONObject 或者 JSONArray。 ``` import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; public class JsonTest { public static void main(String[] args) { // JSON 对象可以是 JSONObject 或者 JSONArray JSONObject json = new JSONObject(); json.put("name", "Tom"); json.put("age", 18); JSONArray jsonArray = new JSONArray(); jsonArray.add("apple"); jsonArray.add("banana"); jsonArray.add("orange"); // 将 JSON 对象转换成字符串 String jsonString = JSON.toJSONString(json); System.out.println(jsonString); // 将 JSON 数组转换成字符串 String jsonArrayString = JSON.toJSONString(jsonArray); System.out.println(jsonArrayString); } } ``` 3. 解析 JSON 对象 使用 FastjsonJSON 类的 parseObject 方法可以将 JSON 字符串解析成一个 Java 对象。 ``` import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; public class JsonTest { public static void main(String[] args) { String jsonString = "{\"name\":\"Tom\",\"age\":18}"; // 将 JSON 字符串解析成 Java 对象 JSONObject json = JSON.parseObject(jsonString); System.out.println(json.getString("name")); System.out.println(json.getInteger("age")); } } ``` 4. 解析 JSON 数组 使用 FastjsonJSON 类的 parseArray 方法可以将 JSON 数组字符串解析成一个 Java 对象数组。 ``` import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; public class JsonTest { public static void main(String[] args) { String jsonArrayString = "[\"apple\",\"banana\",\"orange\"]"; // 将 JSON 数组字符串解析成 Java 对象数组 JSONArray jsonArray = JSON.parseArray(jsonArrayString); for (Object obj : jsonArray) { System.out.println(obj.toString()); } } } ``` 以上就是使用 Fastjson 解析 JSON 文件的基本操作。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值