Jackson objectMapper.readValue 方法 詳解

直接說結論方便一目了然：

1. 簡單的直接Bean.class

2. 復雜的用 TypeReference 

這樣就完事了。

 

public class TestMain2 {
    public static void main(String[] args) throws JsonProcessingException {


        /*
          首先說明 readValue 針對String 一共有3個重載，如下：

          public <T> T readValue(String content, Class<T> valueType)；簡單型，就是 直接  UserBase.class 就可。

          public <T> T readValue(String content, TypeReference<T> valueTypeRef)；復雜的可以 用這個

          public <T> T readValue(String content, JavaType valueType)；這個書寫起來比較麻煩，就不說明了，不常用，前2個已經徹底滿足了。

         */

        ObjectMapper objectMapper = new ObjectMapper();
        String json1 = "{\"userName\":\"小李飛刀\",\"age\":18,\"addTime\":1591851786568}";
        String json2 = "[{\"userName\":\"小李飛刀\",\"age\":18,\"addTime\":123}, {\"userName\":\"小李飛刀2\",\"age\":182,\"addTime\":1234}]";


        //1.最簡單的常用方法，直接將一個json轉換成實體類
        UserBase userBase1 = objectMapper.readValue(json1, UserBase.class); //簡單類型的時候，這樣最方便
        System.out.println("簡單: " + userBase1.getUserName());
        //用 TypeReference 也可以，但是麻煩 不如第一種直接 TypeReference 主要針對繁雜類型
        //UserBase userBase2 = objectMapper.readValue(json1, new TypeReference<UserBase>() {});



        //2.把Json轉換成map，必須使用 TypeReference , map的類型定義 可以根據實際情況來定，比如若值都是String那么就可以 Map<String, String>
        Map<String, Object> userBaseMap =  objectMapper.readValue(json1, new TypeReference<Map<String, Object>>() {});
        System.out.println("map: " + userBaseMap.get("userName"));


        //3.list<Bean>模式，必須用 TypeReference
        List<UserBase> userBaseList = objectMapper.readValue(json2, new TypeReference<List<UserBase>>() {});
        System.out.println("list: " + userBaseList.get(0).getUserName());


        //4.Bean[] 數組，必須用 TypeReference
        UserBase[] userBaseAry = objectMapper.readValue(json2, new TypeReference<UserBase[]>() {});
        System.out.println("ary: " + userBaseAry[0].getUserName());
    }
}

 

 

 

 

 

==========================================================下面是詳細的秒數==================================================

方法1，針對簡單類型，有實體類的json，直接轉換成單個實體類，上代碼：

首先是一個實體類UserBase:

public class UserBase {

    /**
     * 用戶名
     */
    private String userName;


    /**
     * 年齡
     */
    private Integer age;


    /**
     * 增加時間
     */
    private Date addTime;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

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

    public Date getAddTime() {
        return addTime;
    }

    public void setAddTime(Date addTime) {
        this.addTime = addTime;
    }
}

 

 

 

public class TestMain2 {
    public static void main(String[] args) throws JsonProcessingException {

        /*
         1.最簡單的常用方法，直接將一個json轉換成實體類
         */
        ObjectMapper objectMapper = new ObjectMapper();
        String json = "{\"userName\":\"小李飛刀\",\"age\":18,\"addTime\":1591851786568}";

        //這里需要這么寫，
        UserBase userBase = objectMapper.readValue(json, UserBase.class); //簡單類型的時候，這樣最方便

        UserBase userBase1 = objectMapper.readValue(json, new TypeReference<UserBase>() {}); //這樣也可以，TypeReference主要針對復雜類型

        System.out.println(userBase.getUserName());
        System.out.println(userBase1.getUserName());
    }
}

 

 

 

 

 

2. 若是map呢， 應該怎么用會怎樣？？以下開始舉例：

 

public class TestMain3 {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        //注意這里鍵名和鍵值都是String類型的
        Map<String, String> map = new HashMap<>();
        map.put("name", "小李飛刀");
        map.put("sex", "男");

        //先生成一個json方便理解
        String json = objectMapper.writeValueAsString(map);
        System.out.println(json);//{"sex":"男","name":"小李飛刀"}

        /*
         開始反序列化
         */
        Map<String,String> map1 = new HashMap<>();
        //我之前是這么寫的直接 Map.class 總覺得不妥，感覺他用了默認的推斷，然后程序也能正常運行
        map1 = objectMapper.readValue(json, Map.class);
        System.out.println(map1.get("name"));


    }
}

 

 

 

 

 

 

 

 

 

 

我們調試一下代碼看下，

 

 

 

 

 

 

 

 

 

 

 

 

 

顯然這種方式，不好，1. 編譯時 會有 泛型警告。2. 不完美 雖然能用，但是不要這樣。那么 Map時 應該如何 反序列化呢，看如下代碼：

 

 

map1 = objectMapper.readValue(json, new TypeReference<Map<String, String>>() {}); //用這個

 

 

我們來調試看下，這次是否清晰說明了 map1的類型。

 

 

 

 

 

 

 

 

 

 

 

好了，干完了 map，接下來還有一個常用的List<Bean> ，我們調試看下：

 

public class TestMain4 {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        String json = "[{\"userName\":\"小李飛刀\",\"age\":18,\"addTime\":123}, {\"userName\":\"小李飛刀2\",\"age\":182,\"addTime\":1234}]";

        List<UserBase> userBaseList = objectMapper.readValue(json, List.class);

        System.out.println(userBaseList.get(0).getUserName());
    }
}

 

 

 

 先不調試了，需要這么寫：

List<UserBase> userBaseList = objectMapper.readValue(json, new TypeReference<List<UserBase>>() {});

 

 

 

 

上面是直接把Json, 轉換成 List<bean>，關於直接轉換成 Bean數組的問題即，直接把 json轉換成 bean[]，也是用 TypeReference 就可：看如下代碼：

 

public class TestMain4 {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        String json = "[{\"userName\":\"小李飛刀\",\"age\":18,\"addTime\":123}, {\"userName\":\"小李飛刀2\",\"age\":182,\"addTime\":1234}]";

        UserBase[] userBaseAry = objectMapper.readValue(json, new TypeReference<UserBase[]>() {});

        System.out.println(userBaseAry[0].getUserName());
    }
}

 

 

 

===================================================================================================

由於 objectMapper 一共有3個重載，我們已經講了 2個，還有一個 我們看下他的用法，這個不常用，以后盡量少用 會不用，寫代碼 沒有上面2種 來的直接和方便。

 

 

 

不浪費時間了，直接粘貼網上的文章：

來源：https://www.cnblogs.com/gaomanito/p/9591730.html

復制代碼
ObjectMapper mapper = new ObjectMapper();
　　// 排除json字符串中實體類沒有的字段
　　objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);



String json = "[{\"name\":\"a\",\"password\":\"345\"},{\"name\":\"b\",\"password\":\"123\"}]";
        
//第一種方法
List<User> list = mapper.readValue(json, new TypeReference<List<User>>(){/**/});
        
//第二種方法
JavaType javaType = mapper.getTypeFactory().constructCollectionType(List.class, User.class);
List<User> list2 = mapper.readValue(json, javaType);
復制代碼
 

Jackson，我感覺是在Java與Json之間相互轉換的最快速的框架，當然Google的Gson也很不錯，但是參照網上有人的性能測試，看起來還是Jackson比較快一點

    Jackson處理一般的JavaBean和Json之間的轉換只要使用ObjectMapper 對象的readValue和writeValueAsString兩個方法就能實現。但是如果要轉換復雜類型Collection如 List<YourBean>，那么就需要先反序列化復雜類型 為泛型的Collection Type。

如果是ArrayList<YourBean>那么使用ObjectMapper 的getTypeFactory().constructParametricType(collectionClass, elementClasses);

如果是HashMap<String,YourBean>那么 ObjectMapper 的getTypeFactory().constructParametricType(HashMap.class,String.class, YourBean.class);

復制代碼
public final ObjectMapper mapper = new ObjectMapper(); 
     
    public static void main(String[] args) throws Exception{  
        JavaType javaType = getCollectionType(ArrayList.class, YourBean.class); 
        List<YourBean> lst =  (List<YourBean>)mapper.readValue(jsonString, javaType); 
    }   
       /**   
        * 獲取泛型的Collection Type  
        * @param collectionClass 泛型的Collection   
        * @param elementClasses 元素類   
        * @return JavaType Java類型   
        * @since 1.0   
        */   
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {   
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);   
    }
復制代碼
 復雜類型轉換

復制代碼
ObjectMapper objectMapper = new ObjectMapper();
// 排除json字符串中實體類沒有的字段
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
PledgeCertificate pledgeCertificate;
Pledge pledge = new Pledge();
try {
      pledgeCertificate = objectMapper.readValue(requestBody, PledgeCertificate.class);
      pledge = objectMapper.readValue(requestBody, Pledge.class);
　　   Map<String, Object> map = objectMapper.readValue(requestBody, Map.class);
      String writeValueAsString = objectMapper.writeValueAsString(map.get("obligee"));
      JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, Obligee.class);
      List<Obligee> obligee = objectMapper.readValue(writeValueAsString,javaType);
}catch (IOException e) {
      return “轉換錯誤”;
}

數據格式：（實體類沒有obligee字段，先排除）
{
“certificate”:"豫(2016)鄭州市不動產權第0026369號",
“debtEnd”: "yyyy-mm-dd",
“debtStart”: "yyyy-mm-dd",
“pledgeType”: "2",
“maxDebtAmount”:88,
“registType”:"0201",
“obligee” :[{
"obligeeType":"1","name":張三","certType":"1","certNo":"4114211..."},{
"obligeeType":"1","name":"李四","certType":"1","certNo":"4114211..."}]
}
復制代碼
 

{

“certificate”:"豫(2016)鄭州市不動產權第0026369號",

“debtEnd”: "yyyy-mm-dd",

“debtStart”: "yyyy-mm-dd",

“pledgeType”: "2",

“maxDebtAmount”:88,

“registType”:"0201",

“obligee” :[{

"obligeeType":"1","name":張三","certType":"1","certNo":"4114211..."},{

"obligeeType":"1","name":"李四","certType":"1","certNo":"4114211..."}]

}

既然我已經踏上這條道路，那么，任何東西都不應妨礙我沿着這條路走下去！！！！！！！！！！ ！！！ ！ ！！ ！ 個人公眾號《后端技術開發之路》，歡迎您關注！

 

 

來源：https://www.cnblogs.com/surge/p/9046223.html

 

 

Jackson 處理復雜類型(List,map)兩種方法
 

方法一:

String jsonString="[{'id':'1'},{'id':'2'}]";  
ObjectMapper mapper = new ObjectMapper();  
JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, Bean.class);  
//如果是Map類型  mapper.getTypeFactory().constructParametricType(HashMap.class,String.class, Bean.class);  
List<Bean> lst =  (List<Bean>)mapper.readValue(jsonString, javaType);   
 

方法二:

String jsonString="[{'id':'1'},{'id':'2'}]";  
ObjectMapper mapper = new ObjectMapper();  
List<Bean> beanList = mapper.readValue(jsonString, new TypeReference<List<Bean>>() {});