We Keep Coding

Deserialize the JSON data encapsulated in the request body into two different model object

I am learning SpringBoot and am doing this coding challenge. So far, I have successfully set up the controller and have done the mapping.
#RestController
#RequestMapping(path="/mydomain")
public class PaymentController {
#RequestMapping(method=RequestMethod.POST, value="/ingest")
public void ingestData(#RequestBody String data) {
System.out.println("ingest Data");
System.out.println(data);
// List<Orders>
// List<Returns>
}
#RequestMapping(method=RequestMethod.GET, value="/query")
public String queryData(#RequestBody String data) {
// look at LIST of order and return..and return something
}
}
The String data is JSON and it contains two different types - Order and Return.
{
"entries": {
{
type: "ORDER",
name: "order_1",
"attributes": {
"owner": "John"
}
},
{
type: "ORDER",
name: "order_2",
"attributes": {
"owner": "Mike",
"buyer": "Bob"
}
// attributes is a key/value pair Map
},
{
type: "RETURN",
name: "return_1",
"attributes": {
"user": "kelly",
"time": "null",
"inputs": [
"USD",
"EUR"
],
"outputs": [
"CAD",
"GBP"
]
}
// attributes is a key/value pair Map
},
}
}
In ingestData(), I want to parse though the json and create 2 lists - one each for orders and returns. In the past, I have dealt with the all the items in the json mapping to the same Java class. How do I parse and map json items into 2 different java classes?

You should probably rethink your REST api setup a bit. It's better to create endpoints based on classes rather than have generic endpoints that process multiple. Although this might look like more work now it will really help you generate more maintainable code. The fact that you now run into this problem where you want an ObjectMapper to resolve to different classes from a single Json is a good indicator that you're going in the wrong direction.
There is a great REST API design best-practices here on Stack available

[JsonString] -some json parsing libraries-> [Collection<Entity>] -.stream().collect(Collectors.groupingBy())-> [Map<String(type),Collection<Entity>>]
https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html
https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html

Java GSON Json partial parsing

Say I have a JSON object representing an entity (can be any entity) like so:
{
"entity_id": "1",
"entity_name": "employee",
"entity_json": {
"employee_id": "e01",
"employee_name": "john",
"employee_phone_numbers": [
"1234567",
"8765433"
]
}
}
Note that entity_json can represent different entities having different structures as long as it is a valid JSON. For example, the following is another entity's representation:
{
"entity_id": "1",
"entity_name": "invoice",
"entity_json": {
"invoice_id": "1011",
"items": {
"item_id": "1",
"quantity": "3",
"price": "$100"
},
"date": "01-01-2020",
"customer": {
"id": "3",
"address": {
"street": "some_street",
"country": "CZ",
...
}
}
}
}
I want to be able to partially parse this JSON into an Entity POJO using Gson in Java. That is, I'll have an entity POJO like the one shown below:
public class Entity {
private String entity_id;
private String entity_name;
private String entity_json; // <-- entity_json is a String
// getters and setters
}
/*
* entity_json (for employee) = "{ \"employee_id\": \"1\", \"employee... }"
* entity_json (for invoice) = "{ \"invoice_id\": \"1011\", \"items... }"
*/
and I'm planning on performing any operation on entity_json using JsonPath.
Is there any way I can achieve this WITHOUT having to explicitly set entity_json in the JSON structure as a string with escapes?
Any help is appreciated here. Thanks!

You can avoid using a String for your entity_json by using Gson's JsonObject.
Here is my revised Entity class:
import com.google.gson.JsonObject;
public class MyEntity {
private String entity_id;
private String entity_name;
private JsonObject entity_json;
// getters and setters not shown
}
Then you can populate instances as follows:
MyEntity myEntityOne = new Gson().fromJson(JSON_ONE, MyEntity.class);
MyEntity myEntityTwo = new Gson().fromJson(JSON_TWO, MyEntity.class);
System.out.println(myEntityOne.getEntity_json());
System.out.println(myEntityTwo.getEntity_json());
In the above code, JSON_ONE and JSON_TWO are just strings containing the two sample JSONs from your question.
The console prints out the following (snipped for brevity):
{"employee_id":"e01","employee_name":"john","employee_phone_numbers":["1234567","8765433"]}
{"invoice_id":"1011","items":{"item_id":"1","quantity":"3","price":"$100"},"date":"01-01-2020"...
You can, of course, now use Gson to further manipulate each entity_json field as needed, since each one is itself a valid JSON object.

Customized serialization of POJO to JSON in spring restTemplate

I am using the spring restTemplate to make POSTs to an endpoint and want it to convert my POJO to JSON. This is being done already. I have a list and it converts to JSONArray and does it successfully. I want to modify it a bit though where instead of it being an array, I want it to be a JSON with a key being the name of the list variable, and the value being the list.
Example is:
List<Record> records;
The above would create a JSON of
{
"records": [
{
"name": "test",
"address": "chicago"
},
{
"name": "stack",
"address": "overflow"
},
{
"name": "etc",
"address": "etc"
}
]
Rather than being [{},{},{}]

I think just simple create a DTO object which contains your List and return it. For instance:
public class SampleDTO{
private List<Record> records;
//getter setter
}
in the Controller, just return the ResponseEntity with the body is your SampleDTO
Hope this help.

Java collections to JSON

My program has to output following JSON format:
{ "success": {
"code": 1,
"desc": "success" },
"response": {
"res1": [
{
"Item": "item1",
"Description": [
{
"desc": "ad1",
"active": true,
"details": [
{
"Type": "Type1",
"Count": 2,
"Status": true
},
{
"Type": "TYpe2",
"Count": 3,
"Status": false
},
]
},
{
"desc": "item2",
"active": true,
"details": [
{
"Type": "Type1",
"Count": 4,
"Active": true
}
]
},
{
"Item": "item2",
"Description": [
{
"desc": "d2",
"Active": true,
"details": [
{
"Type": "Type3",
"Count": 6,
"Active": true
},
]
},
]
}
]
}
}
I have wrote following to create this json format
HashMap<String, HashMap<String, String>> m1 = new HashMap<String, HashMap<String, String>>();
HashMap<String, String> m2 = new HashMap<String, String>();
HashMap<String, ArrayList<HashMap<String, String>>> m3 = new HashMap<String, ArrayList<HashMap<String, String>>>();
For creating the mentined JSON format, I tried to put m3 and m2 in m1. But since these are not with same type, it won't allow to put.
I am using GSON to convert the collection to JSON.
Gson gson = new Gson();
String json1 = gson.toJson(m1);
My Question is: For creating that JSON format, which collection in Java I have to use?

The best way to deal with a complex JSON structure like that is to create a class with the same structure with properties that represent the underlying arrays as lists. Then, you can use gson to convert the object(s) to JSON in a straightforward way.
In other words, instead of trying to fit the structure into a combination of complex collections or existing Java classes, create a class that is an exact representation of the data, populate it, and then convert it to JSON.

Why don't you let the code generated for you?
After the pojos are created you can of course change the code to tailor your needs.

Create a ResponseWrapper class and build your json accordingly.
Sample code:
public class ResponseWrapper<T>{
private Map<String, T> wrappedObjects = new HashMap<String, T>();
public ResponseWrapper() {
}
public ResponseWrapper(String name, T wrappedObject) {
this.wrappedObjects.put(name, wrappedObject);
}
..
..
Your json can be built like this:
ResponseWrapper response = new ResponseWrapper<ResponseWrapper>();
Items[] item = ....
//item can itself have Description, etc.
response.set("res1", (ArrayList) items);

Thanks for notepad++ and its json view plugin, i can read your json data in proper format. (although your data missing a few brackets)
In my oponion, json structure can be converted into Map but i personally don't like that idea much.
The other way to do is using Java POJO to define your JSON object and then convert it to json. Excellent example here
OK. We will check your data and create Java POJO for it. It's simple and should be something like this
public class YourJsonObj {
public SuccessObj success;
public ResponseObj response;
}
where SuccessObj and ResponseObj are another structure Classes like this:
public class SuccessObj {
public Integer code;
public String desc;
}
public class ResponseObj {
public List<ResObj> res1;
}
Another sub class appear: ResObj. All you have to do is continue define it:
public class ResObj {
public String Item; // << this property's name does't make java happy
public List<DescriptionObj> Description // << this property's name does't make java happy
}
Continue to do this definition till the end of your data. And you got it.

My suggestion is to replicate the same hierarchy of the fields in your JSON example.
By the Google Gson library you can convert (in 2 lines of code) your Java object to a JSON object. Please check the following example (from the user guide of the relative project).
class BagOfPrimitives {
private int value1 = 1;
private String value2 = "abc";
private transient int value3 = 3;
BagOfPrimitives() {
// no-args constructor
}
}
// Serialization
BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj);
// ==> json is {"value1":1,"value2":"abc"}

Create a specific JSON String with Gson

When I use JSON-Lib project, I can create with the command
JSONObject jObject = new JSONObject();
jObject.accumulate("articles", list);
String json = jObject.toString();
The following Output:
{
"articles": [
{
"amount": "50",
"id": "1",
"pct": "50,00",
"price": "162,37",
"startamount": "100",
"stockvalue": "8118,45"
},
{
"amount": "20",
"id": "2",
"pct": "20,00",
"price": "164,83",
"startamount": "100",
"stockvalue": "3296,60"
},
{
"amount": "20",
"id": "3",
"pct": "20,00",
"price": "170,40",
"startamount": "100",
"stockvalue": "3408,00"
},...
]
}
Meanwhile I use the Gson project and are tied to it.
But the following code:
Gson gson = new Gson();
String json = gson.toJson(list);
will give me this output:
[
{
"id": "1",
"amount": "50",
"startamount": "100",
"pct": "50,00",
"price": "162,37",
"stockvalue": "8118,45"
},
{
"id": "2",
"amount": "20",
"startamount": "100",
"pct": "20,00",
"price": "164,83",
"stockvalue": "3296,60"
},...]
The elements in my list are objects from my pojo article
public class Article implements IsSerializable {
private String id;
private String amount;
private String startamount;
private String pct;
private String price;
private String stockvalue;
public Article(){
}
//Setter & Getter
}
How can I create with the help of Gson a JSON string like the one JSON-Lib will create (JSONObject with JSONArray which inlcudes JSONObjects).
In future the JSON String will/must be extended with more arrays (not articles, but other stuff).
I retrieve this generated JSON String from a HttpServlet. Does it make sense to deserialize the Gson JSON String back to ArrayList or should I use the GWT JavaScript Overlay Types?
Thanks & BR,
mybecks

It happens because you give to the Gson a list of objects. So if you want to have the same output as in first json snippet, you have to define object, which will hold the list of articles. E.g. :
public class ArticlesResult {
private List<Article> articles;
...//the rest of the code, like getters and setters
}
Regarding converting JsArray back to the ArrayList. It depends, most of the times it is better to use overlay types, since they are faster to create, and have small footprint in generated JS code. But it is true only for production mode. In devmode, overlay types are slower, so if you rapidly access overlay types, you will waste a lot of time there.

To quote the Gson User Guide:
Gson is a Java library that can be used to convert Java Objects into their JSON representation.
This means that you have to provide the complete structure that you want to see in the JSON string in the Java objects that you serialize into JSON.
In your case you need to wrap your list of articles in a bean that has a property "articles".
If it is required to build dynamic structures, Gson might not be the best tool for you.
you can compare Gson with XML binding tools like JAXB. A bean structure used with JAXB is not meant to be changed at runtime.