Hibernate中用注解配置一对多双向关联和多对一单向关联

最新推荐文章于 2017-12-02 00:17:21 发布
最新推荐文章于 2017-12-02 00:17:21 发布
阅读量664 收藏 1
点赞数
分类专栏： sql hibernate

http://www.cnblogs.com/hmy-1365/p/5790087.html

Hibernate中用注解配置一对多双向关联和多对一单向关联

 

 Hibernate提供了Hibernate Annotations扩展包，使用注解完成映射。在Hibernate3.3之前，需单独下载注解开发包

 

配置持久化类

配置关联关系

 下面我们先从多对一单向关联关系讲起，多对一单向关联就是在多的一方植入一的一方的主键作为外键，下面我们先进行初始配置，

 

在配置的过程中我们会遇到一个问题  就是无论用load还是get都不会出现延迟加载，那么我们应该如何设置为要延迟加载，这样做的好处是可以在用的时候才加载对应的信息，节约内存

 

hibernate中，延迟加载大致可以分为两类，一类是延迟属性加载，另一类是延迟关联实体加载。

 

普通属性：分两种情况，一种是集合属性，一种是非集合属性（如String、Integer......）

集合属性的延迟加载通过PersistentSet、 PersistentList、PersistentBag、PersistentMap、PersistentSortedMap、 PersistentSortedSet作为代理类来实现，代理类中保存了session以及owner属性，owner属性表示了集合属性所属的one 侧的实体。

 

非集合类属性的延迟加载相对比较复杂。仅通过@Basic(fetch = FetchType.LAZY)注解是无法实现延迟加载的。需要让实体实现FieldHandled接口，声明FieldHandler属性，通过拦截器 原理注入对应的FieldHandler属性，起到类似于上述代理类的作用，FieldHandler同样也保持了session，以及需要延迟加载的属 性。

 

我们发现对非集合属性即时设置了@Basic(fetch = FetchType.LAZY)仍无法实现延迟加载，可以看生成的sql语句

 

接下来 我们会对一对多单向关联进行测试，验证对集合类属性，是否可以起到延迟加载的功能

 

注意：不可以对有关联关系的属性设置@Transient

 

 

配置多对一的单向关联关系  示例

复制代码 
 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 @Entity
17 @Table(name = "EMP")
18 public class Emp {
19     @Id
20     @Column(name = "EMPNO")
21     @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "emp_num")
22     @SequenceGenerator(name = "emp_num", sequenceName = "emp_num_id", allocationSize = 1, initialValue = 1)
23     private Integer empNo;
24 
25     @Column(name = "EMPNAME")
26     private String empName;
27     
28     @ManyToOne()
29     @JoinColumn(name = "DEPTNO")
30     /*@Basic(fetch=FetchType.LAZY)*/
31     private Dept dept;
32 
33     
34     public Emp() {
35         super();
36     }
37 
38     public Emp(Integer empNo, String empName) {
39         super();
40         this.empNo = empNo;
41         this.empName = empName;
42     }
43 
44     public Integer getEmpNo() {
45         return empNo;
46     }
47 
48     public void setEmpNo(Integer empNo) {
49         this.empNo = empNo;
50     }
51 
52     public String getEmpName() {
53         return empName;
54     }
55 
56     public void setEmpName(String empName) {
57         this.empName = empName;
58     }
59 
60     public Dept getDept() {
61         return dept;
62     }
63 
64     public void setDept(Dept dept) {
65         this.dept = dept;
66     }
67 }
复制代码
复制代码 
 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 import org.hibernate.annotations.Cascade;
19 
20 @Entity
21 @Table(name = "DEPT")
22 public class Dept {
23     @Id
24     @Column(name = "DEPTNO")
25     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
26     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
27     private Integer deptNo;
28 
29     @Column(name = "DEPTNAME")
30     private String deptName;
31 
32 
33     public Integer getDeptNo() {
34         return deptNo;
35     }
36 
37     public void setDeptNo(Integer deptNo) {
38         this.deptNo = deptNo;
39     }
40 
41     public String getDeptName() {
42         return deptName;
43     }
44 
45     public void setDeptName(String deptName) {
46         this.deptName = deptName;
47     }
48 }
复制代码

 

复制代码 
 1 /**
 2      * 注解测试多对一映射   员工表（多）对应部门表（一）的映射,即只在员工表中植入部门表的信息
 3      * */
 4     @Test
 5     public void manytooneSingle(){
 6         
 7         /**
 8          * 查询操作
 9          * **/
10         /*SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();
11         Session session = sf.openSession();
12         
13         Emp emp=(Emp)session.load(Emp.class, 4);
14         
15         System.out.println(emp.getEmpName()+"\t"+emp.getDept().getDeptName());*/
16         
17         /**
18          * 添加操作
19          * **/
20         SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();
21         Session session = sf.openSession();
22         Transaction tx = session.beginTransaction();
23         Dept dept = (Dept)session.load(Dept.class, 3);
24         
25         Emp emp=new Emp();
26         emp.setEmpName("户梦艳");
27         emp.setEmpNo(001);
28         emp.setDept(dept);
29         
30         Emp emp2=new Emp();
31         emp2.setEmpName("户梦艳2");
32         emp2.setEmpNo(002);
33         emp2.setDept(dept);
34         
35         session.save(emp);
36         session.save(emp2);
37         tx.commit();
38         session.close();
39         
40         
41     }
复制代码

 

一对多双单向配置

复制代码 
 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 
19 @Entity
20 @Table(name="Dept")
21 public class Dept {
22     @Id    
23     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
24     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
25     private Integer deptNo;
26     @Column
27     private String deptName;
28     
29     
30     @OneToMany(cascade={CascadeType.ALL})
31     @JoinColumn(name="deptno")
32     private Set<Emp> emps=new HashSet<Emp>();
33 
34     public Set<Emp> getEmps() {
35         return emps;
36     }
37 
38     public void setEmps(Set<Emp> emps) {
39         this.emps = emps;
40     }
41 
42     public Integer getDeptNo() {
43         return deptNo;
44     }
45 
46     public void setDeptNo(Integer deptNo) {
47         this.deptNo = deptNo;
48     }
49 
50     public String getDeptName() {
51         return deptName;
52     }
53 
54     public void setDeptName(String deptName) {
55         this.deptName = deptName;
56     }
57 }
复制代码

 

复制代码 
 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 import org.hibernate.bytecode.javassist.FieldHandled;
17 import org.hibernate.bytecode.javassist.FieldHandler;
18 
19 
20 @Entity
21 @Table(name = "EMP")
22 public class Emp {
23     
24     
25     
26     @Id
27     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")
28     @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9)
29     private Integer empNo;
30 
31     @Column
32     private String empName;
33     
34    
35 //    @ManyToOne
36 //    @JoinColumn(name="deptno")
37 //    @Basic(fetch=FetchType.LAZY)
38 //    private Dept dept;
39 //    
40 //    public Dept getDept() {
41 //        return dept;
42 //    }
43 //
44 //    public void setDept(Dept dept) {
45 //        this.dept = dept;
46 //    }
47 
48     public Emp() {
49         super();
50     }
51 
52     public Emp(Integer empNo, String empName) {
53         super();
54         this.empNo = empNo;
55         this.empName = empName;
56     }
57 
58     public Integer getEmpNo() {
59         return empNo;
60     }
61 
62     public void setEmpNo(Integer empNo) {
63         this.empNo = empNo;
64     }
65 
66     public String getEmpName() {
67         return empName;
68     }
69 
70     public void setEmpName(String empName) {
71         this.empName = empName;
72     }
73     
74 
75 }
复制代码

 

复制代码 
 1 /**
 2      * 测试一对多单向添加操作
 3      * */
 4     @Test
 5     public void insertOneToManySingle(){
 6         Emp emp=new Emp();
 7         emp.setEmpName("李小鹏");
 8         
 9         Emp emp2=new Emp();
10         emp2.setEmpName("王想想");
11         
12         Dept dept=new Dept();
13         dept.setDeptName("教务部");
14         //设置级联操作
15         dept.getEmps().add(emp);
16         dept.getEmps().add(emp2);
17         
18         session.save(dept);
19         tx.commit();
20         System.out.println("insert ok");
21         
22     }
复制代码

 

复制代码 
 1     /**
 2      * 测试一对多单向查询操作
 3      * */
 4     @Test
 5     public void selectOneToManySingle(){
 6         Dept dept = (Dept)session.load(Dept.class, 1);
 7         System.out.println("======================");
 8         System.out.println("部门名称:"+dept.getDeptName());
 9         System.out.println("=======================");
10         //体现了延迟加载
11         for (Emp emp : dept.getEmps()) {
12             System.out.println("雇员名称："+emp.getEmpName());
13         }
14         //Emp emp = (Emp)session.load(Emp.class, 1);
15         
16         
17     }
复制代码

 

 

一对多双向配置

复制代码 
 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 
19 @Entity
20 @Table(name="Dept")
21 public class Dept {
22     @Id    
23     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
24     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
25     private Integer deptNo;
26     @Column
27     private String deptName;
28     
29     
30     @OneToMany(mappedBy="dept",cascade={CascadeType.ALL})
31    
32     private Set<Emp> emps=new HashSet<Emp>();
33 
34     public Set<Emp> getEmps() {
35         return emps;
36     }
37 
38     public void setEmps(Set<Emp> emps) {
39         this.emps = emps;
40     }
41 
42     public Integer getDeptNo() {
43         return deptNo;
44     }
45 
46     public void setDeptNo(Integer deptNo) {
47         this.deptNo = deptNo;
48     }
49 
50     public String getDeptName() {
51         return deptName;
52     }
53 
54     public void setDeptName(String deptName) {
55         this.deptName = deptName;
56     }
57 }
复制代码

 

复制代码 
 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 import org.hibernate.bytecode.javassist.FieldHandled;
17 import org.hibernate.bytecode.javassist.FieldHandler;
18 
19 
20 @Entity
21 @Table(name = "EMP")
22 public class Emp {
23     
24     
25     
26     @Id
27     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")
28     @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9)
29     private Integer empNo;
30 
31     @Column
32     private String empName;
33     
34    
35     @ManyToOne
36     @JoinColumn(name="deptno")
37     @Basic(fetch=FetchType.LAZY)
38     private Dept dept;
39     
40     public Dept getDept() {
41         return dept;
42     }
43 
44     public void setDept(Dept dept) {
45         this.dept = dept;
46     }
47 
48     public Emp() {
49         super();
50     }
51 
52     public Emp(Integer empNo, String empName) {
53         super();
54         this.empNo = empNo;
55         this.empName = empName;
56     }
57 
58     public Integer getEmpNo() {
59         return empNo;
60     }
61 
62     public void setEmpNo(Integer empNo) {
63         this.empNo = empNo;
64     }
65 
66     public String getEmpName() {
67         return empName;
68     }
69 
70     public void setEmpName(String empName) {
71         this.empName = empName;
72     }
73     
74 
75 }
复制代码

 

 

复制代码 
 1     /**
 2      * 双向一对多的添加操作
 3      * */
 4     @Test 
 5     public void oneToManyDouble(){
 6         Dept dept=new Dept();
 7         dept.setDeptName("财务部");
 8         
 9         Emp emp=new Emp();
10         emp.setEmpName("邹乐");
11         emp.setDept(dept);
12         
13         Emp emp2=new Emp();
14         emp2.setEmpName("范子阳");
15         emp2.setDept(dept);
16         
17         
18         dept.getEmps().add(emp);
19         dept.getEmps().add(emp2);
20         
21         session.save(dept);
22         tx.commit();
23     }
24
复制代码

 

复制代码 
 1 /**
 2      * 双向一对多的查询操作
 3      * */
 4     @Test 
 5     public void selectOneToManyDouble(){
 6         
 7         Dept dept = (Dept)session.load(Dept.class, 1);
 8         System.out.println("部门名称："+dept.getDeptName());
 9         for (Emp emp : dept.getEmps()) {
10             System.out.println("职工姓名："+emp.getEmpName());
11         }
12         
13         System.out.println("==================================================");
14         
15         Emp emp = (Emp)session.load(Emp.class, 1);
16         System.out.println("职工姓名："+emp.getEmpName()+"\t部门名称："+emp.getDept().getDeptName());
17     }
18
复制代码

 


singtorain
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate一对多关联双向关联代码实现分享
09-04
Hibernate一对多关联双向关联代码实现分享,大家参考使用吧
07-hibernate注解-一对多（多对一）双向外键关联
weixin_34162629的博客
11-13 100
一对多（多对一）双向外键 多方：多方持有一方的引用。 @ManyToOne(cascade={CasCadeType.ALL},fetch=FetchType.EAGER) @JoinColumn(name="cid") 一方：一方持有多方的集合。 @OneToMany(@cascade={CascadeType.ALL},fetch=FetchType.LAZY) @JoinColumn(nam...
hibernate中实体关联的注解写法（一对多，多对一）
David_Tsai23的专栏
12-01 1378
1.多对一的单向关联 例如一个人有多个梦想，而一个梦想属于一个人（这个假设可能不是很贴合实际，理解就行），这时候我们需要一个Person类、一个Dream类； 那么我们怎么写注解呢？其实很简单，只需要在多的一方定义一个属性在该属性get方法上加@ManyToOne注解即可 Person类 package vo; import javax.persistence.Entity; impo
Hibernate一对多双向注解配置实例
gongzhufanlulu的博客
04-29 4720
*customer和order是一对多的关系，一个用户可以有多条订单，一条订单只能从属于一个用户。 所以，customer是一的一方，order是多的一方。*package com.lejuad.lejuadhome.manager.entity;import java.io.Serializable; import java.util.List;import javax.annotation.G
Hibernate之关于一对多，多对一双向关联映射
诺言永远依恋小柴、、、
10-28 2322
【Hibernate】之关于一对多，多对一双向关联映射
hibernate一对多关联映射学习小结
08-29
主要介绍了hibernate一对多关联映射学习小结,需要的朋友可以参考下
hibernate3.2级联关系自身一对多双向关联
03-23
hibernate3.2级联关系自身一对多双向关联，适合初学者熟悉hibernate框架。
JSP开发之hibernate之单向多对一关联的实例
10-19
主要介绍了JSP开发之hibernate之单向多对一关联的实例的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
hibernate单向一对多关联映射(注解版)
05-04
hibernate单向一对多关联映射(注解版)
hibernate 多对多全注解（单向关联、双向关联）
09-13
hibernate关联映射注解多对多单向关联、
关于hibernate的多对一单向关联，一对多单向关联，和一对多双向关联的疑惑解答
Real的专栏
08-28 3855
转载：http://yanghelinok.blog.163.com/blog/static/4636027220146974240760/ hibernate提供的多对一，一对多给面向对象的开发提供了更多的操作便捷，但是也引发了不少问题。 也许很多人还不知道单向关联和双向关联有什么区别？那就先来说说这两者间的异同。 单向关联：是指在实体的一端进行关系的维护，直接通过一端的操作实现业
Hibernate的一对多关联关系（单向和双向）
Alan_Xiang的博客
12-04 5261
在领域模型中，类与类之间最普遍的关系就是关联关系。在 UML 中，关联是有方向的。以 Customer 和 Order 为例：一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。 　　单向n-1的关联关系　　单向 n-1 关联只需从 n 的一端可以访问 1 的一端。 　　域模型：从
hibernate一对多多对多映射（注解）
qq_21911655的博客
12-02 1万+
4，一对多多对一单向关联 –@ManyToOne：在多的一方维护记录（在tuser2表维护记录） （1）表结构：tuser2表的groupid字段关联tgroup表的主键id，tuser2是多的一方，tgroup是一的一方： （2）bean： @Entity @Table(name="tuser2") public class TUser2 implements Seriali...
Hibernate 注解单向一对多配置
热门推荐
SwingLife的专栏
12-10 1万+
/***  * Plate表  * @author Swing  *  */ @Entity @Table(name = "tb_Plate") public class Plate implements Serializable  { private static final long serialVersionUID = 1L; private int id; privat
Hibernate 单向多对一、单向一对多、双向一对多关联关系详解
暖心~的博客
09-19 5661
一对多关系是最普遍的映射关系。比如部门和职工 一对多：从部门的角度，一个部门对应多个职工 多对一：从职工的角度，多个职工对应一个部门 数据库表中结构： 表 department：did departname 表 Employee：eid   ename   esex   did 工具类：SessionFactoryUtils .java，用来创建session工厂，后面的测试类的代码中
springboot(酒店管理系统)
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
BP神经网络matlab实例.doc
最新发布
04-25
数学模型算法
hibernate 一对多注解
07-28
更多关于Hibernate一对多注解的详细信息可以参考\[1\]中提供的链接。 #### 引用[.reference_title] - *1* *2* [Hibernate 中一对多的 注解 问题](https://blog.csdn.net/CapMiachael/article/details/51537867)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值