Hibernate单向多对一映射关系01和级联保存和Junit4使用

最新推荐文章于 2021-01-23 11:50:40 发布
最新推荐文章于 2021-01-23 11:50:40 发布
阅读量113 收藏 1
点赞数
文章标签： java 数据库
原文链接：https://my.oschina.net/u/3848699/blog/2222912
版权

一、了解什么是一对多？

　　　　　一对多这种关系用的很多，但是很多人对此模糊不清，一对多不也就是多对一吗，多对多中特殊的一个不也就是一对多吗，为什么还分的那么清楚？并且还是什么单向和双向的那么麻烦，其实原因很简单，就是针对不同的情况和业务需求而产生的这种说法。

　　　　　例如：学生和班级

　　　　　　　　单向一对多：一个班级对应多个学生。 也就是说，在某种业务情况下，我只需要知道从一个班级中知道有哪些学生，但是我不需要知道一个学生在哪个班级，这时候我就没必要写通过学生能查找到对应班级这个业务

（站在“一”这一边，可以通过班级看这个班级的学生功能，没有通过学生知道班级功能）

　　　　　　　　单向多对一：多个学生对应一个班级，可以通过每个学生查找到所在的班级名称，而不能从班级中查找到有哪些学生在里面，这就是从多到一的单面考虑，也就是说，当我们的业务需求只需要通过学生能找到对应班级，而不需要通过班级知道有哪些学生的时候，就可以写这样的单向多对一的关系映射

（站在“多”这一边，有通过学生知道班级功能，没有通过班级看这个班级的学生功能）

　　　　　　　　双向一对多/双向多对一：这两个是一个意思，既然度双向了，说明不管从哪一方去找另一方，度可以找得到，也就无所谓一对多，还是多对一了。从这个学生和班级来讲，通过学生能知道他所在的班级，通过班级，能知道该班级下所有的学生。

　　　　　　通过这个例子就知道了单向和双向是干嘛用的，就是根据不同的业务所规定的，如果你需要双向就写双向的映射关系，如果只需要从一方到另一方，那么就写自己所需要的，单向一对多或者单向多对一。

　　　　　

　　　　所以我们接下要讲解的就是这三种，单向一对多、单向多对一、双向一对多。

二、单向多对一

　　　　　　多个用户属于同一个组，多个学生属于同一个班级，多个学生属于同一个宿舍，等等，很多关系是这种多对一。

　　　　　　多个学生属于同一个班级。单向多对一　　　　

　　　　　　　　　　　　　　　　　　User和Classes类的关系图。

　　　　　　　　　　　　　　　d90b4caac0659a6e292da5dcf2aa7e15e5a.jpg

知道需要的功能是多对一之后，站在“多的角度”，在设计完学生类基本属性的情况下，增加一个“班级类”来保存班级信息，就是说该学生数据有这个班级表信息

例子

9d897e35c06fd3d1f773427895a2468a8e5.jpg

1、首先创建班级和学生实体类

Classes.java

package com.java.model;

public class Classes {
	private String name;
	private long id;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	
}

配置Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--班级表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Classes" table="t_classes">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="class_id">
		<generator class="native"></generator>
	</id>
	
		<!-- 该对象的基本属性 -->
	<property name="name" column="class_name">
	</property>
	</class>


</hibernate-mapping>

 

因为是多对一，站在“多”的角度，也就站在学生角度，classes 班级 不需要有那种关系，只需要配置自己的属性就行了

 

Student.java

package com.java.model;

public class Student {
	private String name;
	private long id;
	
	//定义一个班级对象
	private Classes c;

	public Classes getC() {
		return c;
	}
	public void setC(Classes c) {
		this.c = c;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	

	
	@Override
	public String toString() {
		return "Student [name=" + name + ", id=" + id + ", c=" + c + "]";
	}
	
	

}

　Student需要有相应的能力，所以需要配置外键关系。many to one

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--学生表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Student" table="t_student">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="student_id">
		<generator class="native"></generator>
	</id>
	
	<!-- 该对象的基本属性 -->
	<property name="name" column="student_name">
	</property>
	
	
	 <!-- 重点在这里 
	 		学生表外键和班级表主键相关联，
            name：学生实体类中定义的那个对象的引用名称这东西:private Class c;。
            column：学生表中的外键名称。注意，是被外键约束的字段的名称，写这些配置文件，要时刻记得那两张数据库表的关系。
			学生表外键名可以取和班级表主键名不一样的名字
			本例学生表外键名：classId  
			本例班级表主键名：class_id  
         -->
	<many-to-one name="c" column="classId" class="com.java.model.Classes"></many-to-one>
	</class>


</hibernate-mapping>

单向多对一的关系映射就是这样，原理就是在数据库中多方设置外键指向一方。 然后通过映射文件来利用这个外键帮我们达到我们的目的，这里就是通过外键，找到对应的班级放入我们自己类中的classes属性中。

many-to-one的属性

　　　　　　　　name：影射类属性的名称

　　　　　　　　class：非必须的，不写，hibernate会自己根据name的值去查找

　　　　　　　　column：关联的字段，也是非必须的，hibernate也会帮我们在查找，但是不写的话，User中的外键名称必须和Classes中的主键名称相同。也就是关联的字段名称要相同，这样才找得到

　　　　　　　　net-null：默认是false，就是不能为空

　　　　　　　　5c7bf8a3410d4c80e3b9485baa8b3b181c3.jpg

 

然后执行/StudentTest.java

package com.java.service;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.java.util.HibernateUtil;
public class StudentTest {

	public static void main(String[] args) {
		SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
		  Session session=sessionFactory.openSession(); // 生成一个session
		    session.beginTransaction(); // 开启事务
		    
		  
		    
		    session.getTransaction().commit(); // 提交事务
		    session.close(); // 关闭session
	}
}

查看数据库，发现自动生成了表，还有主外键的关联关系，神奇

ebed66c5c9fab43b9d2d63420933b760f75.jpg

三、“多对一”级联保存

8276647ed5435d2dd49eae04a54896dbe1c.jpg

一般我们写入数据进数据步骤是：

1.操作班级表，给班级表创建一条班级数据

2.操作学生表，给学生表创建一条学生数据，然后放入班级信息

package com.java.service;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.java.model.Classes;
import com.java.model.Student;
import com.java.util.HibernateUtil;
public class StudentTest {

	public static void main(String[] args) {
		SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
		  Session session=sessionFactory.openSession(); // 生成一个session
		    session.beginTransaction(); // 开启事务

		    //写好班级信息
		    Classes banji=new Classes();
		    banji.setName("15软件工程");
                    //持久化，操作班级表，把班级信息放到数据库
		    session.save(banji);
		     
                    //写好学生表的信息
		    Student s1=new Student();
		    s1.setName("张三");
		    s1.setC(banji);
                    //持久化，操作学生表，把学生信息放到数据库
		     session.save(s1);


		    Student s2=new Student();
		    s2.setName("李四");
                    s2.setC(banji);
		    session.save(s2);
		    
		    session.getTransaction().commit(); // 提交事务
		    session.close(); // 关闭session
	}
}

因为我们设置了单向多对一，也就是说，我们可以只操作学生表，同时操作班级表

当我们在学生表保存学生信息和班级信息，班级表自动保存，级联保存先配置“多”的这边

3a94f7b86f38b4eed7dadba1a90d1b59d32.jpg

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--学生表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Student" table="t_student">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="student_id">
		<generator class="native"></generator>
	</id>
	
	<!-- 该对象的基本属性 -->
	<property name="name" column="student_name">
	</property>
	
	
	 <!-- 重点在这里 
	 		学生表外键和班级表主键相关联，
            name：学生实体类中定义的那个对象的引用名称:private Class c;。
            column：学生表中的外键名称。注意，是被外键约束的字段的名称，写这些配置文件，要时刻记得那两张数据库表的关系。
			学生表外键名可以取和班级表主键名不一样的名字
			本例学生表外键名：classId  
			本例班级表主键名：class_id  
         -->
	<many-to-one name="c" column="classId" class="com.java.model.Classes" cascade="save-update"></many-to-one>
	</class>


</hibernate-mapping>

现在就可以级联保存，保存学生表的数据，班级表数据就自动生成

package com.java.service;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.java.model.Classes;
import com.java.model.Student;
import com.java.util.HibernateUtil;
public class StudentTest {

	public static void main(String[] args) {
		SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
		  Session session=sessionFactory.openSession(); // 生成一个session
		    session.beginTransaction(); // 开启事务

		    //写好班级信息对象
		    Classes banji=new Classes();
		    banji.setName("15软件工程");
                    		     
                    //写好学生的信息对象		    
                    Student s1=new Student();
		    s1.setName("张三");
                    //把班级信息对象加到学生的信息对象
		    s1.setC(banji);

                    //持久化，只操作学生表，把学生信息对象放到学生表
		     session.save(s1);


		    Student s2=new Student();
		    s2.setName("李四");
                    s2.setC(banji);
		    session.save(s2);
		    
		    session.getTransaction().commit(); // 提交事务
		    session.close(); // 关闭session
	}
}

这样添加学生信息时把班级信息写上点击确定就行，自动把班级信息保存。

不用先保存班级信息，才能保存学生信息。直接保存学生信息即可

数据库：

学生表

473d7db4d2bf44629c7928cf03f2e9cc1be.jpg

班级表

498860473bba9c9aa58b168ca525226f2ad.jpg

 

四、Junit4使用

Junit方法如下

1a750f2a6b5dec7f542fda0e344fdc6cd46.jpg

使用这些方法看先后执行顺序

8d01972ff1c5863500fd435b5e08712303f.jpg

670637966be86bd04fc60538988d5333580.jpg

StudentTest2 

package com.java.service;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class StudentTest2 {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		System.out.println("类初始化前调用");
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		System.out.println("类初始化前调用");
	}

	@Before
	public void setUp() throws Exception {
		System.out.println("测试方法前调用");
	}

	@After
	public void tearDown() throws Exception {
		System.out.println("测试方法后调用");
	}

	@Test
	public void test() {
		System.out.println("测试方法");
	}

}

执行顺序结果

9a75ce06840c0e44170e55cb2c08d78e006.jpg

常用的就是测试方法前后调用

72797366d904806780234748a49918da2d4.jpg

package com.java.service;

import static org.junit.Assert.*;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Classes;
import com.java.model.Student;
import com.java.util.HibernateUtil;

public class StudentTest2 {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
	    session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}
	
	@Test
	public void testSaveClassAndStudent() {
		System.out.println("正常思路保存数据");

	    //写好班级信息
	    Classes banji=new Classes();
	    banji.setName("15软件工程");
                //持久化，操作班级表，把班级信息放到数据库
	    session.save(banji);
	     
                //写好学生表的信息
	    Student s1=new Student();
	    s1.setName("张三");
	    s1.setC(banji);
                //持久化，操作学生表，把学生信息放到数据库
	     session.save(s1);


	    Student s2=new Student();
	    s2.setName("李四");
                s2.setC(banji);
	    session.save(s2);

	}
	@Test
	public void testSaveClassAndStudentWithCascade() {
		System.out.println("级联保存");

		 //写好班级信息
	    Classes banji=new Classes();
	    banji.setName("15软件工程");
                		     
                //写好学生的信息		    
                Student s1=new Student();
	    s1.setName("张三");
	    s1.setC(banji);

                //持久化，只操作学生表，把学生信息放到学生表
	     session.save(s1);


	    Student s2=new Student();
	    s2.setName("李四");
                s2.setC(banji);
	    session.save(s2);


	}

}

想测试哪个方法就进行如下操作：

9b412910ed96f228ff26e183457346166a2.jpg

 

五、单向多对一 

          说了单向多对一，现在来说说单向一对多，根据前面我们讲的，其实就是换了一个角度去想这个问题，学生和班级，现在站在班级这方去看，肯定是需要通过班级能知晓所有在这个班学习的同学的信息。  

         注意方向：站在“一”的角度看待问题，班级是“一”，就是说每一个班级里都有几十个学生信息，通过班级这个表我可以找到某个学生信息

站在“一”的角度，在设计完班级类基本属性的情况下，增加一个“学生类的集合”（每个学生类代表一个学生）

在model的加学生集合属性

private Set<Student> students=new HashSet<Student>();

 

    788a4336bbb14d25ca2b03702b84f1c29f5.jpg   

       数据库中还是没变，不管是单向一对多还是单向多对一，永远都市通过外键来维护关系的，单向多对一：通过映射文件知道，User的外键能够查找到对应的班级。单向一对多：又是怎么来实现通过User的外键找到属于本班的所有学生的呢？

看代码

Classes.java

package com.java.model;

import java.util.HashSet;
import java.util.Set;

public class Classes {
	private String name;
	private long id;
        <!--重点-->
	private Set<Student> students=new HashSet<Student>();
	
	
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	
}

  Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--班级表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Classes" table="t_classes">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="class_id">
		<generator class="native"></generator>
	</id>
	
		<!-- 该对象的基本属性 -->
	<property name="name" column="class_name">
	</property>
	
	
	
        <!--关键在这里，
            name:set集合属性的名称（model里的classes类的学生集合名称）
            key/column：这个是外键名，这个外键字段名不一定要和本类的主键字段名相同，这点要搞清楚，记住数据库表的关系，谁指向谁就不会混淆
                        这个外键值放在学生表里（不管是单向一对多还是单向多对一，都需要在多方加上外键）
            one to many/class：一对多，所映射的类名(全限定类名，直接写类名也可以，hibernate会帮我们自动写好)
        -->
		        <set name="students">
		            <key column="cid"></key>
		            <one-to-many class="com.java.model.Student" />
		        </set>
		</class>
</hibernate-mapping>

         通过映射文件可以知道，通过本类（班级）中的主键值去寻找映射类（学生）中的外键值，有匹配的就将其对象放置到set集合中来。所以说，不管是单向一对多还是单向多对一，都需要在多方加上外键，也就是说，他们的原理度是一样的，只是站的角度不一样，单向一对多站的角度在于一方，一方如何通过外键来达到自己的目的，就看自己的映射文件如何编写，单向多对一站的角度在多方，多方如何通过外键来达到自己的目的，也要看自己的映射文件的编写。  

    由于是一对多，站在“一”的角度，学生端正常设置就行

Student.java

package com.java.model;

public class Student {
	private String name;
	private long id;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	
}

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--学生表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Student" table="t_student">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="student_id">
		<generator class="native"></generator>
	</id>
	
	<!-- 该对象的基本属性 -->
	<property name="name" column="student_name">
	</property>
	

	</class>


</hibernate-mapping>

 

测试方法（把数据库表删了，因为前面生成了“多对一”的表，现在测试“一对多”）

StudentTest.java

@Test
public static void main(String[] args) {
		SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
		  Session session=sessionFactory.openSession(); // 生成一个session
		    session.beginTransaction(); // 开启事务
		    
		   
		    
		    session.getTransaction().commit(); // 提交事务
		    session.close(); // 关闭session
	}

发现数据库生成成功

0bce5acab395ed16495fc95d9818d5499f5.jpg

、“一对多”级联保存

保存班级表的时候带上学生信息，只操作班级表，学生表也会保存。

首先给Classes.hbm.xml配置cascade="save-update"

3f883d09df9ac1e91c916f62d67b6738df7.jpg

然后测试方法

       @Test
	public void testSaveClassAndStudent() {
		//写好班级信息对象
		Classes c=new Classes();
	    c.setName("08计本");
	    //写好学生信息对象
	    Student s1=new Student();
	    s1.setName("张三");
	    
	    Student s2=new Student();
	    s2.setName("李四");
	    
	    //把学生对象加到班级对象
	    c.getStudents().add(s1);
	    c.getStudents().add(s2);
	    
	    //将班级对象保存到班级表中，学生表自动更新
	    session.save(c);
	}

结果

0b0f41186720f75b7dfcd8a31b3ef5db81b.jpg1255b558034d61f43ea131efcdd0024c6ea.jpg

 

 

转载于:https://my.oschina.net/u/3848699/blog/2222912

chici7332
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate3.2级联关系自身一对多双向关联
03-23
在Java持久化领域，Hibernate是一个广泛应用的ORM（对象关系映射）框架，它极大地简化了数据库操作。在Hibernate 3.2版本中，级联关系是处理对象间关联的重要特性，特别是自身一对多双向关联，这允许一个实体类实例...
框架之hibernate多对一表创建保存
sxb956347789的博客
01-10 604
多对一单向关联 多端持有一端实例
hibernate一对多、多对多级联保存与级联删除与修改外键
Daydream Mr.的博客
02-07 6212
1、复杂写法级联保存 //创建一个公司对象，为公司对象添加员工         GongsiEntity gongsi=new GongsiEntity();         gongsi.setGname("百度");         YuangongEntity yuangong=new YuangongEntity();         yuangong.setYname("001
Hibernate单向多对一实战
实践求真知
11-22 253
一 单向多对一生活举例     二 实现方式 多对一的关系和关系数据库中的外键参照关系最匹配，即在多方的表中的一个外键参照一方表的主键。 通过在多方持有一方的引用实现，需要在“多”的一端使用配置。   三 单向多对一的配置 1 Student.java package com.imooc.entity;   import java.io.Serializable;  
单向多对一
lyfvslw的专栏
11-18 3031
<br /><br />单向多对一关联<br />     在关系型数据库理论中，“多对一”关联同于“一对多”关联，且为了消除数据冗余，在两个关系之间不存在“多对多”关联，“多对多”关联要通过连接表来实现。因此在关系型数据库中只有“一对一”和“一对多（多对一）”，且都是单向的。而在hibernate当中，为了保证关联双方的映射可以通过多种方式进行，“单向一对多”关联和“单向多对一”被认为是两种不同的关联，其主要区别是在于哪个表的映射文件中进行<many to one>的配置，进行<many to one>配
hibernate单向多对一映射
红桃峰峰 的博客
07-15 450
在实际的开发中，数据库表之间的关系有很多都是多对一的关联关系，这种情况的业务，在hibernate中该怎么处理呢？今天我们就来学习一下hibernate的单向多对一映射关系。 新建一个java项目，名称为：08hibernate_many_to_one 项目结构如图： 需要的jar包和如何从hibernate官网获得，请参见《Hibernate环境搭建和配置》
hibernate 级联（cascade和inverse）一对多
02-22
总结，Hibernate的级联和反转特性对于一对多关系的管理至关重要，它们可以简化开发过程，提高数据操作的效率。通过合理配置，可以确保对象关系的正确同步，并利用JUnit进行测试以确保功能的正确性。在实践中，应根据...
hibernate(一对多，多对一映射)操作
07-18
本文将深入探讨Hibernate中的一对多和多对一映射关系，并通过一个实际的demo演示它们在增删查改操作中的应用。 首先，我们要理解什么是数据库的关联关系。在数据库设计中，我们经常遇到一种情况，即一个实体可能与...
举例讲解Java的Hibernate框架中的多对一和一对多映射
09-03
本篇文章将详细讲解在Hibernate中如何实现多对一和一对多的映射关系。 首先，我们来看多对一（Many-to-One）映射。在上述例子中，我们有一个`Employee`类代表`EMPLOYEE`表，一个`Address`类代表`ADDRESS`表。每个`...
Spring boot整合Mybatis实现级联一对多CRUD操作的完整步骤
08-25
首先，我们需要理解什么是级联操作和一对多的关系。在关系型数据库中，级联操作涉及到一个表中的记录与另一个表中的多个记录相关联，这就是一对多关系。例如，一个用户可以拥有多个角色，而每个角色只属于一个用户。...
hibernate注解 级联 多对一 一对多
12-14
hibernate 注解生成表   JPA注解1、@Entity(name="EntityName")必须,name为可选,对应数据库中一的个表2、@Table(name="",catalog="",schema="")可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息name:可选,表示表的名称.默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名catalog:可选,表示Catalog名称,默认为Catalog("").schema:可选,表示Schema名称,默认为Schema("").
hibernate 单向多对一，一对多，双向多对一详解
wanderlustLee的博客
02-26 1508
1、单向多对一和双向多对一的区别？ 只需要从一方获取另一方的数据时 就使用单向关联双方都需要获取对方数据时 就使用双向关系部门--人员使用人员时如果只需要获取对应部门信息(user.getdeptarment())不需要 从部门下的人员信息时，就配置成单向 多对一使用部门时如果只需要获取部门下人员信息(deptartmanet.getusers())不需要 从人员获取部门信息时，就配置成单向 一...
Hibernate之多对多级联保存以及删除
maty_wang的博客
05-31 2073
对应的两个实体类为Student和CourseStudent类package com.maty.entity; import java.util.HashSet; import java.util.Set; /** * @author maty e-mail:512181558@qq.com * @version 创建时间：2018年5月31日 下午3:25:32 类说明 学生类 */ ...
hibernate的级联保存操作（一对多）
u011282647的博客
12-02 1万+
现在我们开始做级联保存操作的练习，上一篇《hibernate基本保存操作》中介绍了hibernate执行保存过程的操作。我们在那个的基础上来做一对多的级联保存操作； 第一步：创建数据库模型Customer（客户）和LinkPerson（联系人） public class Customer{ private String id;//主键ID private String cust
hibernate一对多单向关联时保存问题
weixin_34348174的博客
03-12 143
需求保存一个联系人，同时保存一个客户 问题：当我们先保存联系人，在保存客户是，会产生3条sql语句，两条insert一个update 而实际情况：我们只需要2条insert 解决办法：先保存主表在保存从表 转载于:https://blog.51cto.com/13579086/2085447...
Hibernate 添加数据 一 （一对多）
代码小疯子
03-19 8725
Hibernate 添加数据 (一对多)
Hibernate多对一
weixin_33785972的博客
03-31 71
为什么80%的码农都做不了架构师？>>> ...
Hibernate的一对一,一对多/多对一关联保存
热门推荐
星晚的博客
01-23 2万+
一对一关联保存: ps:这里都是拿工作中的项目做例子,所有不会有完整的业务代码,提供思路 说明: 留言状态表: 记录用户的留言信息,如留言人openid,留言时间等…(主表) 用户留言内容表: 记录用户的留言内容,id与状态表一对一(从表) 留言表实体类配置:(主表) 添加一对一关联的从表 // one to one private com.rhtcms.cms.entity.main.CustomerMessageContent customerMessageContent;//对应内容表信息
使用hibernate5利用宠物主人和宠物的一对多关联关系实现级联操作
最新发布
04-11
使用 Hibernate5 可以利用宠物主人和宠物的一对多关联关系实现级联操作。比如添加一个宠物时可以同时添加它的主人信息，删除一个宠物时也会同时删除它的主人信息。这种级联操作可以大大方便开发者的编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值