Java Persistence API (JPA) is a standard for persisting data in Java applications. It provides annotations and interfaces to manage relational data in an object-oriented way. This article will guide you through using JPA to persist data and configure relationships such as One-to-One, One-to-Many, and Many-to-Many.
To use JPA, you need to include a JPA implementation such as Hibernate or EclipseLink in your project. Below is an example of setting up Hibernate with Maven:
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.6.0.Final</version>
</dependency>
Also, configure the persistence.xml file:
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.1">
<persistence-unit name="examplePU">
<properties>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa_example"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="password"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>
JPA uses the @Entity annotation to define a class as an entity. Below is an example of an entity class:
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
private double price;
// Getters and setters
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
To persist an object, use the EntityManager:
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class MainApp {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("examplePU");
EntityManager em = emf.createEntityManager();
Product product = new Product();
product.setName("Laptop");
product.setPrice(1200.00);
em.getTransaction().begin();
em.persist(product);
em.getTransaction().commit();
em.close();
emf.close();
}
}
JPA allows you to define relationships between entities using annotations such as @OneToOne, @OneToMany, and @ManyToMany.
A one-to-one relationship connects one entity to another. For example, a `User` may have one `Profile`:
import javax.persistence.*;
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String username;
@OneToOne(cascade = CascadeType.ALL)
private Profile profile;
// Getters and setters
// ...
}
@Entity
public class Profile {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String bio;
// Getters and setters
// ...
}
A one-to-many relationship connects one entity to multiple others. For example, a `Department` may have multiple `Employees`:
@Entity
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
private List employees;
// Getters and setters
// ...
}
@Entity
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@ManyToOne
private Department department;
// Getters and setters
// ...
}
A many-to-many relationship connects multiple entities to each other. For example, `Student` and `Course`:
@Entity
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@ManyToMany
@JoinTable(
name = "student_course",
joinColumns = @JoinColumn(name = "student_id"),
inverseJoinColumns = @JoinColumn(name = "course_id")
)
private List courses;
// Getters and setters
// ...
}
@Entity
public class Course {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String title;
@ManyToMany(mappedBy = "courses")
private List students;
// Getters and setters
// ...
}
JPA simplifies data persistence and management of relationships in Java applications. By using annotations like @OneToOne, @OneToMany, and @ManyToMany, developers can model complex relational structures effectively. JPA's abstraction over SQL helps maintain a clean and modular application architecture.