JPA多对多映射

多对多映射表示集合值关联,其中任何数量的实体可以与其他实体的集合关联。 在关系数据库中,一个实体的任何行可以被引用到另一个实体的任意数量的行。

完整的项目目录结构如下所示 -

@ManyToMany 示例

在这个例子中,我们将创建学生和图书馆之间的多对多关系,以便可以为任何数量的学生发放任何类型的书籍。

这个例子包含以下步骤 -

第1步:com.yiibai.mapping包中创建一个实体类Student.java,包含学生ID(s_id)和学生姓名(s_name),其中包含一个使用@@ManyToMany注解的List类型的Library类对象。

文件:Student.java 的代码如下所示 -

package com.yiibai.mapping;

import java.util.List;

import javax.persistence.*;

@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int s_id;
    private String s_name;

    @ManyToMany(targetEntity = Library.class)
    private List lib;

    public Student(int s_id, String s_name, List lib) {
        super();
        this.s_id = s_id;
        this.s_name = s_name;
        this.lib = lib;
    }

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public List getLib() {
        return lib;
    }

    public void ListLib(List lib) {
        this.lib = lib;
    }

    public int getS_id() {
        return s_id;
    }

    public void ListS_id(int s_id) {
        this.s_id = s_id;
    }

    public String getS_name() {
        return s_name;
    }

    public void ListS_name(String s_name) {
        this.s_name = s_name;
    }
}

Java

第2步: 在包含book id(b_id)book name(b_name)@ManyToMany注释的com.yiibai.mapping包下创建另一个实体类Library.java,其中包含List类型的Student类对象。

文件:Library.java 的代码如下所示 -

package com.yiibai.mapping;

import java.util.List;

import javax.persistence.*;

@Entity
public class Library {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int b_id;
    private String b_name;

    @ManyToMany(targetEntity = Student.class)
    private List stud;

    public Library(int b_id, String b_name, List stud) {
        super();
        this.b_id = b_id;
        this.b_name = b_name;
        this.stud = stud;
    }

    public Library() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getB_id() {
        return b_id;
    }

    public void ListB_id(int b_id) {
        this.b_id = b_id;
    }

    public String getB_name() {
        return b_name;
    }

    public void ListB_name(String b_name) {
        this.b_name = b_name;
    }

    public List getStud() {
        return stud;
    }

    public void ListStud(List stud) {
        this.stud = stud;
    }

}

Java

第3步: 将实体类和其他数据库配置映射到persistence.xml文件中。

文件:persistence.xml 的代码如下所示 -

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
    xmlns="http://xmlns.jcp.org/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <persistence-unit name="book_issued">
        <class>com.yiibai.mapping.Student</class>
        <class>com.yiibai.mapping.Library</class>
        <properties>
            <property name="javax.persistence.jdbc.driver"
                value="com.mysql.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url"
                value="jdbc:mysql://localhost:3306/testdb?serverTimezone=UTC" />
            <property name="javax.persistence.jdbc.user" value="root" />
            <property name="javax.persistence.jdbc.password"
                value="123456" />
            <property name="eclipselink.logging.level" value="SEVERE" />
            <property name="eclipselink.ddl-generation"
                value="create-or-extend-tables" />
        </properties>
    </persistence-unit>

</persistence>

XML

com.yiibai.mapping包下创建一个持久化类ManyToManyExample,用于将实体对象与数据保持一致。

文件:ManyToManyExample.java 的代码如下所示 -

package com.yiibai.mapping;

import java.util.ArrayList;

import javax.persistence.*;
import com.yiibai.mapping.Student;
import com.yiibai.mapping.Library;

public class ManyToManyExample {

    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("books_issued");
        EntityManager em = emf.createEntityManager();

        em.getTransaction().begin();

        Student st1 = new Student(1, "Maxsu", null);
        Student st2 = new Student(2, "Xiaonew", null);

        em.persist(st1);
        em.persist(st2);

        ArrayList<Student> al1 = new ArrayList<Student>();
        ArrayList<Student> al2 = new ArrayList<Student>();

        al1.add(st1);
        al1.add(st2);

        al2.add(st1);
        al2.add(st2);

        Library lib1 = new Library(101, "Data Structure", al1);
        Library lib2 = new Library(102, "DBMS", al2);

        em.persist(lib1);
        em.persist(lib2);

        em.getTransaction().commit();
        em.close();
        emf.close();

    }

}

Java

程序输出结果

程序执行完成后,下面的表格在MySQL工作台下生成。

  • Student表 - 此表包含学生详细信息。要获取数据,请在MySQL中运行select * from student查询。结果如下所示 -
mysql> select * from student;
+------+---------+
| S_ID | S_NAME  |
+------+---------+
|    2 | Xiaonew |
|    1 | Maxsu   |
+------+---------+
2 rows in set

Shell

  • Library表 - 这个表格代表学生和图书库之间的映射。 要获取数据,请在MySQL中运行select * from library查询。结果如下所示 -
mysql> select * from library;
+------+----------------+
| B_ID | B_NAME         |
+------+----------------+
|  102 | DBMS           |
|  101 | Data Structure |
+------+----------------+
2 rows in set

Shell

  • Library_student表 - 此表包含库的详细信息。要获取数据,请在MySQL中运行select * from library_student查询。
mysql> select * from library_student;
+--------------+-----------+
| Library_B_ID | stud_S_ID |
+--------------+-----------+
|          101 |         1 |
|          101 |         2 |
|          102 |         1 |
|          102 |         2 |
+--------------+-----------+
4 rows in set

原文地址:https://www.cnblogs.com/borter/p/12423969.html

时间: 2024-10-17 08:55:04

JPA多对多映射的相关文章

JPA实体关联关系映射之概述

一.简介 首先来说关联关系是面向对象分析,面向对象设计最重要的部分,JPA是完全可以通过映射来简化数据持久化到数据,和Hibernate一样,JPA的关联关系也分为两种,一种是单向关联,一种是双向关联: 单向关联:只需要单向访问关联端,比如说:我们只能通过某一学期访问这学期的课程,而不能通过课程访问课程所属的学期,这种关联关系就是单向关联. 双向关联:关联的两端可以互相访问.比说说班级可以访问学生,学生也可以访问班级,这种关联关系就是双向关联. 关联关系可以分为如下几种: 单向:1-1:1-N;

【Hibernate步步为营】--多对多映射具体解释

上篇文章具体讨论了一对多映射,在一对多映射中单向的关联映射会有非常多问题,所以不建议使用假设非要採用一对多的映射的话能够考虑使用双向关联来优化之间的关系,一对多的映射事实上质上是在一的一端使用<many-to-one>标签来标明它们之间的关系,另外还须要在一的一端的对象中使用set标明集合映射. 一.单向多对多 仍然依照前几篇的文章格式来讨论.首先来看对象之间的关系,单向的多对多关系是两个对象之间发生的,比方在人和职位之间,一个人能够有多个职位,并且一个职位也能够由多人来负责,所以它们之间就形

Hibernate中的一对多、多对多映射

一.一对多映射  如快递网点(ExpSite)与快递员(Deliver)的关系,即为一对多关系,一个快递网点有多个快递员,他们的关系如下图所示. 在一对多中,外键在多的一方 (1)在多的一方配置外键 Deliver表为多方,在Deliver实体类中放一个ExpSite方的引用做属性(外键),即所属网点ExpSiteId; Deliver实体类配置文件: <many-to-one name="ExpSiteId" class="ExpSite表所在的包名+ExpSite表

iptables 做网关共享上网IP多对多映射

iptables做网关共享上网IP多对多映射 iptables -t nat -A POSTROUTING -s 10.0.0.0/255.255.240 -o eth0 -j SNAT --to-source 124.42.60.118-124.42.60.162    #这样的话就有了五个外网IP ,是负载均衡的 如果全映射成一个外网IP,容易被封且一个IP的端口是有限的,65535个端口

【SSH高速进阶】——Hibernate 多对多映射

说到多对多关系.印象最深刻的就是大学的选修课.一个学生能够选修多门课程,一门课程能够有多个学生选修,学生所选的每一门课程还有成绩. 这个场景的E-R图例如以下: 对于多对多的关系,我们一般会抽出一张中间表(连接表),来负责维护这两张表的多对多关系.比方上述关系应该生成的表结构为: PO对象 Student.java public class Student { private int id; private String name; private Set<Course> courses; /

Mybatis(四) 高级映射,一对一,一对多,多对多映射

天气甚好,怎能不学习? 一.单向和双向 包括一对一,一对多,多对多这三种情况,但是每一种又分为单向和双向,在hibernate中我们就详细解析过这单向和双向是啥意思,在这里,在重复一遍,就拿一对多这种关系来讲,比如有员工和部门,一个部门中有多个员工,从部门方看,是一对多关系,而多名员工属于一个部门,是多对一关系,那么如果我们的业务需求只需要通过部门查找到所有的员工,那么我们就只需要进行单向一对多的映射,如果我们需要通过员工来查询出对应的部门,那么我们就需要进行单向多对一的映射,而如果我们这两个业

Hibernate中的一对多与多对一映射

1.需求 一个部门有多个员工;         [一对多] 多个员工,属于一个部门    [多对一] 2.实体Bean设计 Dept: public class Dept { private int depId; private String depName; private Set<Employee> emps = new HashSet<Employee>(); set... get... } Employee: public class Employee { private

(08)Hibernate的多对多映射配置

基本需求是:一个项目可以有多个开发人员,一个开发人员可以参加多个项目,因此项目和开发人员是多对多的关系.本文中的学习重点,还和前几篇文章一样,都是JavaBean类的映射文件中的配置. 1.多对多映射 Project.java package com.rk.hibernate.h_many2many; import java.util.Set; public class Project { private int prjId; private String prjName; private Se

Hibernate的多对一映射

一.创建Java工程,新建Lib文件夹,加入Hibernate和数据库(如MySql.Oracle.SqlServer等)的Jar包,创建 hibernate.cfg.xml 文件,并配置,配置项如下: 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE hibernate-configuration PUBLIC 3 "-//Hibernate/Hibernate Configura