@OneToMany单向一对多

最新推荐文章于 2024-07-09 13:49:54 发布
最新推荐文章于 2024-07-09 13:49:54 发布
阅读量1.8k 收藏
点赞数 1
分类专栏： java web开发 文章标签： OneToMany 单向一对多 hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljj2312/article/details/72414248
版权

Hibernate单项一对多详细配置：

数据模型：

一个年级有多个学生，每个学生只属于一个年级。

用hibernate实现一对多关系有xml配置和注解两种方式，下面逐一介绍：

第一种：注解方式

Grade.java

package cn.siggy.pojo;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
 * AbstractGrade entity provides the base persistence definition of the Grade
 * entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "GRADE")
public class Grade implements java.io.Serializable {

	// Fields

	private Integer id;
	private String name;
	private Set<Student> students = new HashSet<Student>(0);

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

	public Grade(Integer id, String name, Set<Student> students) {
		super();
		this.id = id;
		this.name = name;
		this.students = students;
	}

	// Property accessors
	@Id
	@GeneratedValue
	@Column(name = "ID", unique = true, nullable = false, precision = 10, scale = 0)
	public Integer getId() {
		return this.id;
	}

	

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "NAME")
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY,targetEntity=Student.class)    
        //@JoinColumn(name="GRADE_ID",nullable=true) //该配置在单独保存Grade是会将student中的外键字段置空，所以采用下面配置
        @JoinColumn(name="PLAN_ID",updatable=false) 
        public Set<Student> getStudents() {
		return this.students;
	}
	public void setStudents(Set<Student> students) {
	this.students = students;
	}
}






Student.java




package cn.siggy.pojo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;
import javax.persistence.Table;

/**
 * AbstractStudent entity provides the base persistence definition of the
 * Student entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "STUDENT")
public class Student implements java.io.Serializable {

	// Fields

	private Integer id;
	private String name;
	private Integer age;

	// Constructors

	/** default constructor */
	public Student() {
	}

	// Property accessors
	@Id
	@GeneratedValue
	@Column(name = "ID", unique = true, nullable = false, precision = 10, scale = 0)
	public Integer getId() {
		return this.id;
	}

	public void setId(Integer id) {
		this.id = id;
	}
	

	@Column(name = "NAME", length = 510)
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Column(name = "AGE", precision = 10, scale = 0)
	public Integer getAge() {
		return this.age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

}








hibernate.cfg.xml



<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<!--数据库信息  -->
		<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@10.18.100.126:1521:gsdb</property>
		<property name="connection.username">db_lzsmw</property>
		<property name="connection.password">pass_lzsmw</property>
		<!--hibernate可选项 -->
		<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
		<property name="hbm2ddl.auto">update</property>
		<!-- hbm文件 --><!--
		<mapping resource="cn/siggy/pojo/Student.hbm.xml"/>
		<mapping resource="cn/siggy/pojo/Grade.hbm.xml"/>
	-->
		<!-- 使用注解 -->
		<mapping class="cn.siggy.pojo.Grade"/>
		<mapping class="cn.siggy.pojo.Student"/>
	</session-factory>
</hibernate-configuration>






 




第二种：xml配置方式实现一对多 


Grade.java




package cn.siggy.pojo;

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

public class Grade {
	private int id;
	private String name;
	private Set<Student> students = new HashSet<Student>(0);
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}



Grade.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 package="cn.siggy.pojo">
	<class name="Grade">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"/>
		<!-- set是 Grade中的集合属性  name属性名称 -->
		<set name="students">
			<!-- key表示外键  column外键列名-->
			<key column="grade_id" not-null="true"></key>
			<!-- one-to-many 一对多  类Grade 中  students 所表示类型 -->
			<one-to-many class="Student"/>
		</set>
	</class>
</hibernate-mapping>


Student.java





package cn.siggy.pojo;

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



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 package="cn.siggy.pojo">
	<class name="Student">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"/>
		<property name="age"/>
	</class>
</hibernate-mapping>
hibernate.cfg.xml






<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<!--数据库信息  -->
		<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@10.18.100.126:1521:gsdb</property>
		<property name="connection.username">db_lzsmw</property>
		<property name="connection.password">pass_lzsmw</property>
		<!--hibernate可选项 -->
		<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
		<property name="hbm2ddl.auto">update</property>
		<!-- hbm文件 -->
		<mapping resource="cn/siggy/pojo/Student.hbm.xml"/>
		<mapping resource="cn/siggy/pojo/Grade.hbm.xml"/>

		<!-- 使用注解 -->
		<!--<mapping class="cn.siggy.pojo.Grade"/>
		<mapping class="cn.siggy.pojo.Student"/>-->
	</session-factory>
</hibernate-configuration>


工具类：HibernateUtil.java





package cn.siggy.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static Configuration cfg=null;
	private static SessionFactory factory=null;
	private static Session session = null;
	static{
		cfg = new Configuration().configure();
		factory = cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		.applySettings(cfg.getProperties()).build());
	}
	public static Session getSession(){
		if(factory!=null)
			return factory.openSession();
		factory=cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		.applySettings(cfg.getProperties()).build());
		return factory.openSession();
	}
	public static void closeSession(){
		if(session!=null&&session.isOpen())
			session.close();
	}
}



Junit单元测试类：





package cn.siggy.test;

import java.sql.SQLException;
import java.util.Iterator;
import javax.sql.rowset.serial.SerialException;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;
import cn.siggy.pojo.Grade;
import cn.siggy.pojo.Student;
import cn.siggy.util.HibernateUtil;

public class HibernateTest {
	@Test
	public void testCreateDB(){
		Configuration cfg = new Configuration().configure();
		SchemaExport se = new SchemaExport(cfg);
		//第一个参数 是否生成ddl脚本  第二个参数  是否执行到数据库中
		se.create(true, true);
	}
	@Test
	public void testSave() throws HibernateException, SerialException, SQLException{
		Session session = null;
		Transaction tx = null;
		try{
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();
			Grade grade = new Grade();
			grade.setName("基础");
			
			Student stu = new Student();
			stu.setName("张三疯");
			stu.setAge(22);
			Student stu1 = new Student();
			stu1.setName("老王");
			stu1.setAge(23);
			//关联
			grade.getStudents().add(stu);
			grade.getStudents().add(stu1);
			//保存数据的顺序 是根据外键的配置来决定的
			//如果外键不能为null,那么先保存一的一端
			//如果外键可以为null,则可以随意保存
			session.save(grade);
			session.save(stu);
			session.save(stu1);
			
			tx.commit();
			
		}catch (HibernateException e) {
			if(tx!=null)
				tx.rollback();
			e.printStackTrace();
			throw e;
		}finally{
			HibernateUtil.closeSession();
		}
	}
	@Test
	public void testGet(){
		Session session = null;
		Transaction tx = null;
		try{
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();
			//取数据
			Grade grade = (Grade)session.get(Grade.class, 1);
			System.out.println("gradeName="+grade.getName());
			System.out.println("grade所对应的多的一端的数据");
			Iterator<Student> iter = grade.getStudents().iterator();
			for(;iter.hasNext();){
				Student temp = iter.next();
				System.out.println("name="+temp.getName()+"\tage="+temp.getAge());
			}
			tx.commit();
		}catch (HibernateException e) {
			if(tx!=null)
				tx.rollback();
			e.printStackTrace();
			throw e;
		}finally{
			HibernateUtil.closeSession();
		}
	}
}






如下表结构代码可以自动生成，所以不用手动创建




 
 

  
  Student表结构：
 
 


 
 

  
  
  
  


 
 






Grade表结构：




















                

        

        

    

  


    

      

        

            

              
                
                  飞奔的蜗牛2017
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
（5）OneToMany单向、双向manytoone

				
			

			

				

					FixedStar 的博客
				

				

					11-12
					
					1983
					
				

			

		

		

			
				
一、OneToMany单向 
OneToMany说明是一个组知道有哪些成员，而成员不知道自己是哪个组（这是类层面的理解）。数据库方面还是多端（User）有外键属性。 
若两个表中只写OneToMany,则必须写@JoinColumn(name=”groupId”)，否则hibernate会当成多对多建立中间表 
Group（一端）/*
 * 一对多，即在一端加
 * 并且不需要在多端加外键。
 *

			
		

	



                

              
                



	

		

			

				
					
【Spring Boot 3】【JPA】@OneToMany 实现一对多单向关联

				
			

			

				

					又言又语
				

				

					02-22
					
					685
					
				

			

		

		

			
				
本文介绍开发Spring Boot应用时如何使用@OneToMany注解处理一对多单向关联关系，涵盖主从双数据表和带有中间关联关系表的三数据表这两种存储一对多关联关系的实现。本文定义了公司（Company）、工程师（Engineer）、经理（Manager）三个实体，其中公司（Company）与工程师（Engineer）、公司（Company）与经理（Manager）都是一对多单向关联，且关系主控方（即关系拥有方）都是公司（Company本文将中间表对应的Entity（）和Repository（

			
		

	



                


  
              

                


	

		

			

				
					
hibernate——onetomany（单向）

				
			

			

				

					archer的技术故事
				

				

					06-26
					
					505
					
				

			

		

		

			
				
hibernate——onetomany
package com.xueyoucto.xueyou;

import org.hibernate.annotations.*;
import org.hibernate.annotations.CascadeType;

import javax.persistence.*;
import javax.persistence.Entity;
imp

			
		

	





	

		

			

				
					
java springboot中@OneToMany、@ManyToOne以及@ManyToMany讲解

					
最新发布

				
			

			

				

					m0_72642319的博客
				

				

					07-09
					
					1509
					
				

			

		

		

			
				
java springboot中@OneToMany、@ManyToOne以及@ManyToMany讲解

			
		

	



		

			
		



	

		

			

				
					
JPA单向一对多关联关系@OneToMany

				
			

			

				

					qq_36722039的博客
				

				

					07-15
					
					7565
					
				

			

		

		

			
				
package com.jpa.helloworld;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Ent...

			
		

	





	

		

			

				
					
Hibernate One-to-Many(单向)

				
			

			

				

					永无止境
				

				

					01-26
					
					6158
					
				

			

		

		

			
				
Hibernate 单向 One-to-Many 只在one方配置，适用于一条数据关联多条明细

			
		

	





	

		

			

				
					
JPA 中使用 @OneToMany 、@ManyToOne 等关系映射注解

				
			

			

				

					小张Python
				

				

					11-26
					
					4593
					
				

			

		

		

			
				
JPA 做 ORM(Object Relational Mapping，对象关系映射)时，为了开发效率，通常会在实体类上用 hibernate 的关系关联注解。方法，可以解决了父子实体类打印输出时，因相互依赖循环嵌套中堆栈溢出问题；一起使用，既可以单向，也可以双向关联；）关系，一个组可以容纳多个学生，一对多；查询 GroupClass 对象，在输出打印对象的。该错误解决方法：在父类或子类对应的关联字段上，加上。，使用时会触发嵌套循环，造成栈溢出问题；外键关联，一般子实体类这边维护，因此由。

			
		

	





	

		

			

				
					
Hibernate @OneToMany 及 @Cascade级联操作

				
			

			

				

					weixin_40361910的博客
				

				

					02-21
					
					740
					
				

			

		

		

			
				
前言

由图中可以看出实体间关系：一对多(@OneToMany)
在实际开发场景中，删除员工老板不会被删除，老板被删除了员工肯定要删除
由此，就会使用级联操作，在一对多关系中，@Cascade属性(级联)只设置“一”的一方即可，外键由“多”的一方进行维护。
@ManyToOne和@OneToMany 注解

 ManyToOne(多对一)单向：不产生中间表，但可以用@Joincolumn...

			
		

	





	

		

			

				
					
解决@OneToMany关联后插入新数据，先清空中间表再插入的问题

				
			

			

				

					as513385的博客
				

				

					12-30
					
					2754
					
				

			

		

		

			
				
        最近学习大佬的开源项目https://waylau.com/books/，有个用到hibernate的地方困惑很久，blog对象和comment对象为一对多关系，一个博客可能有多个评论



 







但是在配置完成之后，每插入一条新的评论，中间表就会被清空，然后重新插入,这很明显是不合理的。

如果评论变多，一个博客上百条评论，每次新增一个评论都需要执行上百次的插入操作 ...

			
		

	





	

		

			

				
					
(7)hibernate中OneToMany单向

				
			

			

				

					HZPHYT的博客
				

				

					10-06
					
					502
					
				

			

		

		

			
				
OneToMany:在One一方添加外键，比如Message和Comment，就在Message这一方添加set

 

Message.hbm.xml：


&lt;hibernate-mapping&gt;
    &lt;class name="model.Message" table="MESSAGE"&gt;
        &lt;id name="id" type="int"

			
		

	





	

		

			

				
					
JPA OneToMany和ManyToOne单向实现

					
热门推荐

				
			

			

				

					王仁一的博客
				

				

					06-26
					
					1万+
					
				

			

		

		

			
				
博主在学习JPA的过程中，刚开始看到这一部分的时候也很迷惑， OneToMany和ManyToOne这两个注解可以单向实现，也可以双向实现
下面是单向实现方式:
1.@OneToMany
这里使用外健关联的方式，博主设置的是运行项目时自动创建表格，该注解会自动生成外健关联关系

@Entity
@Table(name = "PARENTS")
public class Parents {

			
		

	





	

		

			

				
					
hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法

				
			

			

				

					08-29
				

			

		

		

			
				
主要介绍了hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法,需要的朋友可以参考下

			
		

	





	

		

			

				
					
单向一对多   双向一对多    单项多对多  双向多对多  单项一对一  双向一对一

				
			

			

				

					metjoyful的博客
				

				

					09-21
					
					918
					
				

			

		

		

			
				
1 单向的一对多（不会专门使用 ，如果要使用双向就必须学习）
1.1 配置  (掌握)
多方
@Entity@Table(name="t_product")
public class Product {   
    @Id    
    @GeneratedValue   
    private Long id;   
    private String name;
}

1方配置
@En...

			
		

	





	

		

			

				
					
Hibernate 使用 Annotation 之 OneToMany(单向关联关系)

				
			

			

				

					liangoo7的专栏
				

				

					10-10
					
					8989
					
				

			

		

		

			
				
Java代码如下：
package com.lwp.hibernate.Model;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;  
import javax.persistence.Entity;  
import

			
		

	





	

		

			

				
					
cascade与fetch

				
			

			

				

					王月莹的专栏
				

				

					09-23
					
					8263
					
				

			

		

		

			
				
在Group。java里的注解：
   


@OneToMany(mappedBy="group",


          
cascade={CascadeType.ALL},


           
fetch=FetchType.EAGER

   
         )      
cascade
的注解作用是：group对象的增删改关联到user

			
		

	





	

		

			

				
					
Hibernate08_映射关系---OneToMany单向

				
			

			

				

					chbxw
				

				

					08-27
					
					391
					
				

			

		

		

			
				
组和用户的关系–oneToMany1.1、用户User, 多的一方package com.chb.model;public class User {
    private int id;
    private String username;
    private String passwd;    public User() {}    public User(int id, String

			
		

	





	

		

			

				
					
单向一对多 和 单向多对一 关联关系的一些认识

				
			

			

				

					dieyuanjiao9299的博客
				

				

					07-19
					
					180
					
				

			

		

		

			
				
①、不管是一对多还是多对一，外键列都在多的那端。
②、一对多关联关系中要先保存多端，再保存一端。
③、一对多中保存之前要设置一端的id。

转载于:https://www.cnblogs.com/GooPolaris/p/7919548.html...

			
		

	





	

		

			

				
					
单向一对多关系

				
			

			

				

					anwenzhao0749的博客
				

				

					09-28
					
					123
					
				

			

		

		

			
				
/**
 * 关系被维护端
 * @author Administrator
 *
 */
@Entity
@Table(name="orders")
public class Order {
 private String orderid;
 private Float amount;
 private Set<OrderItem> order...

			
		

	





	

		

			

				
					
一对多单向关联

				
			

			

				

					zsm653983的专栏
				

				

					10-22
					
					5135
					
				

			

		

		

			
				
多的一方:不写任何关联关系
package com.eneitys;
 

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
 

@Entity
@Tabl

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值