Hibernate's one-to-many and many-to-many

Hibernate is an excellent ORM framework that simplifies data access between Java applications and relational databases. In Hibernate, complex data models can be handled using one-to-many and many-to-many relationships.

Hibernate's one-to-many

In Hibernate, one entity class corresponding to multiple other entity classes is called a one-to-many relationship. For example, an order can correspond to multiple order items (OrderItem), and a user (User) can correspond to multiple orders (Order). To implement a one-to-many relationship in Hibernate, you need to define a collection attribute in the entity class to store multiple associated objects, and configure the association in the mapping file.

Hibernate's one-to-many configuration

In the entity class, we need to define a collection attribute to store multiple associated objects, as shown below:

public class Order {
    private Long id;
    private Date orderDate;
    private List<OrderItem> items = new ArrayList<OrderItem>();
    // getters and setters
}

In the mapping file , we need to use the <set> tag to configure the collection attributes and relationships, as shown below:

<class name="Order" table="orders">
    <id name="id" column="id">
        <generator class="native"/>
    </id>
    <property name="orderDate" column="order_date"/>
    <set name="items" table="order_items" inverse="true" cascade="all">
        <key column="order_id"/>
        <one-to-many class="OrderItem"/>
    </set>
</class>

Among them, the <set> tag The name attribute corresponds to the collection attribute name in the entity class, the table attribute corresponds to the name of the association table, the inverse attribute indicates whether to hand over the association relationship to the collection attribute maintenance, The cascade attribute represents a cascade operation, the <key> tag is used to specify the foreign key column in the associated table, the <one-to-many> tag Used to specify the associated entity class.

Hibernate's one-to-many operation

In Hibernate, we can access associated objects through collection properties. For example, we can get all the order items of an order through the getItems() method, and add an order item to the order through the addItem(item) method, as shown below:

Order order = session.get(Order.class, orderId);
List<OrderItem> items = order.getItems();
OrderItem item = new OrderItem();
// set item properties
order.addItem(item);

Hibernate's one-to-many relationship can solve many complex data models in practical problems. For example, in an e-commerce website, an order (Order) may contain multiple order items (OrderItem), and an order item may Contains multiple product information (Product).

Hibernate's many-to-many

The many-to-many relationship in Hibernate represents the correlation between multiple entity classes. For example, a student can take multiple courses, and a course can be taken by multiple students. To implement a many-to-many relationship in Hibernate, you need to define a collection attribute in the entity class to store multiple associated objects, and configure the association in the mapping file.

Hibernate's many-to-many configuration

In the entity class, we need to define a collection attribute to store multiple associated objects, as shown below:

public class Student {
    private Long id;
    private String name;
    private List<Course> courses = new ArrayList<Course>();
    // getters and setters
}

In the mapping file , we need to use the <set> tag to configure the collection attributes and relationships, as shown below:

<class name="Student" table="students">
    <id name="id" column="id">
        <generator class="native"/>
    </id>
    <property name="name" column="name"/>
    <set name="courses" table="student_courses">
        <key column="student_id"/>
        <many-to-many column="course_id" class="Course"/>
    </set>
</class>

Among them, the <set> tag The name attribute corresponds to the collection attribute name in the entity class, the table attribute corresponds to the name of the associated table, and the <key> tag is used to specify the external key in the associated table. Key column, <many-to-many> tag is used to specify the associated entity class.

Hibernate's many-to-many operation

In Hibernate, we can access associated objects through collection properties. For example, we can get all the courses taken by a student through the getCourses() method, and add a course to the student through the addCourse(course) method, as shown below:

Student student = session.get(Student.class, studentId);
List<Course> courses = student.getCourses();
Course course = new Course();
// set course properties
student.addCourse(course);

Hibernate's many-to-many relationship can solve many complex data models in practical problems. For example, in a school, a student (Student) can take multiple courses (Course), and a course (Course) can also be used by multiple courses. Elective for students.

Hibernate's cascade operation

In Hibernate, we can simplify database operations by configuring cascade operations. For example, we can configure the cascade attribute in the mapping file to implement cascade operations, as shown below:

<set name="items" table="order_items" inverse="true" cascade="all">

Among them, the cascade attribute can be set to Values ??such as all, save-update, delete, delete-orphan, respectively represent all operations, save and update operations, delete operations, and delete orphans. Operation etc.

Hibernate's cascade operation can greatly simplify the amount of code and improve development efficiency.

Hibernate's lazy loading

In Hibernate, we can use lazy loading to improve database access performance. For example, we can configure the lazy attribute in the mapping file to implement lazy loading, as shown below:

<set name="items" table="order_items" inverse="true" cascade="all" lazy="true">

Among them, the lazy attribute can be set to true or false means enabling lazy loading and immediate loading respectively.

Hibernate's lazy loading can greatly improve database access performance and reduce unnecessary database operations.

Hibernate query

In Hibernate, we can use HQL (Hibernate Query Language) to query the database. HQL is similar to SQL, but it is an object-oriented query language that uses the concepts of objects and attributes instead of tables and columns.

For example, we can use HQL to query all courses taken by a student, as shown below:

String hql = "from Course as c where c.id in (select sc.course.id from StudentCourse as sc where sc.student.id = :studentId)";
Query query = session.createQuery(hql);
query.setParameter("studentId", studentId);
List<Course> courses = query.list();

Hibernate的查詢功能非常強大，可以靈活地滿足不同的查詢需求。

The above is the detailed content of What is the mapping method of one-to-many and many-to-many relationships in Java Hibernate. For more information, please follow other related articles on the PHP Chinese website!