Jackson JSON serialization of JPA Entities - jackson

Question

I have a JPA persistence layer with many #Entity classes which have many OneToMany and ManyToMany relationships.
I want to expose that entities by RestEasy with Jackson2 as serializer to JSON as REST services.
I know about #JsonIdentityInfo for resolving circular references.
The problem is in different REST services I need to expose different subsets of Entity fields. Moreover I need to expose different levels of depts for collections (OneToMany, OneToOne etc).
For example for this simple Entities:
class User {
Long id;
String name;
Company company;
}
class Company {
Long id;
String name;
List<User> users;
List<Product> products;
}
class Product {
Long id;
String name;
List<User> users;
}
and this REST service:
class MyResource {
User getUser() { //... }
List<User> getUsers() { //... }
Company getCompany() { //... }
List<Company> getComanies() { //... }
}
In method getUser() I need to return JSON with full User object including inner Company object. But that company of course only need to include their id and name field and not full list of users. Even more important that inner Company JSON must not include products! It is logical. If we get the user we don't need products of company that related to this user. If we need them we will send another REST request.
But in method getCompany() I need to return JSON with full Company object including inner JSON arrays of User and Product objects. Of course this time that User objects doesn't need to include inner JSON for Company object.
For this reason I can't use #JsonIgnore. In one case we need some field and in another we doesn't.
Now I came up with approach of using Jackson views (#JsonView annotation). I have View class with different views for every MyResource getter.
public class Views {
public static class User {}
public static class Users {}
public static class Company {}
public static class Companies {}
// etc...
}
and MyResoruce class as
class MyResource {
#JsonView(Views.User.class)
User getUser() { //... }
#JsonView(Views.Users.class)
List<User> getUsers() { //... }
#JsonView(Views.Company.class)
Company getCompany() { //... }
#JsonView(Views.Companies.class)
List<Company> getComanies() { //... }
}
and have a MixIn classes for every Entity with every field annotated as
public abstract class UserMixIn {
#JsonView({ Views.User.class, Views.Users.class, Views.Company.class, Views.Companies.class })
public abstract Long getId();
#JsonView({ Views.User.class, Views.Users.class, Views.Company.class, Views.Companies.class })
public abstract String getName();
#JsonView({ Views.User.class, Views.Users.class })
public abstract Company getCompany();
}
public abstract class CompanyMixIn {
#JsonView({ Views.Company.class, Views.Companies.class, Views.User.class, Views.Users.class })
public abstract Long getId();
#JsonView({ Views.Company.class, Views.Companies.class, Views.User.class, Views.Users.class })
public abstract String getName();
#JsonView({ Views.Company.class, Views.Companies.class })
public abstract List<User> getUsers();
#JsonView({ Views.Company.class, Views.Companies.class })
public abstract List<Product> getProducts();
}
public abstract class ProductMixIn {
#JsonView({ Views.Company.class, Views.Companies.class })
public abstract Long getId();
#JsonView({ Views.Company.class, Views.Companies.class })
public abstract String getName();
public abstract List<User> getUsers();
}
Plurals for support cases where getUsers() doesn't need full inner Company object for every user (performance).
Of course there are just example classes. Real classes are much bigger and complex.
I do not like this approach because I am afraid that in the future it can be a nightmare (too many not manageable views). Maybe there are common approach for exposing JPA Entities as REST services? I believe it is a fairly common task. But can not find any intelligible information on how others doing this. Maybe some best practices.

Answer 1

Your service layer (and your REST controller layer) must expose DTOs (Data transfer objects) instead of #Entity objects.
Example :
For a Service 1 (which focus on User managment) :
public class UserDto {
private Long id;
private String name;
private CompanyDtoLight company;
}
public class CompanyDtoLight {
private Long id;
private String name;
}
For a Service 2 (which focus on Company managment) :
public class CompanyDto {
private Long id;
private String name;
List<UserDtoLight > users;
List<ProductDtoLight > products;
}
public class UserDtoLight {
private Long id;
private String name;
}
class ProductDtoLight {
private Long id;
private String name;
}
(The naming of your DTOs is yours)
How to :
You will need Mappers to transfom and reverse your #Entity to DTOs. Some lib exist like Dozer or MapStruct (there are plenty of other).