java----JSON

 JSON：

下載組件 GSON jar 包

https://mvnrepository.com/artifact/com.google.code.gson/gson

建立JSON

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

import java.io.*;
import java.util.ArrayList;


public class Demo {
    public static void main(String[] args) throws IOException {
        createJson();
    }
    public static void createJson(){
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("花花",10));
        list.add(new Person("哈哈",12));
        JsonArray jsonElements = new JsonArray();
        for (int i = 0; i < list.size(); i++) {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("name",list.get(i).getName());
            jsonObject.addProperty("age",list.get(i).getAge());
            jsonElements.add(jsonObject);
        }
        //
        System.out.println(jsonElements.toString());
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("a.json"));
            bw.write(jsonElements.toString());
            bw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

　　

解析json數據(適合解析複雜的json數據)

必須嚴格準守解析流程，中途若是出現錯誤，就會發生解析失敗

[]  : beginArray;

{} : beginObject;

import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;

import java.io.*;
import java.util.ArrayList;

public class Demo {
    public static void main(String[] args){
        jsonParse();
    }
    public static void jsonParse(){
        try {
            InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json\\person_json.json");
            InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
            //json解釋工具a
            JsonReader jsonReader = new JsonReader(inputStreamReader);
            ArrayList<Person> nameList = new ArrayList<>();
            //開始解析數組
            jsonReader.beginArray();
            while (jsonReader.hasNext()){
                nameList.add(parsePerson(jsonReader));
            }
            //結束解析數組
            jsonReader.endArray();
            nameList.forEach((p)-> System.out.println(p));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static Person parsePerson(JsonReader jsonReader) throws IOException {
        Person person = new Person();
        jsonReader.beginObject();
        while (jsonReader.hasNext()){
            String name = jsonReader.nextName();
            if ("name".equals(name)&&jsonReader.peek()!=JsonToken.NUMBER){
                person.setName(jsonReader.nextString());
            }else if("age".equals(name)){
                person.setAge(Integer.parseInt(jsonReader.nextString()));
            }else{
                //表示當全部都不成立的時候,就跳過該字段；解析下一個
                jsonReader.skipValue();
            }
        }
        jsonReader.endObject();
        return person;
    }
}
class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json數據

[{"name":"花花","age":"10"},{"name":"哈哈","age":"10"}]

　　

補充：

{"name":null}

while (jsonReader.hasNext()){
            String name = jsonReader.nextName();
            if ("name".equals(name)&&jsonReader.peek()!=JsonToken.NULL){
                person.setName(jsonReader.nextString());//表示若是name爲空，就不設置值，此時默認狀況下，就爲空
            }else{
　　　　　　　　　　//跳過該字段
　　　　　　　　　　jsonReader.skipValue()　
　　　　　　　}
}

 

JsonReader.peek()：看看值：沒有真正的讀取；(即光標沒有移動)

JsonToken.STRING  ：值是否爲字符串

JsonToken.NUMBER：值是否爲數字

jsonReader.nextString()：讀取字符串；

JsongReader.nextInt()：讀取int數據

jsonReader.nextDouble()：讀取數組：

 

使用GSON工具解析json數據爲單個對象

將一個java對象轉換爲json字符串，或者將json字符串解析並建立java對象

注意：只能是一個對象；

import com.google.gson.Gson;

import java.io.*;

public class Demo {
    public static void main(String[] args) {
        Mygson();
    }

    private static void Mygson() {
        Gson gson = new Gson();
        InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json\\person_json.json");
        InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
        Person person = gson.fromJson(inputStreamReader, Person.class);
        System.out.println(person);
    }
}
class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json數據

{"name":"花花","age":10}

　　

把一組JSON數據轉換爲java對象集合，或者把一個java對象集合轉換爲Json字符串

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.*;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        Mygson();
    }

    private static void Mygson() {
        Gson gson = new Gson();
        InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json" +
                "\\person_json.json");
        InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
        TypeToken<List<Person>> listTypeToken = new TypeToken<List<Person>>() {
        };
        List<Person> list = gson.fromJson(inputStreamReader, listTypeToken.getType());
        System.out.println(list);
        System.out.println("---------------------------------------------------------");

        //將list對象轉換json字符串
        String s = gson.toJson(list, listTypeToken.getType());
        System.out.println(s);
    }
}
class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json數據

[{"name":"花花","age":"10"},{"name":"哈哈","age":"10"}]

　　

 

MapperUtils

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class MapperUtils {
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static ObjectMapper getInstance() {
        return objectMapper;
    }

    /**
     * 轉換爲 JSON 字符串
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2json(Object obj) throws Exception {
        return objectMapper.writeValueAsString(obj);
    }

    /**
     * 轉換爲 JSON 字符串，忽略空值
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2jsonIgnoreNull(Object obj) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }

    /**
     * 轉換爲 JavaBean
     *
     * @param jsonString
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception {
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }

    /**
     * 字符串轉換爲 Map<String, Object>
     *
     * @param jsonString
     * @return
     * @throws Exception
     */
    public static <T> Map<String, Object> json2map(String jsonString) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }

    /**
     * 字符串轉換爲 Map<String, T>
     */
    public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception {
        Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() {
        });
        Map<String, T> result = new HashMap<String, T>();
        for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) {
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }

    /**
     * 深度轉換 JSON 成 Map
     *
     * @param json
     * @return
     */
    public static Map<String, Object> json2mapDeeply(String json) throws Exception {
        return json2MapRecursion(json, objectMapper);
    }

    /**
     * 把 JSON 解析成 List，若是 List 內部的元素存在 jsonString，繼續解析
     *
     * @param json
     * @param mapper 解析工具
     * @return
     * @throws Exception
     */
    private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        List<Object> list = mapper.readValue(json, List.class);

        for (Object obj : list) {
            if (obj != null && obj instanceof String) {
                String str = (String) obj;
                if (str.startsWith("[")) {
                    obj = json2ListRecursion(str, mapper);
                } else if (obj.toString().startsWith("{")) {
                    obj = json2MapRecursion(str, mapper);
                }
            }
        }

        return list;
    }

    /**
     * 把 JSON 解析成 Map，若是 Map 內部的 Value 存在 jsonString，繼續解析
     *
     * @param json
     * @param mapper
     * @return
     * @throws Exception
     */
    private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        Map<String, Object> map = mapper.readValue(json, Map.class);

        for (Map.Entry<String, Object> entry : map.entrySet()) {
            Object obj = entry.getValue();
            if (obj != null && obj instanceof String) {
                String str = ((String) obj);

                if (str.startsWith("[")) {
                    List<?> list = json2ListRecursion(str, mapper);
                    map.put(entry.getKey(), list);
                } else if (str.startsWith("{")) {
                    Map<String, Object> mapRecursion = json2MapRecursion(str, mapper);
                    map.put(entry.getKey(), mapRecursion);
                }
            }
        }

        return map;
    }

    /**
     * 將 JSON 數組轉換爲集合
     *
     * @param jsonArrayStr
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> list = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return list;
    }


    /**
     * 獲取泛型的 Collection Type
     *
     * @param collectionClass 泛型的Collection
     * @param elementClasses  元素類
     * @return JavaType Java類型
     * @since 1.0
     */
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

    /**
     * 將 Map 轉換爲 JavaBean
     *
     * @param map
     * @param clazz
     * @return
     */
    public static <T> T map2pojo(Map map, Class<T> clazz) {
        return objectMapper.convertValue(map, clazz);
    }

    /**
     * 將 Map 轉換爲 JSON
     *
     * @param map
     * @return
     */
    public static String mapToJson(Map map) {
        try {
            return objectMapper.writeValueAsString(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 將 JSON 對象轉換爲 JavaBean
     *
     * @param obj
     * @param clazz
     * @return
     */
    public static <T> T obj2pojo(Object obj, Class<T> clazz) {
        return objectMapper.convertValue(obj, clazz);
    }
}

 使用

ObjectMapper instance = MapperUtils.getInstance(); 
JsonNode jsonNode = instance.readTree(data);  //封裝的json字符串
JsonNode data1 = jsonNode.findPath("data");   //找到key爲data的數據
String s = data1.toString();                  //data1轉換爲String
List<TbContent> tbContentDtos = MapperUtils.json2list(s, TbContent.class);  //json數據變成java對象
        

 

使用 Jackson 處理 JSON 數據

Jackson 簡介

Jackson 是一個簡單基於 Java 應用庫，Jackson 能夠輕鬆的將 Java 對象轉換成 json 對象和 xml 文檔，一樣也能夠將 json、xml 轉換成 Java 對象。Jackson 所依賴的 jar 包較少，簡單易用而且性能也要相對高些，而且 Jackson 社區相對比較活躍，更新速度也比較快。

Jackson 特色

• 容易使用 - jackson API 提供了一個高層次外觀，以簡化經常使用的用例。
• 無需建立映射 - API提供了默認的映射大部分對象序列化。
• 性能高 - 快速，低內存佔用，適合大型對象圖表或系統。
• 乾淨的 JSON - jackson 建立一個乾淨和緊湊的 JSON 結果，這是讓人很容易閱讀。
• 不依賴 - 庫不須要任何其餘的庫，除了 JDK。
• 開源代碼 - jackson 是開源的，能夠無償使用。

Jackson 註解

Jackson 類庫包含了不少註解，可讓咱們快速創建 Java 類與 JSON 之間的關係。

@JsonProperty

@JsonProperty 註解指定一個屬性用於 JSON 映射，默認狀況下映射的 JSON 屬性與註解的屬性名稱相同，不過可使用該註解的 value 值修改 JSON 屬性名，該註解還有一個 index 屬性指定生成 JSON 屬性的順序，若是有必要的話。

@JsonIgnore

@JsonIgnore 註解用於排除某個屬性，這樣該屬性就不會被 Jackson 序列化和反序列化。

@JsonIgnoreProperties

@JsonIgnoreProperties 註解是類註解。在序列化爲 JSON 的時候，@JsonIgnoreProperties({"prop1", "prop2"}) 會忽略 pro1 和 pro2 兩個屬性。在從 JSON 反序列化爲 Java 類的時候，@JsonIgnoreProperties(ignoreUnknown=true) 會忽略全部沒有 Getter 和 Setter 的屬性。該註解在 Java 類和 JSON 不徹底匹配的時候頗有用。

@JsonIgnoreType

@JsonIgnoreType 也是類註解，會排除全部指定類型的屬性。

@JsonPropertyOrder

@JsonPropertyOrder 和 @JsonProperty 的 index 屬性相似，指定屬性序列化時的順序。

@JsonRootName

@JsonRootName 註解用於指定 JSON 根屬性的名稱。

Jackson 使用實例

pom添加依賴（版本本身去maven倉庫中查看最新版）

<!-- Json Begin -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>${jackson-core.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson-databind.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>${jackson-core.version}</version>
            </dependency>
<!-- Json End -->

對象的序列化與反序列化

package com.funtl.hello.httpclient;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;

public class JsonTester {
    public static void main(String[] args) {
        // 建立 ObjectMapper 對象
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";

        try {
            // 反序列化 JSON 到對象
            Student student = mapper.readValue(jsonString, Student.class);
            System.out.println(student);

            // 序列化對象到 JSON
            String json = mapper.writeValueAsString(student);
            System.out.println(json);
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Student {
    private String name;
    private int age;
}

集合的序列化與反序列化

package com.funtl.hello.httpclient;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

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

public class JsonTester {
    public static void main(String[] args) {
        // 建立 ObjectMapper 對象
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = "{\"draw\":1,\"recordsTotal\":1,\"recordsFiltered\":1,\"data\":[{\"id\":33,\"title\":\"ad1\",\"subTitle\":\"ad1\",\"titleDesc\":\"ad1\",\"url\":\"https://sale.jd.com/act/XkCzhoisOMSW.html\",\"pic\":\"https://m.360buyimg.com/babel/jfs/t20164/187/1771326168/92964/b42fade7/5b359ab2N93be3a65.jpg\",\"pic2\":\"\",\"content\":\"<p><br></p>\"}],\"error\":null}";

        try {
            // 反序列化 JSON 到樹
            JsonNode jsonNode = mapper.readTree(jsonString);

            // 從樹中讀取 data 節點
            JsonNode jsonData = jsonNode.findPath("data");
            System.out.println(jsonData);  //獲取的是一個數組(集合)

            // 反序列化 JSON 到集合
            JavaType javaType = mapper.getTypeFactory().constructParametricType(ArrayList.class, TbContent.class);
            List<TbContent> tbContents = mapper.readValue(jsonData.toString(), javaType);
            for (TbContent tbContent : tbContents) {
                System.out.println(tbContent);
            }

            // 序列化集合到 JSON
            String json = mapper.writeValueAsString(tbContents);
            System.out.println(json);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class TbContent {
    private Long id;
    private String title;
    private String subTitle;
    private String titleDesc;
    private String url;
    private String pic;
    private String pic2;
    private String content;
}

jackson工具類

package com.lusifer.leeshop.server.commons.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Jackson 工具類
 * <p>Title: MapperUtils</p>
 * <p>Description: </p>
 *
 * @author Lusifer
 * @version 1.0.0
 * @date 2018/3/4 21:50
 */
public class MapperUtils {
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static ObjectMapper getInstance() {
        return objectMapper;
    }

    /**
     * 轉換爲 JSON 字符串
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2json(Object obj) throws Exception {
        return objectMapper.writeValueAsString(obj);
    }

    /**
     * 轉換爲 JSON 字符串，忽略空值
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2jsonIgnoreNull(Object obj) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }

    /**
     * 轉換爲 JavaBean
     *
     * @param jsonString
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception {
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }

    /**
     * 字符串轉換爲 Map<String, Object>
     *
     * @param jsonString
     * @return
     * @throws Exception
     */
    public static <T> Map<String, Object> json2map(String jsonString) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }

    /**
     * 字符串轉換爲 Map<String, T>
     */
    public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception {
        Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() {
        });
        Map<String, T> result = new HashMap<String, T>();
        for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) {
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }

    /**
     * 深度轉換 JSON 成 Map
     *
     * @param json
     * @return
     */
    public static Map<String, Object> json2mapDeeply(String json) throws Exception {
        return json2MapRecursion(json, objectMapper);
    }

    /**
     * 把 JSON 解析成 List，若是 List 內部的元素存在 jsonString，繼續解析
     *
     * @param json
     * @param mapper 解析工具
     * @return
     * @throws Exception
     */
    private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        List<Object> list = mapper.readValue(json, List.class);

        for (Object obj : list) {
            if (obj != null && obj instanceof String) {
                String str = (String) obj;
                if (str.startsWith("[")) {
                    obj = json2ListRecursion(str, mapper);
                } else if (obj.toString().startsWith("{")) {
                    obj = json2MapRecursion(str, mapper);
                }
            }
        }

        return list;
    }

    /**
     * 把 JSON 解析成 Map，若是 Map 內部的 Value 存在 jsonString，繼續解析
     *
     * @param json
     * @param mapper
     * @return
     * @throws Exception
     */
    private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        Map<String, Object> map = mapper.readValue(json, Map.class);

        for (Map.Entry<String, Object> entry : map.entrySet()) {
            Object obj = entry.getValue();
            if (obj != null && obj instanceof String) {
                String str = ((String) obj);

                if (str.startsWith("[")) {
                    List<?> list = json2ListRecursion(str, mapper);
                    map.put(entry.getKey(), list);
                } else if (str.startsWith("{")) {
                    Map<String, Object> mapRecursion = json2MapRecursion(str, mapper);
                    map.put(entry.getKey(), mapRecursion);
                }
            }
        }

        return map;
    }

    /**
     * 將 JSON 數組轉換爲集合
     *
     * @param jsonArrayStr
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> list = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return list;
    }


    /**
     * 獲取泛型的 Collection Type
     *
     * @param collectionClass 泛型的Collection
     * @param elementClasses  元素類
     * @return JavaType Java類型
     * @since 1.0
     */
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

    /**
     * 將 Map 轉換爲 JavaBean
     *
     * @param map
     * @param clazz
     * @return
     */
    public static <T> T map2pojo(Map map, Class<T> clazz) {
        return objectMapper.convertValue(map, clazz);
    }

    /**
     * 將 Map 轉換爲 JSON
     *
     * @param map
     * @return
     */
    public static String mapToJson(Map map) {
        try {
            return objectMapper.writeValueAsString(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 將 JSON 對象轉換爲 JavaBean
     *
     * @param obj
     * @param clazz
     * @return
     */
    public static <T> T obj2pojo(Object obj, Class<T> clazz) {
        return objectMapper.convertValue(obj, clazz);
    }
}

View Code