How to apply a JsonView to a nested entity

Question

I have the following JsonViews defined:

public class EntityJsonView {
    public static class Detailed extends Abbreviated {
    }
    
    public static class AuditedDetailed extends Detailed {
    } 
    
    public static class Abbreviated {
        
    }
}

Then I have these classes:

public Class Customer {

@JsonView(EntityJsonView.Abbreviated.class)
private Integer id;

@JsonView(EntityJsonView.Abbreviated.class)
private String name;

@JsonView(EntityJsonView.Detailed.class)
private String phone;

@JsonView(EntityJsonView.Detailed.class)
private List<Invoice> invoices;
}

public Class Invoice {

@JsonView(EntityJsonView.Abbreviated.class)
private Integer id;

@JsonView(EntityJsonView.Detailed.class)
private Customer customer;

@JsonView(EntityJsonView.Detailed.class)
private Employee salesman;

@JsonView(EntityJsonView.Abbreviated.class)
private Date invoiceDate;

@JsonView(EntityJsonView.Abbreviated.class)
private Double amount;
}

I return my customer list like this:

@JsonView(EntityJsonView.Detailed.class)
    public ResponseEntity<List<Customer>> getCustomerList() {
        List<Customer> custs = customerService.getAll();
        return new ResponseEntity<List<Customer>>(custs , HttpStatus.OK);
}

While I want the Customer instances to be serialized using the Detailed view, I want the nested Invoice instances to be serialized using the Abbreviated view. By the same token, when I serialize a list of Invoices using the Detailed view, I want the nested Customer instances to be serialized using the Abbreviated view. This is not just a problem of recursion because there are lots of other attributes I want to remove as well.

I've searched high and low for a solution but perhaps I'm not using the right keywords.

My predecessor in this job accomplished this using @JsonIgnoreProperties but that is proving to be a maintenance problem. When a new attribute is added to a class, I have to hunt down all the ignore lists and decide if it needs to be ignored or not. It would be easier if there was a corresponding @JsonIncludeProperties.

Has anyone found a better way to accomplish this?

Answer 1

I figured out a way to sort of do this and it works for my environment. I'm posting in case someone else has a similar issue. The first step is to create a view for each of your top-level entities. In this example, those will be Foo, Bar, and Snafu. These should all inherit from an abbreviated view.

public class EntityViews {
  
 public static interface Abbr {}
    
 public static interface Foo extends Abbr {}
    
 public static interface Bar extends Abbr {}
    
 public static interface Snafu extends Abbr {}
    
 public static interface Detailed extends Foo, Bar, Snafu {}
}

I used interface because it allows multiple inheritance. All the main class views end up in the Detailed view. Now for the classes:

@JsonView(EntityViews.Foo.class)
public class Foo {

@JsonView(EntityViews.Abbr.Class)
private Integer id;

@JsonView(EntityViews.Abbr.Class)
private String name;

private String description;

private Bar bar;

}

@JsonView(EntityViews.Bar.class)
public class Bar {

@JsonView(EntityViews.Abbr.Class)
private Integer id;

@JsonView(EntityViews.Abbr.Class)
private String name;

private List<Snafu> snafus;
}

@JsonView(EntityViews.Snafu.class)
public class Snafu {

@JsonView(EntityViews.Abbr.Class)
private Integer id;

@JsonView(EntityViews.Abbr.Class)
private String name;

@JsonView(EntityViews.Bar.class, EntityViews.Snafu.class)
@JsonIgnoreProperties("parent", "children")
private Snafu parent;

@JsonIgnoreProperties("parent", "children")
private List<Snafu> children;

}

Now, let's do the endpoints:

@RestController
@RequestMapping("/api/foos")
@CrossOrigin
public class FooController {

@JsonView(EntityViews.Foo.class)
@GetMapping("/")
    public ResponseEntity<List<Foo>> get() {
        List<Foo> list = service.getAll();
        return new ResponseEntity<List<Foo>>(list, HttpStatus.OK);
    }
}

@RestController
@RequestMapping("/api/bars")
@CrossOrigin
public class BarController {

@JsonView(EntityViews.Bar.class)
@GetMapping("/")
    public ResponseEntity<List<Foo>> get() {
        List<Bar> list = service.getAll();
        return new ResponseEntity<List<Bar>>(list, HttpStatus.OK);
    }
}

@RestController
@RequestMapping("/api/snafus")
@CrossOrigin
public class SnafuController {

@JsonView(EntityViews.Snafu.class)
@GetMapping("/")
    public ResponseEntity<List<Snafu>> get() {
        List<Snafu> list = service.getAll();
        return new ResponseEntity<List<Snafu>>(list, HttpStatus.OK);
    }
}

So as we see, each controller assigns the view corresponding to the entity that is being returned. Since those views all inherit from Abbr, all other entities being returned will have the Abbr view applied to them.

Notice in the Snafu class that the parent attribute is assigned to both the Bar and Snafu views. So when you return a Bar endpoint, you will get that attribute as well as the Abbr attributes (I haven't tested this so YMMV. Will edit if it doesn't work like I think it will).

The one place this strategy breaks down is if you have attributes that are the same class as the entity. In that case, you will still have to use @JsonIgnoreProperties to control what is returned but that is a small price to pay for not having to have those on virtually every entity attribute.