best approach for marshaling unmarshaling immutable objects with builder pattern

Question

I have a simple restful service that I'm developing in java. I have been looking at a few of the options for marshalling/unmarshalling json. The possible approaches available, jaxb jackson etc, are quite new to me and I'm trying to find my feet with them. I was wondering if I could get some advice on what would be the best approach and technology to use especially given that many of the objects I'm interested in I have implemented as being immutable and I have used the builder pattern. So there are no setters and the constructor is private.

I have looked at this previous question: Jackson + Builder Pattern? posted on stackoverflow. I am considering something like this approach although it would be great to get some pointers to more resources about using @JsonDeserialize

Here is a very simple example of the type of object I'm considering

public class Reading {

private final double xCoord;
private final double yCoord;
private final double diameter;
private final double reliability;
private final String qualityCode;


private Reading(Builder builder){
    xCoord = builder.xCoord;
    yCoord = builder.yCoord;
    diameter = builder.diameter;
    reliability = builder.reliability;
    qualityCode = builder.qualityCode;
}


public static class Builder {
    //required parameters
    private final double diameter;
    //optional parameters
    private double xCoord = 0.0;
    private double yCoord = 0.0;
    private double reliability = 1.0;
    private String qualityCode;


    public Builder (double diameter){
        this.diameter = diameter;
    }

    public Builder reliability(double val){
        reliability = val;
        return this;
    }

    public Builder qualityCode(String qualityCode){
        this.qualityCode = qualityCode;
        return this;
    }

    public Builder coordinates(double xCoord, double yCoord){
        this.xCoord = xCoord;
        this.yCoord = yCoord;
        return this;
    }

    public Reading build(){
        return new Reading(this);
    }

}

public double getXCoord() {return xCoord;}

public double getYCoord() {return yCoord;}

public String getQualityCode() {return qualityCode;}

public double getDiameter() { return diameter;}

public double getReliability() {return reliability; }

}

There are no problems marshalling this object but unmarshalling doesn't seem to be straight forward. Also is there support for leaving out entries for object values that are null?

Answer 1

you can do this: (implement only getters and use XmlAccessType.FIELD)

@XmlAccessorType(XmlAccessType.FIELD)
public class CreditCardVO implements Serializable {

  private Long ccNumber;
  private String ccName;


  public CreditCardVO(Long ccNumber, String ccName) {
   this.ccNumber = ccNumber;
   this.ccName = ccName;
  }


  private CreditCardVO() {
     // for JAXB's Magic
  }

  public Long getCcNumber() {
    return ccNumber;
  }

  public String getCcName() {
   return ccName;
  }    
}

taken from http://aniketshaligram.blogspot.com/2010/05/jaxb-immutable-objects.html

Answer 2

You can use an XmlAdapter with JAXB to handle immutable objects:

• http://bdoughan.blogspot.com/2010/12/jaxb-and-immutable-objects.html

Answer 3

To make things simple: don't go there. Only value objects should be serialized / deserialized by Jersey / Jackson, and there is no reason to make them immutable because there is (should be) no shared access to them.

I.e. each service call should generate a new Value Object that is not available to other threads. That way you don't have to worry about immutability and hence can use the standard way with getters and setters.

Don't make life unnecessarily complicated if it doesn't buy you anything!

---

Checking back in much later, I disagree with this. Today, I mostly use the Immutables library to generate value objects, and it comes with good support for standard JSON serialization.

Answer 4

If u want some marshlling/unmarshilling u can use JAXB when you want an XML output, otherwise for JSON i will prefer to add some Facades, that convert the JSON String into Objects.

and that means, every thread will have its own instance of Facade, so there will be no point of immutability and if u tend to make the Facade singleton then also there won't be any problem.

When using JSON, u can write own logic to create object, means u can use constructor or setters. Adding to above, then using Facade you will also be able to support subclasses and all under the same facade.

Answer 5

For what it is worth, there are plans (but not ready code) to support Builder style for deserialization (as per this Jira entry). Whenever it gets implemented depends on number of people working on the issue (or at least expressing interest).