Hibernate用注解方式实现一对多、多对多关系
一、一对多关系
1、在上一篇日志中用.xml配置文件项目基础上，再往lib目录先添加一个包-hibernate-jpa-2.0-api-1.0.0.Final.jar
2、新建一个com.st.bean4 包，往包里面添加两个含有注解的类：
a)、DeptBean2类：
1 package com.st.bean4;
2
3 import java.util.HashSet;
4 import java.util.Set;
5
6
7 import javax.persistence.Column;
8 import javax.persistence.Entity;
9 import javax.persistence.GeneratedValue;
10 import javax.persistence.Id;
11 import javax.persistence.JoinColumn;
12 import javax.persistence.OneToMany;
13 import javax.persistence.Table;
14
15 import org.hibernate.annotations.Cascade;
16 import org.hibernate.annotations.CascadeType;
17 import org.hibernate.annotations.GenericGenerator;
18
19 @Entity //指定实体类
20 @Table(name="DEPT") //对应表的名称
21 @GenericGenerator(name="genID", strategy="increment") //声明主键生成策略
22 public class DeptBean2 {
23 @Id //指定主键
24 @GeneratedValue(generator="genID") //设定主键生成策略
25 @Column(name="ID") //指定类中的属性与表中的列的对应关系
26 private long id;
27 @Column(name="NAME") //指定类中的属性与表中的列的对应关系
28 private String name;
29
30 @OneToMany //指定一对多关系
31 @Cascade(value={CascadeType.SAVE_UPDATE}) //设定级联关系
32 @JoinColumn(name="dept_id") //指定与本类主键所对应的外表的外键
33 private Set<EmployeeBean2> emp = new HashSet<EmployeeBean2>();
34 @Override
35 public String toString() {
36 return "DeptBean [id=" + id + ", name=" + name +"]";
37 }
38 public long getId() {
39 return id;
40 }
41 public void setId(long id) {
42 this.id = id;
43 }
44 public String getName() {
45 return name;
46 }
47 public void setName(String name) {
48 this.name = name;
49 }
50 public Set<EmployeeBean2> getEmp() {
51 return emp;
52 }
53 public void setEmp(Set<EmployeeBean2> emp) {
54 this.emp = emp;
55 }
56 }
b）、EmployeeBean类：
1 package com.st.bean4;
2
3 import javax.persistence.Column;
4 import javax.persistence.Entity;
5 import javax.persistence.GeneratedValue;
6 import javax.persistence.Id;
7 import javax.persistence.JoinColumn;
8 import javax.persistence.ManyToOne;
9 import javax.persistence.Table;
10
11 import org.hibernate.annotations.GenericGenerator;
12
13 @Entity //指定一个实体
14 @Table(name="employee") //指定表的名称
15 @GenericGenerator(name="genID", strategy="increment") //声明主键生成策略
16 public class EmployeeBean2 {
17 @Id //指定主键
18 @GeneratedValue(generator="genID") //设定主键生成策略
19 @Column(name="ID") //类中的属性和表中的列名的对应关系
20 private long id;
21 @Column(name="NAME")
22 private String name;
23 @Column(name="SEX")
24 private String sex;
25 @Column(name="JOB")
26 private String job;
27 @ManyToOne// 指定多对一关系 //指定多对一关系
28 @JoinColumn(name="DEPT_ID")
29 //一个员工对应于一个部门号，所以这里不用集合
30 private DeptBean2 dept ; //注意这个地方不要new对象，否则会无法运行
31 public long getId() {
32 return id;
33 }
34 public void setId(long id) {
35 this.id = id;
36 }
37 public String getName() {
38 return name;
39 }
40 public void setName(String name) {
41 this.name = name;
42 }
43 public String getSex() {
44 return sex;
45 }
46 public void setSex(String sex) {
47 this.sex = sex;
48 }
49 public String getJob() {
50 return job;
51 }
52 public void setJob(String job) {
53 this.job = job;
54 }
55 public DeptBean2 getDept() {
56 return dept;
57 }
58 public void setDept(DeptBean2 dept) {
59 this.dept = dept;
60 }
61 @Override
62 public String toString() {
63 return "EmployeeBean [id=" + id + ", name=" + name + ", sex=" + sex
64 + ", job=" + job + ", dept=" + dept
65 + "]";
66 }
67 }
3、在hibernate.cfg.xml文件中引入上面两个类的映射
1 <mapping class="com.st.bean5.UserBean2" />
2 <mapping class="com.st.bean5.RoleBean2" />
4、在BeanTest中添加相应的测试方法：
1 @Test
2 public void bean4test1(){
3 Session session = HibernateTools.openSession();
4 Transaction tran = session.beginTransaction();
5 //首先在dept中新增一条数据，再关联的在employee中新增一条数据
6 //DeptBean2 dept = new DeptBean2();
7 //先读去dept中的数据，再在读取的基础上关联的在employee中新增一条数据
8 DeptBean2 dept = (DeptBean2) session.get(DeptBean2.class,1L); //1L代表主键
9 EmployeeBean2 emp = new EmployeeBean2();
10 //dept.setName("技术部");
11 emp.setName("陈泽俊");
12 emp.setSex("男");
13 emp.setJob("STM32");
14 dept.getEmp().add(emp);
15 session.save(dept);
16 //确认提交事物
17 tran.commit();
18 }
二、多对多关系
1、新建一个com.st.bean4 包，往包里面添加两个含有注解的类
a）、UserBean2：
1 package com.st.bean5;
2 import java.util.HashSet;
3 import java.util.Set;
4
5 import javax.persistence.Column;
6 import javax.persistence.Entity;
7 import javax.persistence.GeneratedValue;
8 import javax.persistence.Id;
9 import javax.persistence.JoinColumn;
10 import javax.persistence.JoinTable;
11 import javax.persistence.ManyToMany;
12 import javax.persistence.Table;
13
14 import org.hibernate.annotations.Cascade;
15 import org.hibernate.annotations.CascadeType;
16 import org.hibernate.annotations.GenericGenerator;
17
18 @Entity //实体
19 @Table(name="T_USER") //表名
20 @GenericGenerator(name="genID", strategy="increment") //声明主键生成策略
21 public class UserBean2 {
22 @Id //指定主键
23 @GeneratedValue(generator="genID") //设定主键生成策略
24 @Column(name="ID") //指定类的属性和表的字段的对应关系
25 private long id;
26 @Column(name="NAME")
27 private String name;
28 @Column(name="SEX")
29 private String sex;
30 @ManyToMany //指定多对多关系
31 @Cascade(value={CascadeType.SAVE_UPDATE}) //设置级联关系
32 @JoinTable(name="USER_ROLE", //指定第三张表
33 joinColumns={@JoinColumn(name="USER_ID")}, //本表与中间表的外键对应
34 inverseJoinColumns={@JoinColumn(name="ROLE_ID")}) //另一张表与第三张表的外键的对应关系
35 private Set<RoleBean2> role = new HashSet<RoleBean2>();
36 public long getId() {
37 return id;
38 }
39 public void setId(long id) {
40 this.id = id;
41 }
42 public String getName() {
43 return name;
44 }
45 public void setName(String name) {
46 this.name = name;
47 }
48 public String getSex() {
49 return sex;
50 }
51 public void setSex(String sex) {
52 this.sex = sex;
53 }
54 public Set<RoleBean2> getRole() {
55 return role;
56 }
57 public void setRole(Set<RoleBean2> role) {
58 this.role = role;
59 }
60 @Override
61 public String toString() {
62 return "UserBean [id=" + id + ", name=" + name + ", sex=" + sex
63 + ", role=" + role + "]";
64 }
65 }
b）、RoleBean类：
1 package com.st.bean5;
2 import java.util.HashSet;
3
4 import java.util.Set;
5
6 import javax.persistence.Column;
7 import javax.persistence.Entity;
8 import javax.persistence.GeneratedValue;
9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.JoinTable;
12 import javax.persistence.ManyToMany;
13 import javax.persistence.Table;
14
15 import org.hibernate.annotations.Cascade;
16 import org.hibernate.annotations.CascadeType;
17 import org.hibernate.annotations.GenericGenerator;
18
19 @Entity //实体
20 @Table(name="T_ROLE") //表名
21 @GenericGenerator(name="genID", strategy="increment")//声明主键生成策略
22 public class RoleBean2 {
23 @Id //主键
24 @GeneratedValue(generator="genID") //设置主键生成策略
25 @Column(name="ID") //类中的属性与表的字段的对应关系
26 private long id;
27 @Column(name="POST")
28 private String post;//职位
29 @Column(name="PAY")
30 private int pay; //薪资
31 @ManyToMany //多对多关系
32 @Cascade(value={CascadeType.SAVE_UPDATE}) //级联关系
33 @JoinTable(name="USER_ROLE", //中间表的名称
34 joinColumns={@JoinColumn(name="ROLE_ID")}, //本表与中间表的外键对应关系
35 inverseJoinColumns={@JoinColumn(name="USER_ID")}) //另一张表与中间表的外键的对应关系
36 private Set<UserBean2> user = new HashSet<UserBean2>();
37
38 public long getId() {
39 return id;
40 }
41 public void setId(long id) {
42 this.id = id;
43 }
44 public String getPost() {
45 return post;
46 }
47 public void setPost(String post) {
48 this.post = post;
49 }
50 public int getPay() {
51 return pay;
52 }
53 public void setPay(int pay) {
54 this.pay = pay;
55 }
56 public Set<UserBean2> getUser() {
57 return user;
58 }
59 public void setUser(Set<UserBean2> user) {
60 this.user = user;
61 }
62 @Override
63 public String toString() {
64 return "RoleBean [id=" + id + ", post=" + post + ", pay=" + pay + "]";
65 }
66 }
2、在hibernate.cfg.xml中引入UserBean2和RoleBean2这两个类的映射：
1 <mapping class="com.st.bean5.UserBean2" />
2 <mapping class="com.st.bean5.RoleBean2" />
3、在BeanTest类中添加测试方法：
1 @Test
2 public void bean5test1(){
3 // 获取一个会话
4 Session session = HibernateTools.openSession();
5 //开启一次事物
6 Transaction tran = session.beginTransaction();
7 UserBean2 user = new UserBean2();
8 // RoleBean2 role = (RoleBean2) session.get(RoleBean2.class,1L);
9 RoleBean2 role = new RoleBean2();
10
11 user.setName("汪文仕");
12 user.setSex("男");
13
14 role.setPost("博士");
15 role.setPay(10000);
16
17 role.getUser().add(user);
18 session.save(role);
19 //确认提交事物
20 tran.commit();
21 }
22 @Test
23 public void bean5test2(){
24 // 获取一个会话
25 Session session = HibernateTools.openSession();
26 /* List<UserBean> list = session.createCriteria(UserBean.class).list();
27 for(UserBean user : list)
28 System.out.println(user);*/
29 String hql = "select new Map(u.name as name,u.sex as sex,r.post as post,r.pay as pay) from UserBean2 u join u.role r";
30 List<Map<String,Object>> list = session.createQuery(hql).list();
31 for(Map<String,Object> data : list)
32 System.out.println(data);
33 }
三、注意：
1、引入了注解需要的jar包后要先删除Java EE 5 Library这个库，否则会两个jar包中的类产生冲突
2、在多表操作时最好设置级联关系，不然对表操作时要先读取一个类的数据，再将新建的一个类的数据添加到这个类上才成功对三张表同时操作。
Hibernate用注解方式实现一对多、多对多关系的更多相关文章
- 2.2、Hibernate用注解方式实现一对多、多对多关系
一.一对多关系 1.在上一篇日志中用.xml配置文件项目基础上,再往lib目录先添加一个包-hibernate-jpa-2.0-api-1.0.0.Final.jar 2.新建一个com.st.bea ...
- hibernate annotation注解方式来处理映射关系
在hibernate中,通常配置对象关系映射关系有两种,一种是基于xml的方式,另一种是基于annotation的注解方式,熟话说,萝卜青菜,可有所爱,每个人都有自己喜欢的配置方式,我在试了这两种方式 ...
- JPA实体关系映射：@ManyToMany多对多关系、@OneToMany@ManyToOne一对多多对一关系和@OneToOne的深度实例解析
JPA实体关系映射:@ManyToMany多对多关系.@OneToMany@ManyToOne一对多多对一关系和@OneToOne的深度实例解析 今天程序中遇到的错误一 org.hibernate.A ...
- SSAS中事实表中的数据如果因为一对多或多对多关系复制了多份，在维度上聚合的时候还是只算一份
SSAS事实表中的数据,有时候会因为一对多或多对多关系发生复制变成多份,如下图所示: 图1 我们可以从上面图片中看到,在这个例子中,有三个事实表Fact_People_Money(此表用字段Money ...
- Hibernate基于注解方式配置来实现实体和数据库之间存在某种映射关系
实体和数据库之间存在某种映射关系,hibernate根据这种映射关系完成数据的存取.在程序中这种映射关系由映射文件(*.hbm.xml)或者java注解(@)定义. 本文以java注解的形式总结映射关 ...
- hibernate中一对多多对一关系设计的理解
1.单向多对一和双向多对一的区别? 只需要从一方获取另一方的数据时 就使用单向关联双方都需要获取对方数据时 就使用双向关系 部门--人员 使用人员时如果只需要获取对应部门信息(user.getdept ...
- SQLAlchemy_定义(一对一/一对多/多对多)关系
目录 Basic Relationship Patterns One To Many One To One Many To Many Basic Relationship Patterns 基本关系模 ...
- 【Java EE 学习 46】【Hibernate学习第三天】【多对多关系映射】
一.多对多关系概述 以学生和课程之间的关系为例. 1.在多对多关系中涉及到的表有三张,两张实体表,一张专门用于维护关系的表. 2.多对多关系中两个实体类中应当分别添加对方的Set集合的属性,并提供se ...
- Hibernate基于注解方式的各种映射全面总结
1. 使用Hibernate Annotation来做对象关系映射 1) 添加必须包: hibernate-jpa-2.0-api-1.0.0.Final.jar 2) 在实体类中添加JPA的标准注解 ...
随机推荐
- DUMP3 企业级电商项目
[开发模式]controller - service(合法校验问题) - dao 反过来也没问题 用户模块 登录 注册 用户名验证(实时反馈前端) 忘记密码 重置密码 退出登录 更新用户信息 获取 ...
- 基于STM32F1的时钟芯片DS1302驱动
目录 DS1302.h源代码 DS1302.c源代码 DS1302.h源代码 /** ********************************************************* ...
- websocket 与Socket.IO介绍
一 websocket WebSocket是html5新增加的一种通信协议,目前流行的浏览器都支持这个协议,例如 Chrome,Safrie,Firefox,Opera,IE等等,对该协议支持最早的 ...
- Java基础10-集合
作业回顾 蜜蜂和熊的生产消费关系,熊在蜂蜜满10斤吃掉.蜜蜂一次生产一斤蜂蜜,且蜜蜂生成一斤蜂蜜花费的时间是10s. 十只蜜蜂和两只熊. 蜜蜂 bag: 20 每次产1,耗时10ms 满5的时候给蜜罐 ...
- POJ 3304 Segments（直线)
题目: Description Given n segments in the two dimensional space, write a program, which determines if ...
- angularjs异步处理 $q.defer()
看别人的项目中有用到 var def = $q.defer()返回一个deferred异步对象def 当代码逻辑遇到 def.resolve(rtns); deferred状态为执行成功,返回rtns ...
- 【python】实用的logging封装
#!/usr/bin/python import logging import logging.handlers def set_logger(filename, logmod): log_size ...
- [转]IntelliJ IDEA 使用spring-boot-devtools热部署无效解决办法
来源:https://www.jianshu.com/p/4d8aa6dfd103 相信大部分使用IntelliJ IDEA的同学都会遇到这个问题,即使项目使用了spring-boot-devtool ...
- Redis数据结构之quicklist
本文及后续文章,Redis版本均是v3.2.8 我们在使用Redis对外暴露的list数据结构时,给我们带来极大的便利性.其底层实现所依赖的内部数据结构就是quicklist. 我们先来回忆下list ...
- Service-Level Agreement （服务水平协议）
Service-Level Agreement (服务水平协议) SLA是为负载测试场景定义的具体目标.例如,评测脚本中任意数量事务的平均响应时间,可以定义具体的目标或阈值.测试运行结束之后,Load ...