Jackson: Konwersja własność JSON do obiektu zagnieżdżonego z Dot Notation

Question

Mam JSON jak ten

{ "id":1, "name":"Jack", "parent.id":2 } 

Uwaga kropkę na "parent.id" własności

Czy można mapować te JSON do następujących klas?

class Child { 
    private int id; 
    private String name; 

    private Parent parent; 

    //getter and setter methods 
} 

class Parent { 
    private int id; 
    private String name; 

    //getter and setter methods 
} 

więc wynik mapowanie byłby podobny do następujących stwierdzeń:

Parent parent = new Parent(); 
parent.setId(2); 

Child child = new Child(); 
child.setId(1); 
child.setName("Jack"); 
child.setParent(parent); // Here is the result 

Answer 1

można przekonwertować ten

{ "id":1, "name":"Jack", "parent.id":2 } 

w tym

{ "id":1, "name":"Jack", "parent": { "id":2 } } 

za pomocą tego

// I'm using jQuery here 
$.fn.serializeObject = function() { 
    var arrayData, objectData; 
    arrayData = this.serializeArray(); 
    objectData = {}; 

    $.each(arrayData, function() { 
    var value; 

    if (this.value != null) { 
     value = this.value; 
    } else { 
     value = ''; 
    } 

    // search for "parent.id" like attribute 
    if (this.name.indexOf('.') != -1) { 
     var attrs = this.name.split('.'); 
     var tx = objectData; 

     for (var i = 0; i < attrs.length - 1; i++) { 
     if (objectData[attrs[i]] == undefined) 
      objectData[attrs[i]] = {}; 
     tx = objectData[attrs[i]]; 
     } 
     tx[attrs[attrs.length - 1]] = value; 
    } else { 
     if (objectData[this.name] != null) { 
     if (!objectData[this.name].push) { 
      objectData[this.name] = [objectData[this.name]]; 
     } 

     objectData[this.name].push(value); 
     } else { 
     objectData[this.name] = value; 
     } 
    } 
    }); 

    return objectData; 
}; 

, a następnie można przekształcić kod do postaci szeregowej za pomocą JSON.serialize().

jeśli używasz Jackson, wtedy można deserializowania żądania ciąg JSON, wykonując jedną z nich:

1. Tworzenie niestandardowego Jackson deserializowania moduł

2. analizowania JSON samodzielnie

public Child parseJackson(String jsonRequest) { 
    // what we need 
    ObjectMapper mapper; 
    JsonNode root, parentNode; 

    // your models 
    Child child; 
    Parent parent; 

    // assign 
    mapper = new ObjectMapper(); 
    root = mapper.readTree(jsonRequest); // deserialize JSON as tree 
    parentNode = root.get("parent"); // get the "parent" branch 

    // assign (again) 
    child = mapper.readValue(root, Child.class); 
    parent = mapper.readValue(parentNode, Parent.class); 

    child.setParent(parent); 

    return child; 
} 

Wadą tej metody jest to trzeba analizować dla każdego JsonRequest z obiektów zagnieżdżonych i będzie bałagan kiedy th ere jest złożoną strukturą zagnieżdżoną. Jeśli jest to problem, proponuję zrobić # 3

3. utworzyć niestandardową klasę Jackson ObjectMapper aby zautomatyzować ten proces

Chodzi o to, aby zbudować ogólny proces za nr 2, tak aby mogła ona obsługiwać dowolne zagnieżdżone żądanie.

public class CustomObjectMapper extends ObjectMapper { 

    // here's the method you need 
    @Override 
    public <T> T readValue(String src, Class<T> type) 
     throws IOException, JsonParseException, JsonMappingException { 

    JsonNode root = this.readTree(src); 
    try { 
     return readNestedValue(root, type); 
    } catch (InstantiationException | IllegalAccessException | IOException 
     | IllegalArgumentException | InvocationTargetException e) { 
     return super.readValue(src, type); 
    } 

    } 

    // if you're using Spring, I suggest you implement this method as well 
    // since Spring's MappingJacksonHttpMessageConverter class will call 
    // this method. 
    @Override 
    public <T> T readValue(InputStream src, JavaType type) 
     throws IOException, JsonParseException, JsonMappingException { 

    JsonNode root = this.readTree(src); 
    try { 
     return readNestedValue(root, (Class<T>) type.getRawClass()); 
    } catch (InstantiationException | IllegalAccessException | IOException 
     | IllegalArgumentException | InvocationTargetException e) { 
     return super.readValue(src, type); 
    } 

    } 

    // we need this to recursively scan the tree node 
    protected <T> T readNestedValue(JsonNode root, Class<T> type) 
     throws InstantiationException, IllegalAccessException, IOException, 
     IllegalArgumentException, InvocationTargetException { 

    // initialize the object use ObjectMapper's readValue 
    T obj = super.readValue(root, type); 
    Iterator it = root.getFieldNames(); 
    while (it.hasNext()) { 
     String name = (String) it.next(); 
     String camelCaseName = name.substring(0, 1).toUpperCase() + name.substring(1); 
     JsonNode node = root.get(name); 

     Field f; 
     try { 
     f = type.getDeclaredField(name); 
     } catch (NoSuchFieldException e) { 
     f = findFieldInSuperClass(name, type.getSuperclass()); 
     } 
     // if no field found then ignore 
     if (f == null) continue; 

     Method getter, setter; 
     try { 
     getter = type.getMethod("get" + camelCaseName); 
     } catch (NoSuchMethodException e) { 
     getter = findGetterInSuperClass("get" + camelCaseName, type.getSuperclass()); 
     } 
     // if no getter found or it has been assigned then ignore 
     if (getter == null || getter.invoke(obj) != null) continue; 

     try { 
     setter = type.getMethod("set" + camelCaseName); 
     } catch (NoSuchMethodException ex) { 
     setter = findSetterInSuperClass("set" + camelCaseName, type.getSuperclass(), f.getType()); 
     } 
     // if no setter found then ignore 
     if (setter == null) continue; 

     setter.invoke(obj, readNestedValue(node, f.getType())); 
    } 

    return obj; 
    } 

    // we need this to search for field in super class 
    // since type.getDeclaredField() will only return fields that in the class 
    // but not super class 
    protected Field findFieldInSuperClass(String name, Class sClass) { 
    if (sClass == null) return null; 
    try { 
     Field f = sClass.getDeclaredField(name); 
     return f; 
    } catch (NoSuchFieldException e) { 
     return findFieldInSuperClass(name, sClass.getSuperclass()); 
    } 
    } 

    protected Method findGetterInSuperClass(String name, Class sClass) { 
    if (sClass == null) return null; 
    try { 
     Method m = sClass.getMethod(name); 
     return m; 
    } catch (NoSuchMethodException e) { 
     return findGetterInSuperClass(name, sClass.getSuperclass()); 
    } 
    } 

    protected Method findSetterInSuperClass(String name, Class sClass, Class type) { 
    if (sClass == null) return null; 
    try { 
     Method m = sClass.getMethod(name, type); 
     return m; 
    } catch (NoSuchMethodException e) { 
     return findSetterInSuperClass(name, sClass.getSuperclass(), type); 
    } 
    } 
} 

Jeśli używasz Spring, to ostatnim krokiem jest zarejestrowanie tej klasy jako Spring bean.

<mvc:annotation-driven> 
    <mvc:message-converters> 
     <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"> 
     <property name="objectMapper"> 
      <bean class="x.y.z.CustomObjectMapper"/> 
     </property> 
     </bean> 
    </mvc:message-converters> 
    </mvc:annotation-driven> 

z nich skonfigurować można łatwo korzystać

@RequestMapping("/saveChild.json") 
@ResponseBody 
public Child saveChild(@RequestBody Child child) { 
    // do something with child 
    return child; 
} 

nadzieję, że to pomaga :)