जैक्सन json मैप करने के लिए और CamelCase कुंजी नाम

Question

मैं CamelCase कुंजी ... कहते युक्त एक नक्शा करने के लिए जैक्सन पुस्तकालय के माध्यम से json कनवर्ट करना चाहते हैं ...

से

{ 
    "SomeKey": "SomeValue", 
    "AnotherKey": "another value", 
    "InnerJson" : {"TheKey" : "TheValue"} 
} 

यह करने के लिए। ..

{ 
    "someKey": "SomeValue", 
    "anotherKey": "another value", 
    "innerJson" : {"theKey" : "TheValue"} 
} 

मेरे कोड ...

public Map<String, Object> jsonToMap(String jsonString) throws IOException 
{ 
    ObjectMapper mapper=new ObjectMapper(); 
    mapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES); 
    return mapper.readValue(jsonString,new TypeReference<Map<String, Object>>(){}); 
} 

लेकिन यह काम नहीं करता है ... यहां तक ​​कि अन्य propertyNamingStrategy जैसे json पर काम नहीं करता ... ...

{ 
    "someKey": "SomeValue" 
} 

mapper.setPropertyNamingStrategy(new PropertyNamingStrategy.PascalCaseStrategy()) 

प्राप्त करने के लिए कैसे

को

{ 
    "SomeKey": "SomeValue" 
} 

camelCase जैकसन के माध्यम से मानचित्र कुंजी नाम ... या क्या मुझे मैन्युअल रूप से लूप नक्शा और कुंजी कन्वर्ट करना चाहिए या कुछ और तरीका है ???

अग्रिम धन्यवाद ...

Answer 1

आप के बजाय POJOs के लिए JSON डेटा (स्पष्ट जावा क्लासों जो JSON डेटा से मेल खाते हैं) से आबद्ध/नक्शे शब्दकोशों काम कर रहे हैं के रूप में, संपत्ति नामकरण रणनीति लागू नहीं होता है:

कक्षा PropertyNamingStrategy ... को परिभाषित करता है कि कैसे JSON गुण ("बाहरी नाम") के नाम POJO तरीकों और क्षेत्रों ("आंतरिक नाम")

०१२३५१६४१० के नाम से निकले हैं

इसलिए, आपको पहले जैक्सन का उपयोग करके डेटा का विश्लेषण करना होगा और फिर परिणाम पर फिर से चालू करना होगा और चाबियाँ बदलना होगा।

इस तरह अपने कोड में परिवर्तित करें:

public Map<String, Object> jsonToMap(String jsonString) throws IOException 
{ 
    ObjectMapper mapper=new ObjectMapper(); 
    mapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES); 
    Map<String, Object> map = mapper.readValue(jsonString,new TypeReference<Map<String, Object>>(){}); 
    return convertMap(map); 
} 

और इन विधियों को जोड़ने:

public String mapKey(String key) { 
    return Character.toLowerCase(key.charAt(0)) + key.substring(1); 
} 

public Map<String, Object> convertMap(Map<String, Object> map) { 
    Map<String, Object> result = new HashMap<String, Object>(); 
    for (Map.Entry<String, Object> entry : map.entrySet()) { 
     String key = entry.getKey(); 
     Object value = entry.getValue(); 
     result.put(mapKey(key), convertValue(value)); 
    } 
    return result; 
} 

public convertList(Lst<Object> list) { 
    List<Object> result = new ArrayList<Object>(); 
    for (Object obj : list) { 
     result.add(convertValue(obj)); 
    } 
    return result; 
} 

public Object covertValue(Object obj) { 
    if (obj instanceof Map<String, Object>) { 
     return convertMap((Map<String, Object>) obj); 
    } else if (obj instanceof List<Object>) { 
     return convertList((List<Object>) obj); 
    } else { 
     return obj; 
    } 
} 

Answer 2

आप कभी भी मानचित्र की चाबियाँ पर पुनरावृति और उन्हें अपडेट कर सकते हैं। हालांकि, अगर आप केवल ऊंट केस कुंजी के साथ JSON बनाने में रूचि रखते हैं, तो आप नीचे वर्णित दृष्टिकोण पर विचार कर सकते हैं।

आपके पास एक कस्टम कुंजी धारावाहिक हो सकता है। यह जब JSON करने के लिए एक Map उदाहरण serializing उपयोग किया जाएगा:

String json = "{\"SomeKey\":\"SomeValue\",\"AnotherKey\":\"another value\",\"InnerJson\":" 
      + "{\"TheKey\":\"TheValue\"}}"; 

SimpleModule simpleModule = new SimpleModule(); 
simpleModule.addKeySerializer(String.class, new CamelCaseKeySerializer()); 

ObjectMapper mapper = new ObjectMapper(); 
mapper.registerModule(simpleModule); 

Map<String, Object> map = mapper.readValue(json, 
              new TypeReference<Map<String, Object>>() {}); 

String camelCaseJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map); 

उत्पादन होगा::

{ 
    "someKey" : "SomeValue", 
    "anotherKey" : "another value", 
    "innerJson" : { 
    "theKey" : "TheValue" 
    } 
} 

इस दृष्टिकोण के साथ

, की चाबी

public class CamelCaseKeySerializer extends JsonSerializer<String> { 

    @Override 
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) 
       throws IOException, JsonProcessingException { 

     String key = Character.toLowerCase(value.charAt(0)) + value.substring(1); 
     gen.writeFieldName(key); 
    } 
} 

तो निम्नलिखित के रूप में करते हैं Map ऊंट मामले में नहीं होगा। लेकिन यह आपको वांछित आउटपुट देगा।