Überprüfen Sie, ob ein Schlüssel in einem geschachtelten JSON vorhanden ist

Question

Ich bin in einer Situation stecken, in der ich überprüfen muss, ob ein Schlüssel in einem verschachtelten JSON-Objekt vorhanden ist. Durch verschachteltes JSON-Objekt, das ein JSON-Objekt im übergeordneten JSON-Objekt als Wert eines seiner Schlüssel enthält. Also muss ich prüfen, ob dieser Schlüssel im gesamten JSON-Objekt existiert. Ich bekomme die folgenden Daten als String Objekt. Ich weiß, dass ich dieses Objekt String analysieren kann, um JSON-Objekt zu erhalten.

{ 
"claim_loss_type_cd": "TEL", 
"claim_type": "002", 
"claim_reason": "001", 
"policy_number": "1234kk3366ff664", 
"info": { 
    "ApplicationContext": { 
     "country": "US" 
    } 
    } 
} 

ich verwendet habe containsKey() Methode den Schlüssel Existenz im Haupt JSON-Objekt zu überprüfen, und es funktioniert. Aber zum Überprüfen eines internen JSON-Objekts wie "info" muss ich das Object erneut zum JSON-Objekt analysieren und dann den Schlüssel erneut prüfen.

 String jsonString = "My JSON String here"; 
     JSONObject finalResponse = new JSONObject(jsonString); 
     finalResponse.containsKey("country"); // will return false 
     JSONObject intermediateResponse = (JSONObject)finalResponse.get("info"); 
     intermediateResponse.containsKey("country"); // will return true 

So ist es eine bessere Möglichkeit, jede API oder eine Methode, die das interne JSON-Objekt zu parsen, ohne die Notwendigkeit als auch innerhalb jeden internen JSON-Objekts überprüfen kann. Ich benutze com.ibm.json.java.JSONObject.JSONObject() native IBM Bibliothek für Websphere Application Server und keine zusätzlichen JSON Parser ich benutze.

In Anbetracht des obigen JSON ist "Claim_type" ein Schlüssel im übergeordneten JSON-Objekt, aber "info" an sich ein JSON-Objekt. Also, was ich tun muss, ist zu überprüfen, ob ein Schlüssel in vollständigen JSON, entweder in Eltern oder einem seiner Kind JSON-Objekt wie Schlüssel "Land" hier im Beispiel existiert.

EDIT:

Dank @chsdk kam ich zu einer Lösung. Aber wenn jemand mit einer anderen API zu einer Lösung kommt, antworten Sie bitte, da die Lösung unter Berücksichtigung der Rekursion & eine große Raum/Zeit-Komplexität haben kann.

public static boolean checkKey(JSONObject object, String searchedKey) { 
    boolean exists = object.containsKey(searchedKey); 
    if(!exists) {  
     Set<String> keys = object.keySet(); 
     for(String key : keys){ 
      if (object.get(key) instanceof JSONObject) { 
        exists = checkKey((JSONObject)object.get(key), searchedKey); 
      } 
     } 
    } 
    return exists; 
} 

Answer 1

Sie können JSONObject verwenden Ihre json zu analysieren und nutzen seine has(String key) Methode zu überprüfen, ob ein Schlüssel in dieser Json existiert oder nicht:

String str="{\"claim_loss_type_cd\": \"TEL\",\"claim_type\":\"002\",\"claim_reason\": \"001\",\"policy_number\":\"1234kk3366ff664\",\"info\": {\"ApplicationContext\":{\"country\": \"US\"}}}"; 
Object obj=JSONValue.parse(str); 
JSONObject json = (JSONObject) obj; 
//Then use has method to check if this key exists or not 
System.out.println(json.has("claim_type")); //Returns true 

EDIT:

Oder besser können Sie einfach überprüfen, ob der JSON String enthält diesen Schlüsselwert, zum Beispiel mit indexOf() Methode:

String str="{\"claim_loss_type_cd\": \"TEL\",\"claim_type\":\"002\",\"claim_reason\": \"001\",\"policy_number\":\"1234kk3366ff664\",\"info\": {\"ApplicationContext\":{\"country\": \"US\"}}}"; 
System.out.println(str.indexOf("claim_type")>-1); //Returns true 

EDIT 2:

Werfen Sie einen Blick auf diese Methode, iteriert es die verschachtelten Objekten über überprüfen, ob der Schlüssel vorhanden ist.

public boolean keyExists(JSONObject object, String searchedKey) { 
    boolean exists = object.has(searchedKey); 
    if(!exists) {  
     Iterator<?> keys = object.keys(); 
     while(keys.hasNext()) { 
      String key = (String)keys.next(); 
      if (object.get(key) instanceof JSONObject) { 
        exists = keyExists(object.get(key), searchedKey); 
      } 
     } 
    } 
    return exists; 
} 

Object obj=JSONValue.parse(str); 
JSONObject json = (JSONObject) obj; 
System.out.println(keyExists(json, "country")); //Returns true 

Answer 2

Eine ready-to-go-Methode bei korrekten Gießen von Typen:

/** 
* JSONObject contains the given key. Search is also done in nested 
* objects recursively. 
* 
* @param json JSONObject to serach in. 
* @param key Key name to search for. 
* @return Key is found. 
*/ 
public static boolean hasKey(
    JSONObject json, 
    String key) { 

    boolean exists = json.has(key); 
    Iterator<?> keys; 
    String nextKey; 

    if (!exists) { 

    keys = json.keys(); 

    while (keys.hasNext()) { 
     nextKey = (String) keys.next(); 

     try { 
     if (json.get(nextKey) instanceof JSONObject) { 
      exists = 
      hasKey(
       json.getJSONObject(nextKey), 
       key); 
     } 
     } catch (JSONException e) { 
     e.printStackTrace(); 
     } 
    } 
    } 

    return exists; 
} 

Answer 3

Beiden Lösungen, die die JsonObject rekursiv iterieren vorschlagen, einen kleinen Fehler haben: sie die Iteration nicht brechen wenn sie endlich den gesuchten Schlüssel finden. Sie müssen also die while-Schleife unterbrechen, sonst wird die Schleife fortgesetzt und wenn es einen nächsten Schlüssel gibt, wird dieser Schlüssel überprüft und so weiter. Das Codebeispiel, das nach dem "country" -Key sucht, funktioniert nur, weil 'country' zufällig der letzte Schlüssel in seinem JsonObject ist.

Beispiel:

/* ... */ 
    while (keys.hasNext()) { 
      nextKey = (String) keys.next(); 

      try { 
      if (json.get(nextKey) instanceof JSONObject) { 
       exists = hasKey(json.getJSONObject(nextKey), key); 

       if(exists){ 
        break; 
       } 

      } 
      } catch (JSONException e) { 
      e.printStackTrace(); 
      } 
     } 
    /* ... */