Accessing Nested Data Structures in Java
Four ways to quickly get at the data you need.
Join the DZone community and get the full member experience.Join For Free
Enterprise data structures are not usually flat. More often they are hierarchical, nesting one or more levels deep. For example, an account object might contain a customer object, which might contain an address object, and so on.
Such data structures are often returned by web services. A single call to the server requires less code and incurs less network overhead than multiple calls to retrieve the same information. Often, these data structures are returned as JSON and mapped to strongly typed equivalents such as Java beans on the client side. This works well when modeling the complete server response; however, it can be overkill when only a small subset of the returned data is required.
For example, the sample user service at typicode.com returns a collection of records structured like this:
It would be straightforward to map this content to a bean representation. However, if the caller is only interested in the "catchPhrase" values, for example, it would still require the following class definitions at a minimum:
WebServiceProxy class, the following code could then be used to bind the response data to bean instances, extract the catch-phrase values, and convert them to a JSON list:
Alternatively, interfaces could be used in place of the bean types to eliminate some of the boilerplate code:
The code for extracting the catch-phrases would be identical to the previous example, and the resulting output would be the same:
A third option would be to deserialize the "raw" JSON data and access the catch-phrases via successive calls to
This uses less code than the bean or interface approaches, but still requires the declaration of a moderately complex generic, even for this fairly simple case.
A fourth alternative would be to use the
valueAt() method of HTTP-RPC’s
Collectionsclass to access the nested values by key path:
This approach is the least verbose, as it allows the caller to retrieve the desired data directly, without the need for intermediate types or nested generics.
If a caller needs access to most or all of the data returned by a service, then binding to bean or interface types is probably the most practical solution. However, if access to only a targeted subset of nested data is required (e.g. for lightweight transformation or basic validation), then the generic map or
valueOf() approach may be preferable.
For more information, see the project README.
Opinions expressed by DZone contributors are their own.