JPA is a Java persistence specification, and Hibernate is its commonly used implementation. 1. JPA defines object and database mapping standards, and Hibernate is responsible for specific operations. 2. Entity classes map table structures through @Entity, @Table, @Id, @GeneratedValue, etc. 3. The association relationship is processed through annotations such as @OneToMany, @ManyToOne, etc., and pay attention to mappedBy and cascading configuration. 4. In Spring Boot, you can quickly complete persistence operations by configuring data sources and using Spring Data JPA.

When you are using Java for persistent data storage, JPA and Hibernate are almost unavoidable tools. They help you handle things between objects and database tables more naturally and efficiently. But if you want to use it well, it is not just as simple as adding a few annotations.

What are JPA and Hibernate?

Simply put, JPA (Java Persistence API) is a specification that defines the standard way in which Java objects map to database tables. Hibernate is an implementation of this specification, and it is the most commonly used one.

You can understand it as the relationship between "interface" and "implementation class". When you write code, you are programming in JPA, and Hibernate performs operations in the underlying layer. The advantage of this is that if the ORM framework is replaced in the future, the changes will not be too big.

Mapping of entity classes and database tables

This is the first step in persistence: turn the Java class into a table in the database. What you need to do is:

• Add @Entity annotation to the class
• Specify the corresponding table name, for example @Table(name = "users")
• Annotate the primary key field as @Id , if it is an auto-increment primary key, add @GeneratedValue

For example:

 @Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // getters and setters
}

In this way, Hibernate knows how to operate this table.

Note: By default, Hibernate will convert the field name into an underscore naming method (such as userName to user_name ). If you don't want it to automatically convert, you can turn it off in the configuration or specify it explicitly with @Column(name = "username") .

How to deal with the relationship?

In real projects, data is not isolated, and one-to-many, many-to-one, and many-to-many relationships are often processed. Take the most common "users and orders" as an example:

A user can have multiple orders, so User and Order are one-to-many relationships. At this time, you can write it in the User class like this:

 @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Order> orders = new ArrayList<>();

Then add the reference back to the Order class:

 @ManyToOne
@JoinColumn(name = "user_id")
private User user;

Here are a few points to note:

• mappedBy means that this end is passively maintaining the relationship, and the real controller is Order.
• cascade controls cascade operations, such as automatically saving Orders when saving User
• fetch = FetchType.LAZY is for performance considerations. The associated data is not loaded by default and loaded on demand.

If you accidentally reverse the relationship maintenance direction, it may cause the data to not be updated or the null pointer exception will occur.

Configuration files and basic usage procedures

In Spring Boot project, you only need to assign database connection information in application.properties or application.yml , and leave the rest to Spring Data JPA.

for example:

 spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.hibernate.ddl-auto=update

Among them, ddl-auto=update is very practical, which means that the table structure is automatically updated according to the entity class structure. But be careful not to use it instead of database migration tools in production environments.

It's also very easy to use:

• Define the Repository interface inherits JpaRepository
• Then just call save() , findById() , findAll() and other methods

 public interface UserRepository extends JpaRepository<User, Long> {
}

Basically that's it.

The above is the detailed content of Persistent Data Storage using Java JPA and Hibernate. For more information, please follow other related articles on the PHP Chinese website!