Relation between JPA and Hibernate annotation

Question

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

so JPA provide me something like interfaces or abstract classes that are implemented by Hibernate? — AndreaNobili, Feb 23 '13 at 12:38

score 25 · Accepted Answer · answered Feb 23 '13 at 12:45

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).

+1, although the last part is incorrect. Even if you use Hibernate with its proprietary API, you'll have to use JPA annotations. Hibernate doesn't reimplement the JPA annotations. — JB Nizet, Feb 23 '13 at 12:56
"you will need no changes to your program" - I wonder if anyone has ever found that to be 100% true. :) +1 for the answer. — Alex Barnes, Feb 23 '13 at 15:22

score 8 · Answer 2 · answered Feb 23 '13 at 12:38

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.

score 0 · Answer 3 · answered Feb 12 '19 at 05:41

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

Relation between JPA and Hibernate annotation

3 Answers3

Linked