Moonwlker: JSON without annotation
Tags: java, json, jackson, showdev
Published: 2020-06-15 11:53:56

Jackson is a powerful library for processing JSON. It’s the default library used by the Spring Framework. It's very flexible and configurable. The standard way of configuring it is using annotations in the classes to be processed.

In this post, I will explain how to use the [Moonwlker](https://github.com/bertilmuth/moonwlker) library that I created. It’s a facade to Jackson, and provides a builder API to configure Jackson. That way, you can get rid of anotations in your classes. I will also show you how to integrate Moonwlker into Spring Boot applications.

Before we dive into code examples, why would you want to get rid of annotations in your classes? There may be several reasons, including:
* The annotations are JSON specific, and you don't want to bind yourself to using JSON as seralization mechanism.
* You don't have access to some classes where you'd need to put annotations, e.g. super classes of a framework.
* You're following Domain Driven Design (DDD) principles to publish/subscribe to Domain Events, and don't want your Domain Event classes to be cluttered with technology specific annotations.

Let's have a look at use cases, and how Moonwlker can help with it.

# Inheritance
Say you have a superclass `Person`, with subclass `Employee`. The standard way to tell Jackson about the inheritance relationships is to use annotations in the superclass:

``` java
@JsonTypeInfo(property = "@type", include = JsonTypeInfo.As.PROPERTY, use = JsonTypeInfo.Id.MINIMAL_CLASS)
@JsonSubTypes({ @JsonSubTypes.Type(value = Employee.class) })
public class Person {
  
  private String firstName;
  private String lastName;

  public Person() {
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }
}
```
What's the meaning of `property = "@type"` in the annotation? It declares that the JSON contains a property called `@type`. Its value is the name of the subclass so that Jackson knows which concrete class instance to create when deserializing.
As you can see, the superclass needs to mention all the subclasses, in this case the `Employee` class. Here's the code:
``` java
public class Employee extends Person{
  private String employeeNumber;

  public Employee() {
  }

  public String getEmployeeNumber() {
    return employeeNumber;
  }

  public void setEmployeeNumber(String employeeNumber) {
    this.employeeNumber = employeeNumber;
  }
}
```
Here's how you deserialize JSON to an `Employee` object, given that the `Employee` class is in the same package as the `Person` class. 

``` java
ObjectMapper objectMapper = new ObjectMapper();
String jsonString = "{ \"@type\" : \".Employee\", \"firstName\" : \"Jane\", \"lastName\" : \"Doe\" , \"employeeNumber\" : \"EMP-2020\"}";
Employee employee = (Employee) objectMapper.readValue(jsonString, Person.class);
```
## How Moonwlker handles inheritance
When you use Moonwlker, you can rid of all the annotations in the superclass. Instead, you build and register a module that contains the mapping between the JSON property, e.g. `@type`, and  the superclass, e.g. `Person`:

``` java
ObjectMapper objectMapper = new ObjectMapper();

MoonwlkerModule module =
  MoonwlkerModule.builder()
    .fromProperty("@type").toSubclassesOf(Person.class)
    .build();

objectMapper.registerModule(module);
```
The JSON looks almost identical, with the exception that there's no leading dot before the class name in the `@type` property:
``` java
String jsonString = "{ \"@type\" : \"Employee\", \"firstName\" : \"Jane\", \"lastName\" : \"Doe\" , \"employeeNumber\" : \"EMP-2020\"}";
Employee employee = (Employee) objectMapper.readValue(jsonString, Person.class);
```
And that's it.

# Integrating Moonwlker into Spring
To integrate Moonwlker into a Spring Boot project, all you need to do is register a Bean for the `ObjectMapper`:

``` java
@SpringBootApplication
public class GreeterApplication {
  public static void main(String[] args) {
    SpringApplication.run(GreeterApplication.class, args);
  }

  @Bean
  ObjectMapper objectMapper() {
    ObjectMapper objectMapper = new ObjectMapper();

    MoonwlkerModule module =
      MoonwlkerModule.builder()
        .fromProperty("@type").toSubclassesOf(Person.class)
        .build();
    
    objectMapper.registerModule(module);
    return objectMapper;
  } 
}
```

# Immutable object with all argument constructors
The standard way in which Jackson supports all arguments constructors is to use the `@JsonCreator` and `@JsonProperties` annotations. Moonwlker changes that: it enables you to deserialize objects that have a single, all arguments default constructor.

An example class that can be (de)serialized with Moonwlker could look like this:

``` java
public class Dog extends Animal {
  private final String name;
  private final String command;

  public Dog(BigDecimal price, String name, String command) {
    super(price);
    this.name = name;
    this.command = command;
  }
  
  public String name() {
    return name;
  }

  public String command() {
    return command;
  }
}
```

See the [Moonwlker website](https://github.com/bertilmuth/moonwlker) on details how to enable this feature.

# More to come
The Moonwlker project is work in progress. 
Any feedback is welcome. Drop a note in the comments. 
Or become a contributor. Thank you!