I am working with socket.io library which emits messages to the socket.io server. The server expects JSON objects, arrays, etc. My original implementation used JSONOject and JSONArray datatypes. However, I would like to switch to using classes generated via Parceler library. The classes generated with library's annotations can be wrapped into Parcels. It seems like a very convenient way of managing such communication. However, is there a way to convert Parceler's class or a Parcel class into a JSON string or JSONObject/Array?
GSON library supports toJson method and I know that Retrofit does some magic with Parcels, JSON, and GSON.
i guess this will help you,
Create a class with getters and setters method for example
class A
{
int b;
void setb(int x){this.b = x;}
int getb(){return this.b}
}
than you can create json from the object of this class:
new Gson().toJson(a)
Or object from json:
a = new Gson().fromJson(data, A.class);
Related
I am using the org.json.JSONStringer class to generate JSON strings for my Android application.
fun createJSONString(stringer:JSONStringer) {
stringer.object()
//write some stuff
stringer.endObject()
}
However, I can't call the object() method of this class to create a new JSON Object, since object is a kotlin property. Thus, Android studio tells me that constructors are not allowed for objects. What could I do to force Android Studio to use the JSONStringer's object() method?
Why not use JSONObject class instead, example to and from JSONObject:
val jsonStr = "{\"age\":33,\"messages\":[\"msg 1\",\"msg 2\"],\"name\":\"jim\"}"
val jObj = JSONObject(jsonStr)
val str = jObj.toString()
Since JSONStringer is just an implementation of JSONObject#toString and JSONArray#toString, also usage of this API is discouraged as described in:
JSONStringer
Implements JSONObject#toString and JSONArray#toString. Most application developers should use those methods directly and disregard this API
Here's a good tutorial: Json parser
And as alternative you can use JSON serialization / deserialization library like GSON or Jackson
How to convert Java object to / from JSON (Jackson)
Write
stringer.`object`()
See Escaping for Java identifiers that are keywords in Kotlin.
I'm trying to implement the parcelable interface using Gson. The idea is to create a json string (using gson) and write it to the parcel object.
Could it be a correct way to implement the interface?
The only problem I've encountered is when I deserialize the object. Actually, I use gson to recreate the object.
private MyClass(Parcel in) {
String json = in.readString();
Gson gson = new Gson();
gson.fromJson(json, getClass());
}
The problem is that the fromJson function returns an object that is the object the constructor should create.
The last line of code should be something like
this=gson.fromJson(json, getClass());
So, if this is a correct way to implement Parcelable, how could I solve this problem?
You should read more carefully the Parcelable javadoc. It contains everything you need.
As quoted in the docs :
Interface for classes whose instances can be written to and restored
from a Parcel. Classes implementing the Parcelable interface must also
have a static field called CREATOR, which is an object implementing
the Parcelable.Creator interface.
So you should have the writeToParcel method declared and also use a creator that will produce instances of your class from a Parcel.
The private constructor is an additional helper that you can use to set the value of the fields of an object given a parcel, but not the object itself. In Java, this is a right value, and can't be assigned.
BTW, the goal of parcelisation is to be provide a short term fast serialization process. You should, generally speaking, use a fast and compact data format when you use parcelisation. JSON is not a candidate of choice, but it will work.
Does somebody aware of some good jackson annotations tutorials? Especially, how do you parse json array using jackson annotations?
Suppose I have json like this:
{
...
"item1": "aaa",
"item2": "bbb",
"fl": [
{
"item3": "ccc",
"item4": "ddd"
}
]
}
How does one parse json including array using jackson annotations?
I assume you are asking about how to map JSON into Java objects (parsing typically refers to lower level activity of decoding JSON content stream into another representation, which may or may not be set of objects).
With Jackson (as well as many other libs, Genson, GSON etc), you have choice of either binding it into a POJO with matching structure, say:
public class Value {
public String item1; // or some other type one can bind from JSON String
public String item2; // can alternatively use getters/setters instead of public fields
public List<EntryType> f1;
}
public class EntryType {
public String item3;
public String item4;
}
or reading it as a Tree representation like so:
JsonNode rootNode = mapper.readTree(inputSource);
In latter case, you need to traverse the tree nodes to find your data.
As to annotations: you only need to use annotations if you need to change default properties of binding; like mapping between JSON Object fields and POJO property names.
For Jackson-specific configuration including some of annotations, see Jackson-databind github project: https://github.com/FasterXML/jackson-databind/
There are three ways to parse json using Jackson -
Using a streaming Parser. (http://www.studytrails.com/java/json/java-jackson-json-streaming.jsp)
Parsing Json to a tree model - http://www.studytrails.com/java/json/java-jackson-json-tree-parsing.jsp
Data binding with our without annotations - data binding, data binding with filters, Polymorphic data binding
I am sharing this for others working between Java clients and Web Services from .Net MVC4 and using RoboSpice and FasterXML Jackson frameworks. I could not find good information on stackoverflow on how to set up the JSON POJO class for proper object mapping for the POST result object. For POST operations the RESULT JSON comes back with the structure from the .Net web services:
{"ClassName":{"attribute_one":1,""attribute_two":1,"....}}
I could not figure out how to get the FastXml Jackson ObjectMapper readValue parsing to work. I got an empty result object after parsing with all the properties set to null or default values..., or invalid property name for the class name if I turned off the JsonIgnoreProperties.
The following POJO object definition finally worked for me. It has an outer class that matches the ClassName in the Result and then an inner static class for mapping the Single Result Object into a Java Class Object:
public class ClassNameOuter {
#JsonProperty("ClassName")
public ClassName _ClassName;
public ClassName get_ClassName() {
return _ClassName;
}
public void set_ClassName(ClassName _ClassName) {
this._ClassName = _ClassName;
}
#JsonIgnoreProperties(ignoreUnknown=true)
public static class ClassName {
#JsonProperty("attribute_one")
public long attribute_one;
#JsonProperty("attribute_two")
public long attribute_two;
For the experts out there on Jackson and Robospice....please share if there is a better way.
RoboSpice doesn't support yet parsing of XML using Jackson. It provides a module to parse XML using SimpleXMLSerializer but not jackson.
Can you indicate which classes of Jackson you used, I would add a module soon to RS.
I'm currently using GSON to parse my JSON to Objects. I was using the standard way like :
Result response= gson.fromJson(reader, Result.class);
Result can be a very complex object with other Complex objects, with up to 5 levels of complex objects. But I have no issues with that.
My Question is : I would like to be able to have in some objects an attribute with a flexible type.
For example :
class Class1 {
String hello;
}
class Class2 {
String world;
}
class Class3 {
Class<?> (= class1 or class2) hello;
}
// Parsing time
Class<?> response= gson.fromJson(reader, Class3.class);
try {
Class1 ret = (Class1)response;
} catch ... {
Class2 ret = (Class2)response;
}
Hope it's clear enough.
Unfortunately, the latest release of Gson (2.0) still doesn't have built-in support for an easy configuration to provide polymorphic deserialization. So, if Gson must be used (instead of an API that has such built-in support, like Jackson -- using which I've posted complete examples for polymorphic deserialization at http://programmerbruce.blogspot.com/2011/05/deserialize-json-with-jackson-into.html), then custom deserialization processing is necessary.
For deserialization to polymorphic types, something in the JSON must be present to identify which concrete type to deserialize to.
One approach would be to have an element in the JSON dedicated to just this purpose, where the deserialization code selects the correct type based on the value of the special-purpose element. For example:
{"type":"Class1","hello":"Hi!"} --> deserializes to Class1 instance
{"type":"Class2","world":"Earth"} --> deserializes to Class2 instance
Another approach would be to just switch on the presence of particular JSON element names, though instead of try-catch blocks as demonstrated in the original question, I'd just use if-statements.
See Gson issue 231 for more on this topic, as well as possible information on when a built-in polymorphic deserialization facility might be included in Gson.
Another StackOverflow.com post with an example of polymorphic deserialization with Gson is Polymorphism with gson