Hibernate的集合一对多与多对一
需求: 部门与员工
一个部门有多个员工; 【一对多】
多个员工,属于一个部门 【多对一】

1、javaBean
——Dept.java
package com.gqx.onetomany;
import java.util.HashSet;
import java.util.Set;
public class Dept {
private int deptId;
private String deptName;
//部门对应的多个员工 (一对多)
private Set<Employee> emps=new HashSet<Employee>();
public int getDeptId() {
return deptId;
}
public void setDeptId(int deptId) {
this.deptId = deptId;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public Set<Employee> getEmps() {
return emps;
}
public void setEmps(Set<Employee> emps) {
this.emps = emps;
}
}
——Employee.java
package com.gqx.onetomany;
public class Employee {
private int empId;
private String empName;
private double salary;
//员工与部门 (多对一)
private Dept dept;
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
}
2、一对多与多对一在映射文件中的表现
多个员工对应一个部门(Employee.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="com.gqx.onetomany"> <class name="Employee" table="t_Employee"> <id name="empId" > <generator class="native"></generator> </id> <property name="empName" length="20"></property> <property name="salary" type="double"></property> <!-- 多对一映射配置 Employee映射关键点 1、映射的部门属性 dept 2、映射的部门对象,对应的字段 dept_id 3、部门的类型 --> <many-to-one name="dept" column="dept_id" class="Dept"></many-to-one> </class> </hibernate-mapping>
一个部门对应多个员工(Dept.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="com.gqx.onetomany"> <class name="Dept" table="t_Dept" > <id name="deptId"> <generator class="native"></generator> </id> <property name="deptName" length="20"></property> <!-- 一对多关联映射配置(通过部门管理到员工) Dept 映射关键点 1、指定映射的集合属性: "emps" 2、集合属性对应的集和表 "t_employee" 3、集合表的外键字段 "t_employee中的dept_id 4、集合元素的类型 --> <set name="emps" table="t_Employee"> <key column="dept_id"></key> <one-to-many class="Employee"/> </set> </class> </hibernate-mapping>
3、写测试类进存储
package com.gqx.onetomany;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class Demo {
private static SessionFactory sf;
static{
sf=new Configuration().
configure().
addClass(Dept.class).addClass(Employee.class)
.buildSessionFactory();
}
/**
* 保存:部门方【一的一方】
*/
@Test
public void test() {
Session session=sf.openSession();
session.beginTransaction();
//部门对象
Dept dept=new Dept();
dept.setDeptName("前端组");
//员工对象
Employee emp1=new Employee();
emp1.setEmpName("张三");
Employee emp2=new Employee();
emp2.setEmpName("李四");
//关系
dept.getEmps().add(emp1);
dept.getEmps().add(emp2);
//保存
session.save(dept);
session.save(emp1);
session.save(emp2);
session.getTransaction().commit();
session.close();
/* 结果
*Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
*Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
*Hibernate: insert into t_Dept (deptName) values (?)
*Hibernate: update t_Employee set deptId=? where empId=?
*Hibernate: update t_Employee set deptId=? where empId=?
*
*为什么会有五条sql语句?
*开始的时候先插入员工,并没有部门,一旦部门加入后,通过update的语句维护两者的关系
*/
}
/**
* 保存:员工方【多的一方】
*/
@Test
public void test2() {
Session session=sf.openSession();
session.beginTransaction();
//部门对象
Dept dept=new Dept();
dept.setDeptName("运维组");
//员工对象
Employee emp1=new Employee();
emp1.setEmpName("王五");
Employee emp2=new Employee();
emp2.setEmpName("老刘");
//关系
emp1.setDept(dept);
emp2.setDept(dept);
//保存
session.save(emp1);
session.save(emp2);
session.save(dept);
session.getTransaction().commit();
session.close();
/* 结果
*Hibernate: insert into t_Dept (deptName) values (?)
*Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
*Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
*
*如果将session.save(dept)放到两个员工的下方 结果为:
* Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_Employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_Dept (deptName) values (?)
Hibernate: update t_Employee set empName=?, salary=?, dept_id=? where empId=?
Hibernate: update t_Employee set empName=?, salary=?, dept_id=? where empId=?
*/
}
}
存储之后,如果要获取数据,则、
package com.gqx.onetomany;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class DemoGet {
private static SessionFactory sf;
static{
sf=new Configuration().
configure().
addClass(Dept.class).addClass(Employee.class)
.buildSessionFactory();
}
@Test
public void test() {
Session session=sf.openSession();
session.beginTransaction();
//通过部门方获取另外一方
Dept dept=(Dept)session.get(Dept.class, 1);
System.out.println(dept.getDeptName());
Set<Employee> set=dept.getEmps();
Iterator<Employee> iterators=set.iterator();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
Employee employee = (Employee) iterator.next();
System.out.println(employee.getEmpName());
}
session.getTransaction().commit();
session.close();
}
@Test
public void test2() {
Session session=sf.openSession();
session.beginTransaction();
//通过员工方获取另外一方
Employee employee=(Employee)session.get(Employee.class, 1);
System.out.println(employee.getEmpName());
System.out.println(employee.getDept().getDeptName());
session.getTransaction().commit();
session.close();
}
}
总结:
在一对多与多对一的关联关系中,保存数据最好的通过多的一方来维护关系,这样可以减少update语句的生成,从而提高hibernate的执行效率!
配置一对多与多对一,这种叫“双向关联”
只配置一对多, 叫“单项一对多”
只配置多对一, 叫“单项多对一”
注意:
配置了哪一方,哪一方才有维护关联关系的权限!
js:强大的splice
<!DOCTYPE HTML>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>无标题文档</title>
</head>
<body>
<input type="text">
<br>
<input type="checkbox" value="html">html
<br>
<input type="checkbox" value="js">js
<br>
<input type="checkbox" value="css">css
<br>
<input type="checkbox" value="jquery">jquery
<br>
<script>
/* array.splice(start, deleteCount[, item1[, item2[, ...]]])
哪一位开始修改内容 / 移除的数组元素的个数 / 要添加进数组的元素。如果不指定,则 splice() 只删除数组元素
var arr = ['a','b','c','d','e','f'];
var a = arr.splice( 1 , 2 , 'x' , 'y' ,'z' );
console.log(arr);
会打印出["a", "x", "y", "z", "d", "e", "f"]
将arr中索引为1(从0开始)的后两位删除,同时添加'x','y','z'
*/
var aInput = document.getElementsByTagName('input');
for (var i = aInput.length - 1; i >= 0; i--) {
aInput[i].onclick = function() {
if (this.checked) {
if (aInput[0].value == '') {
aInput[0].value += this.value;
} else {
aInput[0].value += ',' + this.value;
}
} else {
var arr = aInput[0].value.split(',');
for (var i = arr.length - 1; i >= 0; i--) {
if (arr[i] == this.value) {
//第二个参数表示从数组中的第i个元素开始删除一个元素
console.log(arr);
arr.splice(1, 1);
console.log(arr);
}
}
aInput[0].value = arr;
}
}
}
</script>
</body>
</html>
Hibernate的集合一对多与多对一的更多相关文章
- (转)Hibernate关联映射——一对多(多对一)
http://blog.csdn.net/yerenyuan_pku/article/details/70152173 Hibernate关联映射——一对多(多对一) 我们以客户(Customer)与 ...
- Hibernate在关于一对多,多对一双向关联映射
[Hibernate]之关于一对多,多对一双向关联映射 因为一对多.和多对一的双向关联映射基本上一样,所以这里就一起写下来! Annotations配置 @Entity @Table(name=&qu ...
- Hibernate一对一、一对多、多对多注解映射配置
一对一: 一对多: 多对多:
- Hibernate关联关系配置(一对多,一对一,多对多)
一对多 创建两个类 Manager(一这一端) Worker(多这一端) 即一个经理下有多个员工 package com.hibernate.n21; import java.util.HashS ...
- 三大框架 之 Hibernate查询(一对多、多对多、查询关系)
目录 一对多 表之间关系 表之间关系建表原则 一对多关系配置 建立表 建立ORM 添加配置文件 在hibernate.cfg.xml中的标签里,添加核心配置文件 引入工具类 编写测试类 级联操作 什么 ...
- Hibernate中的一对多与多对一映射
1.需求 一个部门有多个员工; [一对多] 多个员工,属于一个部门 [多对一] 2.实体Bean设计 Dept: public class Dept { private int ...
- Hibernate 一对一、一对多、多对多注解mappedBy属性的总结
mappedBy: 所填内容必为本类在另一方的字段名. 表示:本类放弃控制关联关系,所有对关联关系的控制,如:建立.解除与另一方的关系,都由对方控制,本类不管.举个例子: Teacher和Studen ...
- Hibernate 一对一、一对多、多对多注解cascade属性的总结
作用:是否级联被注解字段里面的对象.可选值:javax.persistence.CascadeType.PERSIST, MERGE, REMOVE, REFRESH, DETACH, ALL.可选其 ...
- hibernate annotation 之 一对多、多对一双向外键关联
假设,一个农场产出多种植物,具体的某一植物产于某一农场. 3 import java.io.Serializable; 4 import java.util.Set; 5 import javax.p ...
随机推荐
- classmethod,staticmethod
'''1 绑定方法: 在类内部定义的函数,默认就是给对象来用,而且是绑定给对象用的,称为对象的绑定方法 绑定对象的方法特殊之处: 应该由对象来调用,对象来调用,会自动将对象当作第一个参数传入 绑定到类 ...
- day25(令牌机制)
令牌机制 作用:处理页面重复提交,造成数据多次写入数据库. 使用方法: 类似于验证码机制,使用session记录一个不可能重复的值(Uuid)在访问controller时对session进行校验. / ...
- 关于python logging的 NOTSET 级别
说重点: NOTSET 意指不设置 所以按照父logger级别来过滤日志 注意 不是最低级别的意思 由于logging中root日志对象的默认级别是WARNING, 所以当你使用logging.get ...
- android上的i-jetty (1)环境搭建
介绍下如果把android设备作为一个web服务器使用, 编译i-jetty 1. 将源码download下来,http://code.google.com/p/i-jetty/downloads/l ...
- 从MS Word到Windows Live Writer
在做笔记的时候,喜欢使用Word进行排版及插入图片,但是当将笔记发布的时候,一般的网站是不支持直接将Word中的图片进行上传的,此时使用Windows Live Writer是一个不错的选择. 可是, ...
- Android自适应屏幕的实现方法
首先我们先了解下手机分辨率 分辨率是指屏幕上有横竖各有多少个像素目前手机分辨率大概情况如下: QVGA 分辨率:320×240 简 介:QVGA即"Quarter VGA". ...
- Python自动化开发 - 面向对象(一)
本节内容 1.编程范式 面向过程编程 面向对象编程 2.面向对象编程介绍 类的语法 类与实例内存分配 构造方法 自定义方法 3.面向对象特性 一.编程范式 编程是程序员 用特定的语法+数据结构+算法组 ...
- headpq
从一个集合中获得最大或者最小的N个元素列表 http://python3-cookbook.readthedocs.io/zh_CN/latest/c01/p04_find_largest_or_sm ...
- <string.h>的学习
感觉学习代码库最好的方法就是运行一下. 下面附上结果和示例代码 #include <stdio.h> #include <string.h> int main(){ const ...
- 解决SHAREJPOINT 跨域问题
目前仅支持IE7/8不支持IE11和谷歌 对于跨域情况,目前找到如果jquery是get获取方式,可以配置web.config相关属性,具体powershell命令如下: Add-PSSnapin M ...