如何避免 JSONObject Null 检查

Question

I have JSON like below

{
  "a1": "aaa",
  "b1": 333,
  "c1": {
    "c1": "ccc",
    "d1": "ddd",
    "f1": [
      {"a1": "xyz"},
      {"b1":  "lmn"},
      {"c1":123.00}
    ]
  }
}

I am reading the file into String and creating a JSONObject as below

JSONObject json = new JSONObject(new JSONTokener(str));

The JSON is coming to my application from outside so the content can be very different in times. Say it can be completely null or some of the elements can be null or array size can be 0 or 1 or more etc.

When I am working on the JSONObject I can keep on checking all the elements using

json.has and !=null 

so that it does not throw any exception.

I can have the code as below

if(
      json.has("c") 
   && json.getJSONObject("c")!= null 
   && json.getJSONObject("c").has("f") 
   && json.getJSONObject("c").getJSONArray("f").length() > 1 
   &&json.getJSONObject("c").getJSONArray("f").getJSONObject(1).has("b")
  ){     
      String x = json.getJSONObject("c").getJSONArray("f").getJSONObject(1).getString("b");
   }

That makes the code having a long list of if conditions.

However I am thinking instead I can just enclose the statement with try catch

try {
     String x = json.getJSONObject("c").getJSONArray("f").getJSONObject(1).getString("b");
    }catch(JSONException e) {
        //log and proceed
    }

Please suggest if there is any valid reason in this case to put a long if conditions rather than just try - catch - log and proceed.

Also can you share if using JSONException has any "pros" in this context?

Answer 1

Option 0: Long If-Statement

I think this is far too convoluted, especially as the chain gets longer. The only case where I would consider a remotely similar solution is if the user needs to know exactly at which point the problem lies and there are specific guidelines on how to solve this and how this may occur in a very specific use case, however in that case you need a large number of if statements and log statements.

Option 1: Try-Catch

Try-catch, as you suggested, is indeed possible, however you need to make sure that you catch all possible exceptions that can occur when a JSON field is not present or of the wrong type, for example ClassCastException and NullPointerException. It is short but not very elegant and as the other answerer said might hide other exceptions (but you could still log the stack trace).

Option 2: Java 8 Optional

Another option is to find a library that allows you to use the Java 8 Optional type. For example, this is suggested using Jackson . This is more elegant but could become a large chain as well. Also this adds one more dependency to your project.

Option 3: Path Expressions

A third option would be to use path expression JsonPath , where you can put all your statements into one expression and get all results for that. In my opinion this is the perfect use case and by far the best solution. The only downside is that this adds one more dependency to your project.

Answer 2

Please suggest if there is any valid reason in this case to put a long if conditions rather than just try - catch - log and proceed.

Here are a couple of reasons:

• Efficiency: creating, throwing and catching an exception is relatively expensive. Exactly how expensive is version dependent, and probably context dependent too. In recent versions, the JIT compiler can (AFAIK) optimize some sequences into a conditional branch. However, if you are going to log the exception, then the JVM is going to have to create an exception object and populate the stacktrace, and that this the most expensive part.

• If you log NullPointerException for:

   json.getJSONObject("c").getJSONArray("f").getJSONObject(1).getString("b")

  you may not be able to tell which of the components was missing or null. The line number in the stacktrace won't be sufficient to distinguish the cases. (With a JSONException the exception message will give you more clues.)

• You also can't distinguish the case where json is null , which is probably a different kind of problem; ie a bug. If you treat that as a data error, you are making it difficult to find and fix the code bug.

• If you catch all exceptions (as suggested by another answer), you are potentially hiding more classes of bugs. Bad idea.

---

Also can you share if using JSONException has any "pros" in this context?

The only real "pro" is that it is possibly less code, especially if you can put the try... catch around a lot of this code.

The bottom line is that you need to weigh this up for yourself. And one factor is how likely it is that you will get JSON that doesn't match your code's expectations. That will depend in part on what is producing the JSON.

Answer 3

Thanks to the responses above, below is how the problem has been solved.

JSONPath is working the best for the scenario I mentioned. Thanks to @Konrad.

First create a configuration object of type com.jayway.jsonpath.Configuration

Configuration conf = Configuration.builder().options(Option.SUPPRESS_EXCEPTIONS).mappingProvider(new JsonOrgMappingProvider()).jsonProvider(new JsonOrgJsonProvider()).build();

• Option.SUPPRESS_EXCEPTIONS - This will help to suppress the exception in case an element is missing
• mappingProvider(new JsonOrgMappingProvider()).jsonProvider(new JsonOrgJsonProvider() - This uses the right provider so that when we parse the json we don't need to convert the JSONObject to String thus giving optimal performance.

DocumentContext docContext = JsonPath.using(conf).parse(json);

If we use default provider then we need to parse the JSONObject as follows

DocumentContext docContext = JsonPath.using(conf).parse(json.toString());

Then to read the element I used

docContext.read("$.a.b.c.d.values[0].e.f")

The performance is now optimal as well. The reason it was taking more time and memory was because

• I was reading and parsing at the same time in a loop. Later on I moved the parsing out of loop.
• I was using default provider and was doing json.toString()