Java applications often use JSON as a common format for sending and receiving data. Moreover, it’s used as a serialization protocol for storing data. With smaller JSON data sizes, our applications become cheaper and faster.<\/p>\n
In this tutorial, we’ll look at various ways of reducing the size of JSON<\/a> in our Java applications.<\/p>\n Let’s create a domain model for a Customer<\/em> with some contact data:<\/p>\n Note that all fields will be mandatory, except for phoneNumber<\/em> and email<\/em>.<\/p>\n To properly test JSON data size differences, we need at least a few hundred Customer<\/em> instances. They must have different data to make our tests more lifelike. The data generation web site mockaroo<\/a><\/em> helps us here. We can create 1,000 JSON data records there for free, in our own format, and with authentic test data.<\/p>\n Let’s configure mockaroo<\/em> for our domain model:<\/p>\n Here, some items to keep in mind:<\/p>\n All the code examples below use the same data of 1,000 customers from mockaroo<\/em>. We use the factory method Customer.fromMockFile() <\/em>to read that file and turn it into Customer<\/em> objects.<\/p>\n We’ll be using Jackson<\/a> as our JSON processing library.<\/p>\n Let’s write a Java object to JSON with the default Jackson options:<\/p>\n Let’s see the mock data for the first Customer<\/em>:<\/p>\n When using default Jackon options, the JSON data byte array with all 1,000 customers is 181.0 KB in size<\/strong>.<\/p>\n As text data, JSON data compresses nicely. That’s why gzip <\/em>is our first option to reduce the JSON data size. Moreover, it can be automatically applied in HTTP, the common protocol for sending and receiving JSON.<\/p>\n Let’s take the JSON produced with the default Jackson options and compress it with gzip<\/em>. This results in 45.9 KB, just 25.3% of the original size<\/strong>. So if we can enable gzip<\/em> compression through configuration, we’ll cut down the JSON data size by 75% without any change to our Java code!<\/p>\n If our Spring Boot application delivers the JSON data to other services or front-ends, then we’ll enable gzip<\/em> compression in the Spring Boot configuration. Let’s see a typical compression configuration in YAML syntax:<\/p>\n First, we enabled compression in general by setting enabled<\/em> as true. Then, we specifically enabled JSON data compression by adding application\/json<\/em> to the list of mime-types<\/em>. Finally, notice that we set min-response-size<\/em> to 1,024 bytes long. This is because if we compress short amounts of data, we may produce bigger data than the original.<\/p>\n Often, proxies such as NGINX<\/a>\u00a0or web servers such as the Apache HTTP Server<\/a>\u00a0deliver the JSON data to other services or front-ends. Configuring JSON data compression in these tools is beyond the scope of this tutorial.<\/p>\n A previous tutorial on gzip<\/em><\/a> tells us that gzip<\/em> has various compression levels. Our code examples use\u00a0gzip<\/em> with the default Java compression level. Spring Boot, proxies, or web servers may get different compression results for the same JSON data.<\/p>\n If we use JSON as the serialization protocol to store data, we’ll need to compress and decompress the data ourselves.<\/p>\n It’s a best practice to use field names that are neither too short nor too long. Let’s omit this for the sake of demonstration: We’ll use single-character field names in JSON, but we’ll not change the Java field names. This reduces the JSON data size but lowers JSON readability. Since it would also require updates to all services and front-ends, we’ll probably use these short field names only when storing data:<\/p>\n It’s easy to change the JSON field names with Jackson while leaving the Java field names intact. We’ll use the @JsonProperty<\/em> annotation:<\/p>\n Using single-character field names leads to data that is 72.5% of the original size. Moreover, using gzip will <\/em>compress that to 23.8%.<\/strong> That’s not much smaller than the 25.3% we got from simply compressing the original data with gzip<\/em>. We always need to look for a suitable cost-benefit relation. Losing readability for a small gain in size won’t be recommendable for most scenarios.<\/p>\n Let’s see how we can further reduce the JSON data size by leaving out the field names altogether. We can achieve this by storing a customers<\/em> array in our JSON. Notice that we’ll be also reducing readability. And we’ll also need to update all the services and front-ends that use our JSON data:<\/p>\n Storing the Customer<\/em> as an array leads to output that’s 53.1% of the original size, and 22.0% with gzip<\/em> compression.<\/strong> This is our best result so far. Still, 22% is not significantly smaller than the 25.3% we got from merely compressing the original data with gzip<\/em>.<\/p>\n In order to serialize a customer as an array, we need to take full control of JSON serialization. Refer again to our Jackson<\/a> tutorial for more examples.<\/p>\n Jackson and other JSON processing libraries may not handle JSON null<\/em> values correctly when reading or writing JSON. For example, Jackson writes a JSON null<\/em> value by default when it encounters a Java null<\/em> value. That’s why it’s a good practice to remove empty fields in JSON data<\/strong>. This leaves the initialization of empty values to each JSON processing library and reduces the JSON data size.<\/p>\n In our mock data, we set 50% of the phone numbers, and 30% of the email addresses, as empty. Leaving out these null<\/em> values reduces our JSON data size to 166.8kB or 92.1% of the original data size. Then, gzip <\/em>compression will\u00a0drop it to 24.9%.<\/p>\n Now, if we combine ignoring null<\/em> values with the shorter field names from the previous section, then we’ll get more significant savings: 68.3% of the original size and 23.4% with gzip<\/em><\/strong>.<\/p>\n We can configure the omission of null<\/em> value fields in Jackson per class<\/a> or globally for all classes<\/a>.<\/p>\n We achieved the smallest JSON data size so far by serializing it to an array. One way of reducing that even further is a new domain model with fewer fields. <\/strong>But why would we do that?<\/p>\n Let’s imagine a front-end for our JSON data that shows all customers as a table with two columns: name and street address. Let’s write JSON data specifically for this front-end:<\/p>\n Notice how we concatenated the name fields into name<\/em> and the address fields into address<\/em>. Also, we left out email<\/em> and phoneNumber<\/em>.<\/p>\n This should produce much smaller JSON data. It also saves the front-end from concatenating the Customer<\/em> fields. But on the downside, this couples our back-end tightly to the front-end<\/strong>.<\/p>\n Let’s create a new domain class CustomerSlim<\/em> for this front-end:<\/p>\n If we convert our test data to this new CustomerSlim<\/em> domain class, we\u2018ll reduce it to 46.1% of the original size. That will be using the default Jackson settings. If we use gzip<\/em> it goes down to 15.1%. This last result is already a significant gain over the previous best result of 22.0%.<\/p>\n Next, if we also use one-character field names, this gets us down to 40.7% of the original size, with gzip<\/em> further reducing this to 14.7%. This result is only a small gain over the 15.1% we reached with the Jackson default settings.<\/p>\n No fields in CustomerSlim <\/em>are optional, so leaving out empty values has no effect on the JSON data size.<\/p>\n Our last optimization is the serialization of an array. By serializing CustomerSlim<\/em> to an array, we achieve our best result: 34.2% of the original size and 14.2% with gzip<\/em>.<\/strong> So even without compression, we remove nearly two-thirds of the original data. And compression shrinks our JSON data to just one-seventh of the original size!<\/p>\n In this article, we first saw why we need to reduce JSON data sizes. Next, we learned various ways to reduce this JSON data size. Finally, we learned how to further reduce JSON data size with a domain model that’s custom to one front-end.<\/p>\n The complete code is available, as always, over on GitHub<\/a>.<\/p>\n The post Reducing JSON Data Size<\/a> first appeared on Baeldung<\/a>.<\/p>\n In this tutorial, we’ll look at various ways of reducing the size of JSON in our Java applications.<\/p>\n The post Reducing JSON Data Size<\/a> first appeared on Baeldung<\/a>.<\/p>\n2. Domain Model and Test Data<\/h2>\n
public class Customer {\r\n private long id;\r\n private String firstName;\r\n private String lastName;\r\n private String street;\r\n private String postalCode;\r\n private String city;\r\n private String state;\r\n private String phoneNumber;\r\n private String email;<\/code><\/pre>\n![\"\"](\"https:\/\/www.baeldung.com\/wp-content\/uploads\/2020\/09\/JSON-generation.png\")
<\/a><\/p>\n\n
3. JSON Data Size with Jackson Default Options<\/h2>\n
Customer[] customers = Customer.fromMockFile();\r\nObjectMapper mapper = new ObjectMapper();\r\nbyte[] feedback = mapper.writeValueAsBytes(customers); <\/code><\/pre>\n{\r\n \"id\" : 1, \r\n \"firstName\" : \"Horatius\", \r\n \"lastName\" : \"Strognell\", \r\n \"street\" : \"4848 New Castle Point\", \r\n \"postalCode\" : \"33432\", \r\n \"city\" : \"Boca Raton\", \r\n \"state\" : \"FL\", \r\n \"phoneNumber\" : \"561-824-9105\", \r\n \"email\" : \"hstrognell0@dailymail.co.uk\"\r\n}<\/code><\/pre>\n4. Compressing with gzip<\/em><\/h2>\n
server:\r\n compression:\r\n enabled: true\r\n mime-types: text\/html,text\/plain,text\/css,application\/javascript,application\/json\r\n min-response-size: 1024\r\n<\/code><\/pre>\n5. Shorter Field Names in JSON<\/h2>\n
{\r\n \"i\" : 1,\r\n \"f\" : \"Horatius\",\r\n \"l\" : \"Strognell\",\r\n \"s\" : \"4848 New Castle Point\",\r\n \"p\" : \"33432\",\r\n \"c\" : \"Boca Raton\",\r\n \"a\" : \"FL\",\r\n \"o\" : \"561-824-9105\",\r\n \"e\" : \"hstrognell0@dailymail.co.uk\"\r\n}<\/code><\/pre>\n@JsonProperty(\"p\")\r\nprivate String postalCode;\r\n<\/code><\/pre>\n6. Serializing to an Array<\/h2>\n
[ 1, \"Horatius\", \"Strognell\", \"4848 New Castle Point\", \"33432\", \"Boca Raton\", \"FL\", \"561-824-9105\", \"hstrognell0@dailymail.co.uk\" ]\r\n<\/code><\/pre>\n7. Excluding null<\/em> Values<\/h2>\n
8. New Domain Class<\/h2>\n
{\r\n \"id\" : 1,\r\n \"name\" : \"Horatius Strognell\",\r\n \"address\" : \"4848 New Castle Point, Boca Raton FL 33432\"\r\n}<\/code><\/pre>\npublic class CustomerSlim {\r\n private long id;\r\n private String name;\r\n private String address;<\/code><\/pre>\n9. Conclusion<\/h2>\n
<\/p>\n
![](\"https:\/\/assets.feedblitz.com\/i\/fblike20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/googleplus20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/pinterest20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/twitter20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/email20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/rss20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/comments20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/commentsrss20.png\")
<\/a> <\/div>\n\n![\\\"IT\u96fb\u8166\u88dc\u7fd2](\\\"http:\/\/itteacheritfreelance.hk\/test\/wordpress\/wp-content\/uploads\/2016\/05\/logo2-2.png\\\"){kind=logo}
\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n<\/div>","protected":false},"author":895,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Reducing JSON Data Size - ITTeacherITFreelance.hk","description":"In this tutorial, we'll look at various ways of reducing the size of JSON in our Java applications. The post Reducing JSON Data Size first appeared on Baeldung"},"footnotes":""},"categories":[6],"tags":[5393],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/79885"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/895"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=79885"}],"version-history":[{"count":8,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/79885\/revisions"}],"predecessor-version":[{"id":83111,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/79885\/revisions\/83111"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=79885"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=79885"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=79885"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}