hibernate中List一对多映射关系详解

场景:一个Team对一个多个Student,其中Team中的studes属性为List类型

直接上代码,测试通过的:

Team.java

 

Java代码
  1. package com.fgh.hibernate;  
  2. import java.util.ArrayList;  
  3. import java.util.List;  
  4. /** 
  5.  * 一的一方 
  6.  * @author fgh 
  7.  * 
  8.  */  
  9. @SuppressWarnings("unchecked")  
  10. public class Team {  
  11.     private String id;  
  12.     private String name;  
  13.     private List students = new ArrayList();  
  14.     public String getId() {  
  15.         return id;  
  16.     }  
  17.     public void setId(String id) {  
  18.         this.id = id;  
  19.     }  
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26.     public List getStudents() {  
  27.         return students;  
  28.     }  
  29.     public void setStudents(List students) {  
  30.         this.students = students;  
  31.     }  
  32. }  

Studeng.java

 

Java代码
  1. package com.fgh.hibernate;  
  2. /** 
  3.  * 多的一方 
  4.  * @author fgh 
  5.  * 
  6.  */  
  7. public class Student {  
  8.     private String id;  
  9.     private String cardId;  
  10.     private String name;  
  11.     private int age;  
  12.     private Team team;  
  13.     public String getId() {  
  14.         return id;  
  15.     }  
  16.     public void setId(String id) {  
  17.         this.id = id;  
  18.     }  
  19.     public String getCardId() {  
  20.         return cardId;  
  21.     }  
  22.     public void setCardId(String cardId) {  
  23.         this.cardId = cardId;  
  24.     }  
  25.     public String getName() {  
  26.         return name;  
  27.     }  
  28.     public void setName(String name) {  
  29.         this.name = name;  
  30.     }  
  31.     public int getAge() {  
  32.         return age;  
  33.     }  
  34.     public void setAge(int age) {  
  35.         this.age = age;  
  36.     }  
  37.     public Team getTeam() {  
  38.         return team;  
  39.     }  
  40.     public void setTeam(Team team) {  
  41.         this.team = team;  
  42.     }  
  43. }  

以下三个配置文件均放在src根目录下:

hibernate主配置文件:

hibernate.cfg.xml

 

Html代码
  1. <?xml version='1.0' encoding='UTF-8'?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  5. <!-- Generated by MyEclipse Hibernate Tools.                   -->  
  6. <hibernate-configuration>  
  7.     <session-factory>  
  8.         <property name="connection.url">  
  9.             jdbc:mysql://localhost:3306/hibernate  
  10.         </property>  
  11.         <property name="connection.username">root</property>  
  12.         <property name="connection.password">root</property>  
  13.         <property name="connection.driver_class">  
  14.             com.mysql.jdbc.Driver  
  15.         </property>  
  16.         <property name="dialect">  
  17.             org.hibernate.dialect.MySQLDialect  
  18.         </property>  
  19.         <property name="show_sql">true</property>  
  20.         <!-- 引入两个相关配置文件 -->  
  21.         <mapping resource="Team.hbm.xml" />  
  22.         <mapping resource="Student.hbm.xml" />  
  23.     </session-factory>  
  24. </hibernate-configuration>  

一方配置文件: Team.hbm.xml

 

 

Html代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.fgh.hibernate.Team" table="team_list">  
  7.         <!-- 采用uuid生成主键 这里要指定type为string类型 -->  
  8.         <id name="id" column="id" type="string">  
  9.             <generator class="uuid"></generator>  
  10.         </id>  
  11.         <!-- 像类似这样的name属性 都是指类里面的成员变量 column指数据库中对应的字段名-->  
  12.         <property name="name" column="name" type="string"></property>  
  13.         <!-- 设置级联为 cascade="all"-->  
  14.         <list name="students" table="student_list" cascade="all">  
  15.             <!-- 维护对方的外键 -->  
  16.             <key column="team_id"></key>  
  17.             <!-- index标签表示多的一方 对应一的一方的索引位置   
  18.                 column属性表示数据库中存放数据的字段  
  19.                 index为关键字 避免跟关键字冲突 使用`index` 或 [index]  
  20.             -->  
  21.             <index column="[index]" type="string"></index>  
  22.             <!-- 建立一对多的关联 -->  
  23.             <one-to-many class="com.fgh.hibernate.Student" />  
  24.         </list>  
  25.     </class>  
  26. </hibernate-mapping>  

多方配置文件 : Studeng.hbm.xml

 

Html代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.fgh.hibernate.Student" table="student_list">  
  7.         <id name="id" column="id" type="string">  
  8.             <generator class="uuid"></generator>  
  9.         </id>  
  10.         <property name="cardId" column="card_id" type="string"></property>  
  11.         <property name="name" column="name" type="string"></property>  
  12.         <property name="age" column="age" type="int"></property>  
  13.         <!-- 因为list中的value 不是原始类型 所以要指定其类型 -->  
  14.         <!-- 建立多对一关联映射关系 column="team_id"表示team这张表通过该字段  
  15.              和student表关联 -->  
  16.         <many-to-one name="team" column="team_id"  
  17.             class="com.fgh.hibernate.Team">  
  18.         </many-to-one>  
  19.     </class>  
  20. </hibernate-mapping>  

 

根据以上三个配置文件,可以生成对应的数据库表,代码如下:

CreateTable.java

 

Java代码
  1. package com.fgh.hibernate;  
  2. import org.hibernate.cfg.Configuration;  
  3. import org.hibernate.tool.hbm2ddl.SchemaExport;  
  4. /** 
  5.  * 根据.hbm.xml配置文件创建相应的数据库表 
  6.  * @author fgh 
  7.  * 
  8.  */  
  9. public class CreateTable {  
  10.     public static void main(String[] args) {  
  11.         SchemaExport export = new SchemaExport(new Configuration().configure());  
  12.         // 第一个参数表示是否在控制台打印出DDL语句(print the DDL to the console)  
  13.         // 第二个参数表示是否将脚本输出到数据库(export the script to the database)  
  14.         export.create(truetrue);  
  15.     }  
  16. }  

 

 

运行CreateTable.java 生成对应表,后台打印sql如下:

 

Sql代码
  1. alter table student_list drop foreign key FKFEDE142211CB0B6A  
  2. drop table if exists student_list  
  3. drop table if exists team_list  
  4. create table student_list (id varchar(255) not null, card_id varchar(255), name varchar(255), age integer, team_id varchar(255), `indexintegerprimary key (id))  
  5. create table team_list (id varchar(255) not nullname varchar(255), primary key (id))  
  6. alter table student_list add index FKFEDE142211CB0B6A (team_id), add constraint FKFEDE142211CB0B6A foreign key (team_id) references team_list (id)  

 

ok,表已经创建成功,下面测试保存操作:

InsertTest.java

 

Java代码
  1. package com.fgh.hibernate;  
  2. import org.hibernate.Session;  
  3. import org.hibernate.SessionFactory;  
  4. import org.hibernate.Transaction;  
  5. import org.hibernate.cfg.Configuration;  
  6. /** 
  7.  * 保存操作测试类 
  8.  * @author fgh 
  9.  * 
  10.  */  
  11. public class InsertTest {  
  12.     private static SessionFactory sessionFactory;  
  13.     //创建工厂实例  
  14.     static {  
  15.         try {  
  16.             sessionFactory = new Configuration().configure()  
  17.                     .buildSessionFactory();  
  18.         } catch (Exception e) {  
  19.             e.printStackTrace();  
  20.         }  
  21.     }  
  22.     @SuppressWarnings("unchecked")  
  23.     public static void main(String[] args) {  
  24.         Session session = sessionFactory.openSession();  
  25.         Transaction tx = null;  
  26.         try {  
  27.             //创建两个team  
  28.             Team team = new Team();  
  29.             team.setName("team1");  
  30.             Team team2 = new Team();  
  31.             team2.setName("team2");  
  32.             //创建6个student对象  
  33.             Student student = new Student();  
  34.             student.setAge(20);  
  35.             student.setName("zhangsan");  
  36.             student.setTeam(team);  
  37.             Student student2 = new Student();  
  38.             student2.setAge(24);  
  39.             student2.setName("lisi");  
  40.             student2.setTeam(team);  
  41.             Student student3 = new Student();  
  42.             student3.setAge(24);  
  43.             student3.setName("student3");  
  44.             student3.setTeam(team2);  
  45.             Student student4 = new Student();  
  46.             student4.setAge(24);  
  47.             student4.setName("student4");  
  48.             student4.setTeam(team2);  
  49.             Student student5 = new Student();  
  50.             student5.setAge(24);  
  51.             student5.setName("student5");  
  52.             student5.setTeam(team2);  
  53.               
  54.             //前两个student属于team  
  55.             team.getStudents().add(student);  
  56.             team.getStudents().add(student2);  
  57.             //后三个student属于team2  
  58.             team2.getStudents().add(student3);  
  59.             team2.getStudents().add(student4);  
  60.             team2.getStudents().add(student5);  
  61.             //开启事务  
  62.             tx = session.beginTransaction();  
  63.               
  64.             //保存team和team2  
  65.             session.save(team);  
  66.             session.save(team2);  
  67.             System.out.println("save success!");  
  68.               
  69.             //提交事务  
  70.             tx.commit();  
  71.         } catch (Exception e) {  
  72.             e.printStackTrace();  
  73.             if (null != tx) {  
  74.                 tx.rollback();  
  75.             }  
  76.         } finally {  
  77.             session.close();  
  78.         }  
  79.     }  
  80. }  

控制打印sql如下:

 

Sql代码
  1. save success!  
  2. Hibernate: insert into team_list (name, id) values (?, ?)  
  3. Hibernate: insert into student_list (card_id, name, age, team_id, id) values (?, ?, ?, ?, ?)  
  4. Hibernate: insert into student_list (card_id, name, age, team_id, id) values (?, ?, ?, ?, ?)  
  5. Hibernate: insert into team_list (name, id) values (?, ?)  
  6. Hibernate: insert into student_list (card_id, name, age, team_id, id) values (?, ?, ?, ?, ?)  
  7. Hibernate: insert into student_list (card_id, name, age, team_id, id) values (?, ?, ?, ?, ?)  
  8. Hibernate: insert into student_list (card_id, name, age, team_id, id) values (?, ?, ?, ?, ?)  
  9. Hibernate: update student_list set team_id=?, `index`=? where id=?  
  10. Hibernate: update student_list set team_id=?, `index`=? where id=?  
  11. Hibernate: update student_list set team_id=?, `index`=? where id=?  
  12. Hibernate: update student_list set team_id=?, `index`=? where id=?  
  13. Hibernate: update student_list set team_id=?, `index`=? where id=?  

02-04插入的是team
05-08插入的是team2

09-13是对student_list表中外键team_id,和排序字段index的维护

 

student_list表中记录如下:

 

Sql代码
  1. id                    name    age           team_id  
Sql代码
  1. 8a8adb7b34a45b700134a45b72130002 zhangsan  20  8a8adb7b34a45b700134a45b71fc00010  
  2. 8a8adb7b34a45b700134a45b72130003 lisi      24  8a8adb7b34a45b700134a45b71fc00011  
  3. 8a8adb7b34a45b700134a45b72130005 student3  24  8a8adb7b34a45b700134a45b721300040  
  4. 8a8adb7b34a45b700134a45b72130006 student4  24  8a8adb7b34a45b700134a45b721300041  
  5. 8a8adb7b34a45b700134a45b72140007 student5  24  8a8adb7b34a45b700134a45b721300042  

team_list表中记录:

Sql代码
  1. 8a8adb7b34a467320134a46733cc0001    team1  
  2. 8a8adb7b34a467320134a46733e40004    team2 
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate是一个Java持久化框架,它能够将Java对象映射到数据库的表格,同时支持各种关系数据库,如MySQL、Oracle等。在Hibernate,对于一对一、一对多和多对多的关系,我们可以通过以下方式进行映射。 一对一关系:在Hibernate,可以通过主键关联和外键关联来实现一对一关系映射。主键关联是指两个实体之间的关联通过主键来进行,可以使用@PrimaryKeyJoinColumn注解将两个实体关联起来。外键关联是指通过一个实体引用另一个实体的主键作为外键,使用@JoinColumn注解来指定外键属性。 一对多关系:在Hibernate一对多关系通常通过外键关联来实现。在一的一方,使用@OneToMany注解来定义一对多关系,同时使用@JoinColumn注解指定外键属性。在多的一方,使用@ManyToOne注解来定义多对一关系,并使用@JoinColumn注解指定外键属性。 多对多关系:在Hibernate,多对多关系通常通过间表来实现。在多对多的两个实体,使用@ManyToMany注解来定义多对多关系。同时,需要在间表创建两个外键,分别与两个实体的主键关联,并使用@JoinTable注解来指定间表的表名和两个外键的列名。 总结:通过Hibernate的注解方式,可以方便地实现一对一、一对多和多对多关系映射。通过合理地使用注解,可以减少编写映射文件的工作量,提高开发效率。同时,Hibernate还提供了在运行时自动生成表结构的功能,可以根据Java实体类来动态创建或更新对应的数据库表格,从而提高系统的可维护性和灵活性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值