Jak przekonwertować jsonString na JSONObject w Javie

Mam zmienną String o nazwie jsonString:

{"phonetype":"N95","cat":"WP"}

Teraz chcę przekonwertować go na obiekt JSON. Szukałem więcej w Google, ale nie otrzymałem żadnych oczekiwanych odpowiedzi ...

Korzystanie z biblioteki org.json :

try {
     JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
}catch (JSONException err){
     Log.d("Error", err.toString());
}

Do każdego, kto wciąż szuka odpowiedzi:

JSONParser parser = new JSONParser();
JSONObject json = (JSONObject) parser.parse(stringToParse);

Możesz użyć google-gson. Detale:

Przykłady obiektów

class BagOfPrimitives {
  private int value1 = 1;
  private String value2 = "abc";
  private transient int value3 = 3;
  BagOfPrimitives() {
    // no-args constructor
  }
}

(Serializacja)

BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj); 
==> json is {"value1":1,"value2":"abc"}

Pamiętaj, że nie można serializować obiektów z referencjami kołowymi, ponieważ spowoduje to nieskończoną rekurencję.

(Deserializacja)

BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);  
==> obj2 is just like obj

Kolejny przykład Gsona:

Gson jest łatwy do nauczenia i wdrożenia, musisz wiedzieć, że są dwie następujące metody:

-> toJson () - konwertuje obiekt Java do formatu JSON

-> fromJson () - konwertuje JSON na obiekt Java

import com.google.gson.Gson;

public class TestObjectToJson {
  private int data1 = 100;
  private String data2 = "hello";

  public static void main(String[] args) {
      TestObjectToJson obj = new TestObjectToJson();
      Gson gson = new Gson();

      //convert java object to JSON format
      String json = gson.toJson(obj);

      System.out.println(json);
  }

}

Wynik

{"data1":100,"data2":"hello"}

Zasoby:

Strona główna projektu Google Gson

Podręcznik użytkownika Gson

Przykład

Istnieje wiele serializatorów i deserializatorów Java JSON powiązanych ze stroną główną JSON .

W chwili pisania tego tekstu są 22:

• JSON-java .
• JSONUtil .
• jsonp .
• Json-lib .
• Stringtree .
• SOJO .
• json-taglib .
• Flexjson .
• Argo .
• jsonij .
• fastjson .
• mjson .
• JJSON .
• json-simple .
• json-io .
• google-gson .
• FOSS Nova JSON .
• KONWERTER KUKURYDZY .
• Apache Johnzon .
• Genson .
• cookjson .
• progbase .

... ale oczywiście lista może się zmienić.

Rozwiązanie Java 7

import javax.json.*;

...

String TEXT;
JsonObject body = Json.createReader(new StringReader(TEXT)).readObject()

;

Aby przekonwertować Stringna JSONObjectCiebie, wystarczy przekazać Stringinstancję do Konstruktora JSONObject.

Na przykład:

JSONObject jsonObj = new JSONObject("your string");

Lubię do tego używać google-gson i to właśnie dlatego, że nie muszę bezpośrednio współpracować z JSONObject.

W takim przypadku miałbym klasę, która będzie odpowiadać właściwościom Twojego obiektu JSON

class Phone {
 public String phonetype;
 public String cat;
}


...
String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";
Gson gson = new Gson();
Phone fooFromJson = gson.fromJson(jsonString, Phone.class);
...

Myślę jednak, że twoje pytanie jest bardziej jak: Jak skończyć z rzeczywistym obiektem JSONObject z ciągu JSON.

Patrzyłem na interfejs google-json i nie mogłem znaleźć niczego tak prostego jak interfejs org.json, który prawdopodobnie jest tym, czego chcesz używać, jeśli bardzo potrzebujesz JSONObject.

http://www.json.org/javadoc/org/json/JSONObject.html

Z org.json.JSONObject (inny całkowicie inny API) Jeśli chcesz zrobić coś takiego jak ...

JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
System.out.println(jsonObject.getString("phonetype"));

Myślę, że piękno Google-gson polega na tym, że nie musisz zajmować się JSONObject. Po prostu łapiesz Jsona, przekazujesz klasę, do której chcesz dokonać deserializacji, a twoje atrybuty klasy zostaną dopasowane do JSON, ale z drugiej strony każdy ma swoje własne wymagania, być może nie możesz sobie pozwolić na luksus, na który mają wstępnie zmapowane klasy strona deserializująca, ponieważ po stronie generującej JSON może być zbyt dynamicznie. W takim przypadku wystarczy użyć json.org.

musisz zaimportować org.json

JSONObject jsonObj = null;
        try {
            jsonObj = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
        } catch (JSONException e) {
            e.printStackTrace();
        }

Ciąg do JSON za Jacksonpomocą com.fasterxml.jackson.databind:

Zakładając, że twój ciąg json reprezentuje to: jsonString = {"phonetype": "N95", "cat": "WP"}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
 * Simple code exmpl
 */
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(jsonString);
String phoneType = node.get("phonetype").asText();
String cat = node.get("cat").asText();

Jeśli używasz http://json-lib.sourceforge.net (net.sf.json.JSONObject)

to jest dość łatwe:

String myJsonString;
JSONObject json = JSONObject.fromObject(myJsonString);

lub

JSONObject json = JSONSerializer.toJSON(myJsonString);

uzyskaj wartości następnie z json.getString (param), json.getInt (param) i tak dalej.

Aby przekonwertować ciąg na json, a żądło jest jak json. {„typ telefonu”: „N95”, „kot”: „WP”}

String Data=response.getEntity().getText().toString(); // reading the string value 
JSONObject json = (JSONObject) new JSONParser().parse(Data);
String x=(String) json.get("phonetype");
System.out.println("Check Data"+x);
String y=(String) json.get("cat");
System.out.println("Check Data"+y);

Użyj JsonNode z szybciejxml do ogólnego analizowania Json. Wewnętrznie tworzy mapę kluczowej wartości dla wszystkich danych wejściowych.

Przykład:

private void test(@RequestBody JsonNode node)

Ciąg wejściowy:

{"a":"b","c":"d"}

Nie trzeba używać żadnej zewnętrznej biblioteki.

Zamiast tego możesz użyć tej klasy :) (obsługuje nawet listy, listy zagnieżdżone i json)

public class Utility {

    public static Map<String, Object> jsonToMap(Object json) throws JSONException {

        if(json instanceof JSONObject)
            return _jsonToMap_((JSONObject)json) ;

        else if (json instanceof String)
        {
            JSONObject jsonObject = new JSONObject((String)json) ;
            return _jsonToMap_(jsonObject) ;
        }
        return null ;
    }


   private static Map<String, Object> _jsonToMap_(JSONObject json) throws JSONException {
        Map<String, Object> retMap = new HashMap<String, Object>();

        if(json != JSONObject.NULL) {
            retMap = toMap(json);
        }
        return retMap;
    }


    private static Map<String, Object> toMap(JSONObject object) throws JSONException {
        Map<String, Object> map = new HashMap<String, Object>();

        Iterator<String> keysItr = object.keys();
        while(keysItr.hasNext()) {
            String key = keysItr.next();
            Object value = object.get(key);

            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            map.put(key, value);
        }
        return map;
    }


    public static List<Object> toList(JSONArray array) throws JSONException {
        List<Object> list = new ArrayList<Object>();
        for(int i = 0; i < array.length(); i++) {
            Object value = array.get(i);
            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            list.add(value);
        }
        return list;
    }
}

Aby przekonwertować ciąg JSON na skrót, użyj tego:

HashMap<String, Object> hashMap = new HashMap<>(Utility.jsonToMap(

Codehaus Jackson - Jestem niesamowitym API od 2012 roku dla moich usług RESTful i testów JUnit. Dzięki ich interfejsowi API możesz:

(1) Konwertuj ciąg JSON na bean Java

public static String beanToJSONString(Object myJavaBean) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.writeValueAsString(myJavaBean);
}

(2) Konwertuj ciąg JSON na obiekt JSON (JsonNode)

public static JsonNode stringToJSONObject(String jsonString) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.readTree(jsonString);
}

//Example:
String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";   
JsonNode jsonNode = stringToJSONObject(jsonString);
Assert.assertEquals("Phonetype value not legit!", "N95", jsonNode.get("phonetype").getTextValue());
Assert.assertEquals("Cat value is tragic!", "WP", jsonNode.get("cat").getTextValue());

(3) Konwertuj komponent bean Java na JSON String

    public static Object JSONStringToBean(Class myBeanClass, String JSONString) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.readValue(JSONString, beanClass);
}

REFS:

1. Codehaus Jackson

2. JsonNode API - jak używać, nawigować, analizować i oceniać wartości z obiektu JsonNode

3. Tutorial - Prosty tutorial, jak używać Jacksona do konwersji ciągu JSON na JsonNode

UWAGA: GSON z deserializacją interfejsu spowoduje wyjątek taki jak poniżej.

"java.lang.RuntimeException: Unable to invoke no-args constructor for interface XXX. Register an InstanceCreator with Gson for this type may fix this problem."

Podczas deserializacji; GSON nie wie, który obiekt musi być intantowany dla tego interfejsu.

Jest to rozwiązane jakoś tutaj .

Jednak FlexJSON ma to rozwiązanie z natury. podczas szeregowania czasu dodaje nazwę klasy jako część json jak poniżej.

{
    "HTTPStatus": "OK",
    "class": "com.XXX.YYY.HTTPViewResponse",
    "code": null,
    "outputContext": {
        "class": "com.XXX.YYY.ZZZ.OutputSuccessContext",
        "eligible": true
    }
}

Tak więc JSON będzie trochę oblewał; ale nie potrzebujesz pisać, InstanceCreatorco jest wymagane w GSON.

Korzystanie z org.json

Jeśli masz ciąg znaków zawierający tekst w formacie JSON, możesz uzyskać obiekt JSON, wykonując następujące czynności:

String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";
JSONObject jsonObj = null;
    try {
        jsonObj = new JSONObject(jsonString);
    } catch (JSONException e) {
        e.printStackTrace();
    }

Teraz, aby uzyskać dostęp do rodzaju telefonu

Sysout.out.println(jsonObject.getString("phonetype"));

Do ustawiania pojedynczego obiektu Json na listę tj

"locations":{

}

w List<Location>

posługiwać się

ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

jackson.mapper-asl-1.9.7.jar

Konwertowanie ciągu znaków na obiekt Json za pomocą org.json.simple.JSONObject

private static JSONObject createJSONObject(String jsonString){
    JSONObject  jsonObject=new JSONObject();
    JSONParser jsonParser=new  JSONParser();
    if ((jsonString != null) && !(jsonString.isEmpty())) {
        try {
            jsonObject=(JSONObject) jsonParser.parse(jsonString);
        } catch (org.json.simple.parser.ParseException e) {
            e.printStackTrace();
        }
    }
    return jsonObject;
}

Lepiej idź w prostszy sposób, używając org.jsonlib. Po prostu zastosuj bardzo proste podejście, jak poniżej:

JSONObject obj = new JSONObject();
obj.put("phonetype", "N95");
obj.put("cat", "WP");

Teraz objjest konwertowana JSONObjectforma odpowiedniego ciągu. Dzieje się tak w przypadku, gdy masz pary nazwa-wartość.

W przypadku ciągu możesz bezpośrednio przekazać konstruktor JSONObject. Jeśli to będzie poprawne json String, to dobrze, w przeciwnym razie spowoduje wyjątek.