Hibernate 多对一关联查询

一、单向多对一和双向多对一的区别

  如果只需要从一方获取另一方数据,就用单向多对一;如果需要从双方都获取对方数据,就用双向多对一。

  如果有两个对象,一个为User对象,一个为Department对象,一个用户只能属于一个部门,而一个部门可以包含多个用户。这样就是多对一关系。如下图

  

    假设:我们需要通过用户找到所对应的部门,不需要通过部门查询该部门有哪些用户,就采用单向多对一关系

    如果:我们不仅需要通过用户获取所对应的部门,还需要通过部门对象获取该部门下的用户,那么就采用双向多对一

二、单向多对一关系

  Department.java

 1 package com.proc.pojo;
 2
 3 import java.io.Serializable;
 4
 5 public class Department implements Serializable {
 6
 7     private Integer id;
 8     private String deptname;
 9
10     //提供构造方法
11     public Department() {
12     }
13
14     public Department(String deptname) {
15         this.deptname = deptname;
16     }
17
18     //getter和setter实现
19     public Integer getId() {
20         return id;
21     }
22     public void setId(Integer id) {
23         this.id = id;
24     }
25     public String getDeptname() {
26         return deptname;
27     }
28     public void setDeptname(String deptname) {
29         this.deptname = deptname;
30     }
31 }

  User.java

 1 package com.proc.pojo;
 2
 3 import java.io.Serializable;
 4
 5 public class User implements Serializable {
 6
 7     private Integer id;
 8     private String name;
 9     private Department dept;
10
11     //提供构造方法
12     public User() {
13     }
14     public User(String name) {
15         this.name = name;
16     }
17     //getter和setter实现
18     public Integer getId() {
19         return id;
20     }
21
22     public void setId(Integer id) {
23         this.id = id;
24     }
25     public String getName() {
26         return name;
27     }
28     public void setName(String name) {
29         this.name = name;
30     }
31     public Department getDept() {
32         return dept;
33     }
34     public void setDept(Department dept) {
35         this.dept = dept;
36     }
37 }

  Department.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!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.proc.pojo">
    <class name="Department" table="department">
        <id name="id" type="int">
            <generator class="native"></generator>
        </id>
        <property name="deptname" length="20" not-null="true"></property>
    </class>
</hibernate-mapping>

  User.hbm.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping package="com.proc.pojo">
 6     <class name="User">
 7         <id name="id" type="int">
 8             <generator class="native"></generator>
 9         </id>
10         <property name="name" length="20" not-null="true"></property>
11         <many-to-one name="dept" column="deptid" class="Department" ></many-to-one>
12     </class>
13 </hibernate-mapping>

   代码讲解:在配置User(多)->Department(一)时,采用外键映射,其中

  name="dept":User对象dept属性

  class="Department":表示该dept属性的类型是Department类型,因为User和Department在同一个包中,所以直接使用了类名称

  column="deptid":指定在用user表中,对应department表的中主键的列为deptid

  这里并没有指出user表中deptid对应的值department表中哪一列,默认为主键,这里也会自动给deptid列添加一个外键约束

  测试代码:

 1 package com.proc.test;
 2
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8
 9 import com.proc.pojo.Department;
10 import com.proc.pojo.User;
11
12 public class TestOneToMany {
13
14     private static SessionFactory factory=new Configuration()
15                                 .configure()
16                                 .addClass(User.class)
17                                 .addClass(Department.class)
18                                 .buildSessionFactory();
19     @Test
20     public void set(){
21
22         Session session=factory.openSession();
23         Transaction tran=session.beginTransaction();
24         Department dept1=new Department("IT部");
25
26         User user1=new User("caoyc");
27         User user2=new User("zhh");
28
29         user1.setDept(dept1);
30         user2.setDept(dept1);
31
32         session.save(dept1);
33         session.save(user1);
34         session.save(user2);
35
36         tran.commit();
37         session.close();
38     }
39 }

在控制台输出SQL语句:

Hibernate: create table department (id integer not null auto_increment, deptname varchar(20) not null, primary key (id))
Hibernate: create table User (id integer not null auto_increment, name varchar(20) not null, deptid integer, primary key (id))
Hibernate: alter table User add constraint FK66lqw6kl2gcxhs44gamc91fbd foreign key (deptid) references department (id)

Hibernate: insert into department (deptname) values (?)
Hibernate: insert into User (name, deptid) values (?, ?)
Hibernate: insert into User (name, deptid) values (?, ?)

时间: 2024-10-18 17:01:11

Hibernate 多对一关联查询的相关文章

Hibernate 多对多关联查询条件使用

from Brand as b inner join fetch b.styles as s where s.styleId=?

Hibernate-ORM:11.Hibernate中的关联查询

------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 本篇博客将讲述Hibernate中的关联查询,及其级联(cascade)操作,以及指定哪一方维护关联关系的(inverse) 一,讲述目录如下: 1.单向一对多:(增加一个区县及其它以下的对应街道) 2.单项一对多:(查询一个区县,以及它下面所有的对应街道) 3.单项多对一:(查询一个指定的街道,并同时展示出其对应的区县) 4.双向一对多(多对一):(值得注意:toString()套路不对容易引发错误Err

hibernate多对一关联映射

hibernate多对一关联映射: 实体类 (POJO) public class Student{ private int stuId; private String stuNum; private String stuName; private ClassRoom cr; } public class ClassRoom{ private int claId; private String claName; } 映射文件 <class name=" Student" tabl

NHibernate教程(11)--多对多关联查询

本节内容 多对多关系引入 多对多映射关系 多对多关联查询 1.原生SQL关联查询 2.HQL关联查询 3.Criteria API关联查询 结语 多对多关系引入 让我们再次回顾在第二篇中建立的数据模型: 在图上,我已经清晰的标注了表之间的关系,上两篇分析Customer和Order之间的"外键关系"或者称作"父子关系"."一对多关系"和关联查询,这一篇以Order为中心,分析Order和Product之间的关系,直接看下面一幅图的两张表: 上面两

atitit.atitit.hb many2one relate hibernate 多对一关联配置..

atitit.atitit.hb many2one relate hibernate 多对一关联配置.. 1. 多对一单向 @ManyToOne 1 1. 其中@JoinColumn 注解 2 2. @targetEntity注解 2 2. 生成的sql LEFT OUTER 2 3. 多对一也可以通过关联表的方式来映射,通过 @JoinTable 注解可 2 4. 另外一个属性也关联到table column(recomn?? ) 3 5. 参考 3 1. 多对一单向 @ManyToOne (

hibernate多对一关联映射两种形式的理解

关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 多对一单向和多对一双向关联: 单向:多对一单向是只用维护多的一方,例如一家厂商(Factory)可以生产多种产品(Product),只用在Product实体类和配置文件中配置即可.在Product实体属性类中,需要有Factory属性,而不再需要外键这个属性,因为关联外键的配置在配置文件中many-to-one. 双向:多对一双向关联需要双方都维护对方,例如班级(Class)和学生(Student)之间的关系,需要在Class实体类和

05.Hibernate多对多关联

前言:本文讲解使用Hibernate映射多对多关联关系,并使用多种方式映射多对多关联. 1.数据库表的多对多关系 本文根据学生信息表(tb_student)和教师信息表(tb_teacher)来说明多对多映射关系,一个学生有多个老师,一个老师也有多个学生,其数据库模型图如下: 根据以上图,对应的建表语句如下: CREATE TABLE tb_student ( id bigint NOT NULL auto_increment COMMENT 'ID', no varchar(10) NOT N

关于解决hibernate左连接关联查询不执行的问题

hql是这样的: String vrsql = "From VehicleRelevance as vr left join fetch vr.partRelevance as pr where vr.vehicle_id=1 and pr.part_id=2"; 但是 pr.part_id是作为partRevelance标的外键 所以必须这样配置: <property name="part_id" column="PART_ID" typ

hibernate多对多关联

多对多表的搭建 java类中 多对多 1.关系操作 1.多对多,谁操作效率都一样 2.解除关系 把第三张表的一行数据删除掉 3.建立关系 把第三张表的数据增加一行记录 4.变更关系 先删除后增加 2.级联操作 都是对象针对集合的操作 例子 工具类 public class HibernateUtils {     public static SessionFactory sessionFactory;     public static String url;     @Before     p