Our Java team has recently prepared a hands-on workshop on functional programming in Java 8. The participants solved our coding tasks, trying out the Java 8’s features in separation, and now it’s time we show off how we employ the full power of Java 8 in our real-life projects.

This is a common problem of converting pairs of similar objects one to another (in our case – domain classes to DTOs, which are then sent to frontend as JSON objects) and the other way round. In this case, what we need is a one-shot conversion, just once in the object’s lifetime. What we do not want is coupling between the two kinds of objects: DTO classes shouldn’t “know” about domain classes and the other way round.

Converter class in Java

As changes in the source object do not have to affect the destination object, the classic solution would be to create a single “Mapper” (or “Converter”) class for each pair. There are also tools which are able to map fields of similar classes, based on field names. But how about “producing” whole collections of our source object? How to produce collections of destination objects, without too much boilerplate code?

What addresses our needs, is Java 8 and its three core features:

  • default method implementation in interfaces
  • streams
  • lambdas (here in the form of a method reference)

Default method implementation is what saves us from boilerplate code, creating collections of objects. Streams and lambdas build a beautiful code transforming our collections. Let’s have a look at the final class hierarchy and the code itself:

Having implemented the default method that converts a collection of data transfer objects (D) into entities (E), as well as another one that does the opposite, we don’t need to implement this in concrete implementations of the converter any more. Creating a converter for a single DTO/domain class is as simple as that:

Another feature you can see there is our ClassUtils.setIfNotNull method, which only calls the setter if the getter yields a non-null value:

So there we have a complete Converter structure using all the Java 8 goodness. Adding a new Converter for another entity-DTO pair (like User, Address, etc.) needs just creating a new UserConverterImpl class, implementing its own UserConverter, which in turn should  implement GenericConverter. This way the new class will be capable of converting collections of objects out-of-the box. This is possible thanks to the default method implementations in GenericConverter interface, which is a very handy Java 8’s feature.

Let us know your thoughts on this solution!

white Land Rover
Business Featured Post

How BlaBlaCar beat the competition in the race for market domination in 27 countries.

When BlaBlaCar approached XSolve, they were at a stage of rapid growth with around 24 million users already buzzing about their excellent carpooling platform. But the visionaries at BlaBlaCar...

ebook cover
Business Featured Post

E-book: How to Create an Agile Office

We present to you an e-book which collects all our experiences and thoughts regarding creation of an agile office. Hands on, practical, functional. This resource was created primarily for...

Holacracy why it’s a good idea to share the power
Business Featured Post

Holacracy: why it’s a good idea to share the power

We are on standing on the brink of the AI revolution. Researchers at the University of Oxford predict that in the next two decades up to 66% of American...

This site uses cookies. By continuing to browse the site you are agreeing to our use of cookies.

To find out more click here

Ok, Thanks