CODEWITHSUNDEEP
javaspringhibernatejpaspring-mvc
AndreaNobili
AndreaNobili

Reputation: 42957

Relation between JPA and Hibernate annotation

I am quite new in Spring world and I am studying how to integrate Hibernate and Spring framework

i have some dount about the relation beetween Hibernate annotation and JPA annotation.

Whene I have something like the following entity class:

package org.andrea.myexample.HibernateOnSpring.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;


/* Classe che rappresenta un oggetto da persistere sul database
 * 
 */
@Entity
@Table(name="person")
public class Person {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int pid;

    private String firstname;

    private String lastname;

    public int getPid() {
        return pid;
    }

    public void setPid(int pid) {
        this.pid = pid;
    }

    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;
    }
}

The thing that I am not understanding is what is the relationship between Hibernate annotation and JPA annotation

The annotation @Entity, @Table(name="person"), @GeneratedValue(strategy=GenerationType.AUTO) and id using in the previous example are simple JPA annotation or specific annotation for Hibernate?

if I'm using JPA annotations to persist the data to the database, what's giving me Hibernate?

Tnx

Andrea

Upvotes: 9

Views: 9723

Answers (3)

thomas77
thomas77

Reputation: 1150

Like @SJuan76 is saying, JPA (Java Persistence API) is a specification and Hibernate is one implementation. I agree with the others; stick to using plain JPA as much as you can. The JPA specification doesn't change very often, and when it does it is usually backward compatible. This means that your code will be protected from changes in the implementation. You are for example free to upgrade your Hibernate dependencies if your code don't depend on anything from org.hibernate.* but rather javax.persistence.*.

Btw. JPA is in version 2.2 as of Hibernate 5.3. Read more about JPA here

Upvotes: 0

SJuan76
SJuan76

Reputation: 24780

The answer is mixed.

As others have pointed out, JPA is an specification an Hibernate provides an implementation. You use JPA annotations/API and, by including Hibernate jars in your classpath, Hibernate will provide the actual logic.

Additionally, Hibernate offers an API that is unrelated to JPA. You can use that as well; the main difference is:

  • if you use the JPA API, you may later replace Hibernate by other JPA implementation (v.g. EclipseLink) and you will need no changes to your program

  • if you use directly Hibernate API, you have no implementation alternatives. The advantage may be that you can use features that Hibernate has defined but that are not part of JPA standard, which might be usefult to you.

At any rate, what you should completely avoid is mixing JPA with the Hibernate API. As a beginner, I would advice you to stick to JPA.

To ensure that you are using JPA, only include classes/annotations from java.persistence. Do not include anything from org.hibernate (or, if you want just to use Hibernate, do just the opposite).

Upvotes: 26

JB Nizet
JB Nizet

Reputation: 691625

Hibernate is an implementation of the JPA specification. JPA is just a specification, and a set of annotations and interfaces. You need an implementation of JPA to use it, and Hibernate is one of them. Just like to use JDBC, you need a database driver.

The package of the annotation is javax.persistence, so they're JPA annotations. Hibernate annotations are in the package org.hibernate.xxx.

Upvotes: 9

Related Questions