जैक्सन का उपयोग करने के लिए वस्तुओं की एक सरणी deserialise कैसे करें

Question

जैक्सन डेटा बाइंडिंग प्रलेखन इंगित करता है कि जैक्सन का समर्थन करता है "सभी समर्थित प्रकारों के एरे" deserialising लेकिन मैं इस बात के लिए सटीक सिंटैक्स को समझ नहीं सकता।

एक वस्तु के लिए मैं यह करूँगा:

//json input
{
    "id" : "junk",
    "stuff" : "things"
}

//Java
MyClass instance = objectMapper.readValue(json, MyClass.class);

अब एक सरणी के लिए मैं यह करना चाहता हूं:

//json input
[{
    "id" : "junk",
    "stuff" : "things"
},
{
    "id" : "spam",
    "stuff" : "eggs"
}]

//Java
List<MyClass> entries = ?

किसी को पता है कि क्या कोई जादू लापता कमांड है? अगर नहीं तो फिर उपाय क्या है?

Comments

मैं JSON से निपटने के लिए Google की GSON लाइब्रेरी पसंद करता हूं। यह जांचने योग्य है कि क्या आपने अभी तक इसकी कोशिश नहीं की है ... इसके साथ काम करना बहुत आसान और सहज है।

— जेसी वेब वेब

एफडब्ल्यूआईडब्ल्यू जीसन के साथ इस विशिष्ट समस्या का संभावित समाधान जैक्सन के डेटा बाइंडिंग एपीआई के साथ लगभग संभव है।

— प्रोग्रामर ब्रूस

Gweebz - शायद आप यह बताना चाहेंगे कि आपको लगता है कि GSON एक बेहतर विकल्प है (जैक्सन की तुलना में)?

— स्टेक्समैन

Answer 1

पहले एक मैपर बनाएं:

import com.fasterxml.jackson.databind.ObjectMapper;// in play 2.3
ObjectMapper mapper = new ObjectMapper();

ऐरे के रूप में:

MyClass[] myObjects = mapper.readValue(json, MyClass[].class);

सूची के रूप में:

List<MyClass> myObjects = mapper.readValue(jsonInput, new TypeReference<List<MyClass>>(){});

सूची प्रकार निर्दिष्ट करने का दूसरा तरीका:

List<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));

Comments

एक अतिरिक्त ध्यान दें, अगर आपको पार्स करते समय कोई त्रुटि मिलती है जैसे कि JsonMappingException: No suitable constructor found for typeतब इसका मतलब है कि आपको अपनी कक्षा में एक डिफॉल्ट कंस्ट्रक्टर को जोड़ने की आवश्यकता है, एक निजी नो-आर्ग कंस्ट्रक्टर को जोड़कर इसे मेरे लिए निर्धारित किया गया है।

— SyntaxRules 16

यदि आपके पास स्पष्ट कंस्ट्रक्टर है - तो @SyntaxRules स्पष्ट कंस्ट्रक्टर को जोड़ना आवश्यक है - यदि नहीं, तो कंपाइलर स्वचालित रूप से सार्वजनिक "खाली" कंस्ट्रक्टर बनाता है। अच्छी बात। एक और आम समस्या यह है कि आंतरिक वर्गों को होना चाहिए static- अन्यथा उनके पास कभी भी शून्य-अर्ग कंस्ट्रक्टर नहीं है।

— स्टेक्समैन

Btw, List<MyClass> myObjects = Arrays.asList(mapper.readValue(json, MyClass[].class))TypeRefence की तुलना में 10 गुना तेज काम करता है।

मैं एक सामान्य प्रकार के संस्करण की तलाश में हूं।

— स्टीफन

@EugeneTskhovrebov आपका रास्ता इनलाइनिंग के लिए सबसे साफ है। दूसरों को कास्टिंग या घोषणा की आवश्यकता होती है। मैं इसे उजागर करने में मदद करने के लिए अपने स्वयं के उत्तर के रूप में जोड़ने का सुझाव देता हूं, और आपको कुछ प्रतिनिधि देता हूं।

— एरिक बी

Answer 2

से यूजीन Tskhovrebov

List<MyClass> myObjects = Arrays.asList(mapper.readValue(json, MyClass[].class))

यह समाधान मेरे लिए सबसे अच्छा लगता है

Comments

जावा, लोटस डोमिनोज़ में एजेंटों के साथ काम करने वालों के लिए, यह जाने का रास्ता है। मैंने कुछ अन्य समाधानों की कोशिश की, लेकिन हमेशा ResourceNotFoundException

— जॉन

उपर्युक्त उत्तर के लिए टिप्पणियों में इसके अलावा सिंटेक्सRules को इस समाधान की आवश्यकता हो सकती है जैसा कि हम, यह मेरे लिए था। मैं बस इसे जोड़ना चाहता था ताकि यह खो न जाए।

— रोब

याArrays.asList(Json.fromJson(json.get("fieldName"), MyClass[].class))

— अल-मोताफर

याList<MyClass> myObjects = Arrays.asList(mapper.treeToValue(jsonNode.get("fieldName"), MyClass[].class))

— कोलिन क्रॉल

@CollinKrawll क्या करता है objectmapper.treetovalue?

— इस्वर

Answer 3

सामान्य कार्यान्वयन के लिए:

public static <T> List<T> parseJsonArray(String json,
                                         Class<T> classOnWhichArrayIsDefined) 
                                         throws IOException, ClassNotFoundException {
   ObjectMapper mapper = new ObjectMapper();
   Class<T[]> arrayClass = (Class<T[]>) Class.forName("[L" + classOnWhichArrayIsDefined.getName() + ";");
   T[] objects = mapper.readValue(json, arrayClass);
   return Arrays.asList(objects);
}

Comments

कक्षा <टी []> का अच्छा निर्माण। यह कभी नहीं देखा। आपको इस बारे में जानकारी कहां से मिली?

— रोलैंड वान हेडडेम

Answer 4

सबसे पहले ObjectReader का एक उदाहरण बनाएं जो थ्रेड-सुरक्षित है।

ObjectMapper objectMapper = new ObjectMapper();
ObjectReader objectReader = objectMapper.reader().forType(new TypeReference<List<MyClass>>(){});

फिर इसका उपयोग करें:

List<MyClass> result = objectReader.readValue(inputStream);

Comments

यह वही है जो मैं देख रहा हूँ, धन्यवाद

— अकेला

हम प्राप्त करते हैं - com.fasterxml.jackson.databind.JsonMappingException: java.util का उदाहरण नहीं दे सकते। पंक्ति: 1, कॉलम: 1]

— दिनेश कुमार

Answer 5

try {
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory f = new JsonFactory();
    List<User> lstUser = null;
    JsonParser jp = f.createJsonParser(new File("C:\\maven\\user.json"));
    TypeReference<List<User>> tRef = new TypeReference<List<User>>() {};
    lstUser = mapper.readValue(jp, tRef);
    for (User user : lstUser) {
        System.out.println(user.toString());
    }

} catch (JsonGenerationException e) {
    e.printStackTrace();
} catch (JsonMappingException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

Answer 6

यहाँ एक उपयोगिता है जो json2object या Object2json को बदलने के लिए है, जो भी आपकी पूजो (इकाई T) है

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

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

/**
 * 
 * @author TIAGO.MEDICI
 * 
 */
public class JsonUtils {

    public static boolean isJSONValid(String jsonInString) {
        try {
            final ObjectMapper mapper = new ObjectMapper();
            mapper.readTree(jsonInString);
            return true;
        } catch (IOException e) {
            return false;
        }
    }

    public static String serializeAsJsonString(Object object) throws JsonGenerationException, JsonMappingException, IOException {
        ObjectMapper objMapper = new ObjectMapper();
        objMapper.enable(SerializationFeature.INDENT_OUTPUT);
        objMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        StringWriter sw = new StringWriter();
        objMapper.writeValue(sw, object);
        return sw.toString();
    }

    public static String serializeAsJsonString(Object object, boolean indent) throws JsonGenerationException, JsonMappingException, IOException {
        ObjectMapper objMapper = new ObjectMapper();
        if (indent == true) {
            objMapper.enable(SerializationFeature.INDENT_OUTPUT);
            objMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        }

        StringWriter stringWriter = new StringWriter();
        objMapper.writeValue(stringWriter, object);
        return stringWriter.toString();
    }

    public static <T> T jsonStringToObject(String content, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
        T obj = null;
        ObjectMapper objMapper = new ObjectMapper();
        obj = objMapper.readValue(content, clazz);
        return obj;
    }

    @SuppressWarnings("rawtypes")
    public static <T> T jsonStringToObjectArray(String content) throws JsonParseException, JsonMappingException, IOException {
        T obj = null;
        ObjectMapper mapper = new ObjectMapper();
        obj = mapper.readValue(content, new TypeReference<List>() {
        });
        return obj;
    }

    public static <T> T jsonStringToObjectArray(String content, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
        T obj = null;
        ObjectMapper mapper = new ObjectMapper();
        mapper = new ObjectMapper().configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        obj = mapper.readValue(content, mapper.getTypeFactory().constructCollectionType(List.class, clazz));
        return obj;
    }

Answer 7

आप एक वर्ग भी बना सकते हैं जो विस्तारित हो ArrayList:

public static class MyList extends ArrayList<Myclass> {}

और फिर इसका उपयोग करें जैसे:

List<MyClass> list = objectMapper.readValue(json, MyList.class);