常用的JSON轉換工具類

阿新 • • 發佈：2019-01-24

最近在寫專案的時候，經常會有String轉Object以及Object轉Json字串的需求，或者JSONArray轉Lsit以及List轉JSONArray的需求，所以抽時間封裝一個常用Json工具類。

下面就直接上程式碼，都是一些在專案中經常用到的轉換。

package com.cherry.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.type.JavaType;
import org.codehaus.jackson.type.TypeReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * @author  
[email protected]
 * @create 2018/6/14 10:16
 * @desc Json工具類
 */
public class JsonTools {

    private static final Logger log = LoggerFactory.getLogger(JsonTools.class);

    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 物件欄位全部列入
        objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_DEFAULT);

        // 取消預設轉換timestamps形式
        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);

        // 忽略空bean轉json的錯誤
        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);

        // 統一日期格式yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

        // 忽略在json字串中存在,但是在java物件中不存在對應屬性的情況
        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * object轉Json字串
     *
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> String obj2String(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            log.error("Parse object to String error",e);
            return null;
        }
    }

    /**
     * Object轉json字串並格式化美化
     *
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> String obj2StringPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (Exception e) {
            log.error("Parse object to String error",e);
            return null;
        }
    }

    /**
     * string轉object
     *
     * @param str   json字串
     * @param clazz 被轉物件class
     * @param <T>
     * @return
     */
    public static <T> T string2Obj(String str, Class<T> clazz) {
        if (StringUtils.isEmpty(str) || clazz == null) {
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (IOException e) {
            log.error("Parse String to Object error",e);
            return null;
        }
    }

    /**
     * string轉object
     *
     * @param str  json字串
     * @param typeReference 被轉物件引用型別
     * @param <T>
     * @return
     */
    public static <T> T string2ObjRef(String str, TypeReference<T> typeReference) {
        if (StringUtils.isEmpty(str) || typeReference == null) {
            return null;
        }
        try {
            return (T) (typeReference.getType().equals(String.class) ? str : objectMapper.readValue(str, typeReference));
        } catch (IOException e) {
            log.error("Parse String to Object error",e);
            return null;
        }
    }

    /**
     * string轉collection 用於轉為集合物件
     *
     * @param str  json字串
     * @param collectionClass 被轉集合class
     * @param elementClasses  被轉集合中物件型別class
     * @param <T>
     * @return
     */
    public static <T> T string2Collection(String str, Class<?> collectionClass, Class<?>... elementClasses) {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
        try {
            return objectMapper.readValue(str, javaType);
        } catch (IOException e) {
            log.error("Parse String to Collection error",e);
            return null;
        }
    }

    /**
     * 根據JSONArray String獲取到List
     *
     * @param <T>
     * @param <T>
     * @param jArrayStr
     * @return
     */
    public static <T> List<T> getListByJSONArray(Class<T> class1, String jArrayStr) {
        List<T> list = new ArrayList<>();
        JSONArray jsonArray = JSONArray.parseArray(jArrayStr);
        if (jsonArray == null || jsonArray.isEmpty()) {
            return list;//nerver return null
        }
        for (Object object : jsonArray) {
            JSONObject jsonObject = (JSONObject) object;
            T t = JSONObject.toJavaObject(jsonObject, class1);
            list.add(t);
        }
        return list;
    }

    /**
     * 根據List獲取到對應的JSONArray
     *
     * @param list
     * @return
     */
    public static JSONArray getJSONArrayByList(List<?> list) {
        JSONArray jsonArray = new JSONArray();
        if (list == null || list.isEmpty()) {
            return jsonArray;//nerver return null
        }
        for (Object object : list) {
            jsonArray.add(object);
        }
        return jsonArray;
    }
}

Test測試類

@Test
    public void obj2String() {
        Student student = new Student(1001, "xiaoming", "M", 80.2);
        String s = JsonTools.obj2String(student);
        System.out.println(s);
    }

@Test
    public void obj2StringPretty() {
        Student student = new Student(1001, "xiaoming", "M", 80.2);
        String s = JsonTools.obj2StringPretty(student);
        System.out.println(s);
    }

@Test
    public void string2Obj() {
        String s = "{\n" +
                "  \"id\" : 1001,\n" +
                "  \"name\" : \"xiaoming\",\n" +
                "  \"sex\" : \"M\",\n" +
                "  \"grade\" : 80.2\n" +
                "}";
        Student student = JsonTools.string2Obj(s, Student.class);
        System.out.println(student);
    }

@Test
    public void string2ObjRef() {
        Student xiaoming = new Student(1001, "xiaoming", "M", 80.2);
        Student xiaobai = new Student(1002, "xiaobai", "F", 80.3);
        List<Student> studentList = new ArrayList<>();
        studentList.add(xiaoming);
        studentList.add(xiaobai);
        String studentListStr = JsonTools.obj2StringPretty(studentList);
        List<Student> studentListObj = JsonTools.string2ObjRef(studentListStr, new TypeReference<List<Student>>() {
        });
        System.out.println(studentListObj.toString());
    }

@Test
    public void string2Collection() {
        Student xiaoming = new Student(1001, "xiaoming", "M", 80.2);
        Student xiaobai = new Student(1002, "xiaobai", "F", 80.3);
        List<Student> studentList = new ArrayList<>();
        studentList.add(xiaoming);
        studentList.add(xiaobai);
        String studentListStr = JsonTools.obj2StringPretty(studentList);
        //List<Student> studentListObj = JsonTools.string2ObjRef(studentListStr, new TypeReference<List<Student>>(){});
        // 依次傳入集合以及集合中物件型別的class
        List<Student> studentListObj = JsonTools.string2Collection(studentListStr, List.class, Student.class);
        System.out.println(studentListObj.toString());
    }

@Test
    public void getListByJSONArray() {
        //定義一個數組
        List<Student> students = new ArrayList<>();
        Student xiaoming = new Student(1001, "xiaoming", "M", 80.2);
        Student xiaohong = new Student(1002, "xiaohong", "M", 80.2);
        students.add(xiaoming);
        students.add(xiaohong);
        //將List轉換為jsonArray
        JSONArray student = JsonTools.getJSONArrayByList(students);
        //將jsonArray轉為List
        List<Student> studentList = JsonTools.getListByJSONArray(Student.class, student.toJSONString());
        System.out.println(studentList);
    }

@Test
    public void getJSONArrayByList() {
        //定義一個數組
        List<Student> students = new ArrayList<>();
        Student xiaoming = new Student(1001, "xiaoming", "M", 80.2);
        Student xiaobai = new Student(1002, "xiaobai", "M", 80.2);
        students.add(xiaoming);
        students.add(xiaobai);
        //將List轉換為jsonArray
        JSONArray student = JsonTools.getJSONArrayByList(students);
        System.out.println(student.toJSONString());
    }

pom.xml

<!-- JsonTools -->
 <dependency>
     <groupId>org.codehaus.jackson</groupId>
     <artifactId>jackson-mapper-asl</artifactId>
     <version>1.9.13</version>
 </dependency>

常用的JSON轉換工具類

最近在寫專案的時候，經常會有String轉Object以及Object轉Json字串的需求，或者JSONArray轉Lsit以及List轉JSONArray的需求，所以抽時間封裝一個常用Json工具類。下面就直接上程式碼，都是一些在專案中經常用到的轉換。pac

使用Gson的Json轉換工具類

space .com p s win left ebo href face get 382bt我S辭籃廝0綽yhttp://www.facebolw.com/space/2102274 u6靡q壬第62曳ihttp://www.facebolw.com/space/210

java json轉換工具類

在java專案中，通常會用到json型別的轉換，常常需要對 json字串和物件進行相互轉換。在製作自定義的json轉換類之前，先引入以下依賴  <dependency> <groupId>com.fasterx

定義vo類和JSON轉換工具類

通過JSON自動的處理機制需要進行多層VO物件的取得,這樣的做法在實際工作中比較麻煩,也不建議使用,所以此時如果是一個單獨的VO物件則可以自己編寫一個程式類. 定義BO與JSON的轉換處理 package mao.shu.util; import java.lang

json轉換工具類

package com.test.common; import java.io.IOException; import java.util.Collection; import java.util.HashMap; import java.util.Map; impor

C#常用資料型別轉換工具類

using System.Collections; using System.Collections.Generic; using UnityEngine; using System; using System.IO; using System.Text; /// <summary> /

java常用工具類（二）—— JSON處理工具類

tor ast val simple sta 轉換 local pass password package com.springboot.commons.utils; import com.springboot.commons.scan.JacksonObjectMapp

Json字串與實體集轉換工具類——SpringBootQuickStart

開始更新SpringBoot2.x 快速入門系列本次分享一個常用的工具類，實體集與字串互相轉換的工具類，也就是Json字串的序列化與反序列化 Demo 下載： https://github.com/wangyushuai/springboot-quick-start 歡迎大

java 物件與json字串互相轉換工具類

需要引入的jar包： JsonUtil.java檔案： package

Java8之後常用的時間日期之間的轉換工具類

package com.ilike.time;import java.time.Instant;import java.time.LocalDateTime;import java.time.ZoneId;import java.time.format.DateTimeFor

JSON對象與XML相互轉換工具類

reat lse 1.2 ace 文件內容 apache 相互 order content 依賴jar <dependency> <groupId>dom4j</groupId>

java專案常用工具類之beancopy，bean和map轉換工具類

專案環境： jdk1.8+spring4.3.12 一、問題描述及試用場景：在專案規範中，要求類名以DO為尾的類作為資料庫層實體bean，類名以MO為尾的類作為系統傳輸層實體bean，類名以VO為尾的類作為服務端與前端互動的實體bean。由於以上要求，需

常用的日期工具類

pbe minutes sse 類型 sca 格式 param gettime don 對於開發中的日期工具類進行總結： package com.yunhwa.base.util; import java.math.BigDecimal;import java.sql.

java(二)：工作中常用到的工具類

java 工具類工作中大家要用到很多工具類，第三方的jar中有很多現成的工具類符合自己的項目需要，這個時候就不需要去重復造輪子了，從而節省了很多時間，大家可以利用這些時間去做其它重要的事情，如果沒有符合自己的工具類，這個時候就要寫自己的工具類了,下面列舉一些工作中常用的工具類。1、

Java時間格式轉換工具類

string stact 修改 stack time mil 日期格式轉換 pla gettime 把當前時間修改成指定時間 //把當前時間修改成指定時間 public String dateUtil(Integer seconds, String dateFo

Java中將字符串與unicode的相互轉換工具類

png style nic ava param 字符串拼接 size tostring info unicode編碼規則 unicode碼對每一個字符用4位16進制數表示。具體規則是：將一個字符(char)的高8位與低8位分別取出，轉化為16進制數，如果轉化的16進制數的長

常用的併發工具類

在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier、Semaphore和Exchange CountDownLatch CountDownLatch是一個同步計數器，初始化的時候傳入需要計數的執行

SpringBoot中預設json轉換工具Jackson

Spring Boot 內建了jackson來完成JSON的序列化和反序列化操作。Jackson使用ObjectMapper類將POJO物件序列化成JSON字串，也能將JSON字串反序列化成POJO物件。 JackSon支援三種層次的序列化和反序列化方式：採用JsonParser來解

json處理工具類

package com.sys.util; import java.util.List; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JavaType

前端常用外掛及工具類庫彙總

函式庫 Lodash（推薦）：github.com/lodash/loda… Underscore：underscorejs.org/ Ramda：github.com/ramda/ramda outils：github.com/proYang/out… 30-seconds-o

常用的JSON轉換工具類

相關推薦