Objects in collections needs to have override option from reflection-based variable detection

[KimvdLinde]

adding a collection needs to have an option to use custom made JSONObjects for the elements in the collection instead of the default method and variable reflection based construction of the JSONObject because not everybody wants to push out all variables in the object into JSON to see for everybody.

[KimvdLinde]

This is the code I use to override it:

public JSONObject toJSON() { JSONObject collection = new JSONObject(); this.keySet().forEach((key) -> { collection.put(key.toString(), ((AgObject) this.get(key)).toJSON()); }); return collection; }

[johnjaylward]

This project supports an interface JSONString which I believe will do what you want assuming you have source control over the objects in the collection.

Were you looking for something different?

[KimvdLinde]

No, I am putting out an JSONObject, not a string (yet).

[johnjaylward]

An example implementation using the JSONString interface may look something like this:

public class MyPoJo implements org.json.JSONString {
  private String someField; // pretend getters and setters
  private int someOtherField; // pretend getters and setters
  private ZonedDateTime aDate; // pretend getters and setters
  
  @Override
  public String toJSONString() {
    // notice the lack of "someOtherField"
    return "{" + "\"someField\":" + JSONObject.quote(this.someField) + ",\"aDate\":" + JSONObject.quote(formatMyDate()) + "}";
  }

  private String formatMyDate() { /* some implementation that formats your date a specific way */ }
}

// then somewhere else in code:
Collection<MyPoJo> cMP = getACollectionFromSomewhere();

JSONArray ja = new JSONArray(cMP); // at this point, the items in the JSONArray are still MyPoJo, not a string or JSONObject
// if you want you can still work with the POJO through the JSONArray

// the following will cause the `MyPoJo.toJSONString` to be called for each MyPoJo in the list
// the output will be as you expect with the POJO formatted as we customized.
return ja.ToString(); 

Does something like this accomplish what you are trying to do, or do you need to work with actual JSONObjects?

[johnjaylward]

@stleary can you add the above example to the Wiki somewhere? maybe make an examples page?

[KimvdLinde]

I need the actual objects because I add them to other objects and if I use string it does not render correctly

[johnjaylward]

Are you unable to add the original POJO? i.e. something like this:

// assume the same POJO implementation above

Collection<MyPoJo> cMP = getACollectionFromSomewhere();

JSONObject jo = getJSONObjectFromSomewhere();

MyPoJo mpj = cMP.stream().filter(p -> p.getSomeOtherField() == 5).getFirstOrDefault();
if (mpj != null) {
    jo.put("pojo5",mpj); // add the POJO as the MyPoJo class, not a JSON Object
}

mpj = cMP.stream().filter(p -> p.getSomeOtherField() == 15).getFirstOrDefault();
if (mpj != null) {
    jo.put("pojo15",mpj); // add the POJO as the MyPoJo class, not a JSON Object
}

// this will output the `jo` with the 2 found POJO under keys `pojo5` and `pojo15`.
// Both pojo will be output using the `toJSONString` method. 
return jo.toString();

[KimvdLinde]

The above solution that I posted works brilliantly for me, so I just use that. Just was thinking that if the put(map) method would recognize a specific function to override the default, that would be an easy way to simplify the code for many.

[johnjaylward]

for full disclosure, I use a similar solution as @KimvdLinde in my own copy of this library. Mine looks like

public interface JSONSerializable {
    JSONObject toJson(final int recursionDepth) throws JSONException;
}

However, due to the presence of the JSONString interface in the main library I never felt comfortable bringing it over to here. For example, what if something like this were done:

public class A implements JSONString {
   public String toJSONString(){
       // some implementation
   }
}

public class B extends A implements JSONSerializable {
   public JSONObject toJson(final int recursionDepth){
       // some implementation
   }
}


JSONObject jo = new JSONObject();
jo.put("myB", new B());
jo.toString();

Which output should be used? From the writer side we would need some kind of precedence ordering to decide if the writer calls toJSONString or toJSON. We could use reflection and try to figure out which it closest to the object being written, but that can be an expensive call which could significantly slow down the writer. Or we could always make it a convention that since we are outputing a JSON String, the toJSONString method would be called first, otherwise toJSON().toString() would be called. This could cause some odd "bugs" in code though if someone was expecting a field in Object B to be output, but only object A was.

I'm not against adding in a new interface, but I do feel like it could lead to some ambiguity.

[KimvdLinde]

I would say that toJSONstring is when it leaves the JSON package (print.out for example) and toJSON when adding to a JSONObject

[johnjaylward]

so something like this?:

JSONObject jo = new JSONObject();
B myB = new B();
jo.put("someKey", myB); // calls `B.toJson()` internally so long as B implements the interface

jo.toString(); // `someKey` is already a JSONObject, so there would be no direct call to `toJSONString` on the B object.

In essence, the toJson method would take precedence.

[KimvdLinde]

Exactly.

[KimvdLinde]

The benefit is that this is actually a much faster implementation that the reflection based current implementation.

[johnjaylward]

@stleary any thoughts on the proposed interface? Is it something you feel is addable to the library?

I think the simpler method that @KimvdLinde suggested (toJSON()) would be a better candidate as it's easier to call internally. For my interface (toJSON(int recursionDepth)), I end up having methods on the JSONObject and JSONArray dedicated to the interface that looks like this (maybe... working from memory):

// JSONObject.java

public JSONObject put(string key, JSONSerializable o, int recursionDepth) {
  if (key == null) throw JSONException("Key can not be null");
  if (value == null) {
    this.remove(key);
    return this;
  }
  return this.put(key, o.toJSON(recursionDepth));
}

// JSONArray.java

public JSONArray put(JSONSerializable o, int recursionDepth) {
  return this.put(o.toJSON(recursionDepth));
}

With the simpler method proposed by @KimvdLinde, we don't need any specialized functions and just add cases to the receivers that take Object as their value parameter.