Mapping JSON object to Hibernate entity

We were using such approach to simplify design and get rid of many dtos (we were abusing them too much). Basically, it worked for us.

However, in our REST model we were trying to do not expose other relations for an object as you can always create another REST resources to access them.

So we just put @JsonIgnore annotations to relations mappings like @OneToMany or @ManyToOnemaking them transient.

Another problem I see that if you still like to return these relations you would have to use Join.FETCH strategy for them or move transaction management higher so that transaction still exists when a response is serialized to JSON (Open Session In View Pattern). On my opinion these two solutions are not so good.

You can map the json request without using any library at REST web-services (Jersy)
this sample of code:

This hibernate entity called book:

@Entity
@Table(name = "book", schema = "cashcall")
public class Book implements java.io.Serializable {
   private int id;
   private Author author; // another hibernate entity 
   private String bookName;

   //setters and getters
}

This web-services function

@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public String addBook(Book book) {
    String bookName=book.getName();
    return bookName;
}

This is sample json request:

{
  "bookName" : "Head First Java",
  "author" : {
    "id" : 1
   }
}  

Maven dependency

The first thing you need to do is to set up the following Hibernate Types Maven dependency in your project pom.xml configuration file:

<dependency>
    <groupId>com.vladmihalcea</groupId>
    <artifactId>hibernate-types-52</artifactId>
    <version>${hibernate-types.version}</version>
</dependency>

Domain model

Now, if you are using PostgreSQL, you need to use the JsonType from Hibernate Types.

In order to use it in your entities, you will have to declare it on either class level or in a package-info.java package-level descriptor, like this:

@TypeDef(name = "json", typeClass = JsonType.class)

And, the entity mapping will look like this:

@Type(type = "json")
@Column(columnDefinition = "json")
private Location location;

If you're using Hibernate 5 or later, then the JSON type is registered automatically by the Postgre92Dialect.

Otherwise, you need to register it yourself:

public class PostgreSQLDialect extends PostgreSQL91Dialect {

    public PostgreSQL92Dialect() {
        super();
        this.registerColumnType( Types.JAVA_OBJECT, "json" );
    }
}

The JsonType works with Oracle, SQL Server, PostgreSQL, MySQL, and H2 as well. Check out the project page for more details about how you can map JSON column types on various relational database systems.

Yes, this wouldn't be a problem and is actually a fairly common practice.

In the recent years I have come to realize that sometimes, however, it is not a good idea to always build your views based on your domain directly. You can take a look at this post:

http://codebetter.com/jpboodhoo/2007/09/27/screen-bound-dto-s/

It is also known as "Presentation Model":

http://martinfowler.com/eaaDev/PresentationModel.html

The idea behind that is basically the following:

Imagine you have the domain entry User, who looks like that :

@Entity
@Data
public class User {
     @Id private UUID userId;
     private String username;
     @OneToMany private List<Permission> permissions;
}

Let's now imagine you have a view where you wanna display that user's name, and you totally don't care about the permissions. If you use your approach of immediately returning the User to the view, Hibernate will make an additional join from the Permissions table because event though the permissions are lazily loaded by default, there is no easy way to signal to the jackson serializer or whatever you are using, that you don't care about them in this particular occasion, so jackson will try to unproxy them (if your transaction is still alive by the time your object is put for json serialization, otherwise you get a nasty exception). Yes, you can add a @JsonIgnore annotation on the permissions field, but then if you need it in some other view, you are screwed.

That a very basic example, but you should get the idea that sometimes your domain model can't be immediately used to be returned to the presentation layer, due to both code maintainability and performance issues.