`
liuhello
  • 浏览: 69223 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

Hibernate中的一对一的关系(二)

阅读更多
唯一外键
       通过一个外键将两个表关联到一起。
       下面以用户和用户组为例进行说明,一个用户对应一个用户组,用户表通过一个group_id与用户组进行关联。
TUser.java
java 代码
 
  1. package com.tyq.vo;  
  2.   
  3. public class TUser {  
  4.   
  5.     private int    id;  
  6.     private String name;  
  7.     private String password;  
  8.     private int    age;  
  9.     private TGroup group;  
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     private void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public String getPassword() {  
  23.         return password;  
  24.     }  
  25.     public void setPassword(String password) {  
  26.         this.password = password;  
  27.     }  
  28.     public int getAge() {  
  29.         return age;  
  30.     }  
  31.     public void setAge(int age) {  
  32.         this.age = age;  
  33.     }  
  34.     public TGroup getGroup() {  
  35.         return group;  
  36.     }  
  37.     public void setGroup(TGroup tgroup) {  
  38.         this.group = tgroup;  
  39.     }  
  40. }  
映射文件TUser.hbm.xml
java 代码
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.tyq.vo">  
  6.     <class name="TUser" table="tuser">  
  7.         <id name="id" column="id">  
  8.             <generator class="native" />  
  9.         </id>  
  10.         <property name="name" column="name" type="string"  
  11.             not-null="true" />  
  12.         <property name="password" column="password" type="string"  
  13.             not-null="true" />  
  14.         <property name="age" column="age" type="integer" />  
  15.         <many-to-one name="group" class="TGroup" column="group_id" unique="true"/>  
  16.     </class>  
  17. </hibernate-mapping>  
TGroup.java
java 代码
 
  1. package com.tyq.vo;  
  2.   
  3. public class TGroup {  
  4.     private int     id;  
  5.     private String  name;  
  6.     private TUser user;  
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19.     public TUser getUser() {  
  20.         return user;  
  21.     }  
  22.     public void setUser(TUser user) {  
  23.         this.user = user;  
  24.     }  
  25.       
  26. }  
映射文件TGroup.hbm.xml
java 代码
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.tyq.vo">  
  6.     <class name="TGroup" table="tgroup">  
  7.         <id name="id" column="id">  
  8.             <generator class="native" />  
  9.         </id>  
  10.         <property name="name" column="name" type="string"  
  11.             not-null="true" />  
  12.             <one-to-one name="user" class="TUser" property-ref="group"/>  
  13.     </class>  
  14. </hibernate-mapping>  
用户表:
+-----------+----------------+------+-----+---------+----------------+
| Field        | Type              | Null  | Key | Default | Extra               |
+-----------+----------------+------+-----+---------+----------------+
| id            | int(11)            | NO   | PRI  | NULL    | auto_increment |
| name       | varchar(40)    | NO   | UNI  |            |                         |
| password | varchar(50)    | NO    |       |            |                          |
| age          | int(11)           | YES   |       | NULL    |                        |
| group_id   | int(11)          | YES   |       | NULL    |                      |
+------------+---------------+------+-----+---------+----------------+
用户组表:
+-------+---------------+------+-----+---------+----------------+
| Field   | Type            | Null | Key   | Default | Extra              |
+-------+---------------+------+-----+---------+----------------+
| id       | int(11)          | NO   | PRI  | NULL    | auto_increment |
| name  | varchar(100) | YES  |        | NULL    |                      |
+-------+--------------+------+------+---------+----------------+

测试代码:
java 代码
 
  1. TUser tuser = new TUser();  
  2. tuser.setAge(12);  
  3. tuser.setName("tyqqw");  
  4. tuser.setPassword("liuhello");  
  5. TGroup group = new TGroup();  
  6. group.setName("haha");  
  7. tuser.setGroup(group);  
  8. UserDAOImpl dao = (UserDAOImpl)userDAO;  
  9. Session session = dao.getSessionFactory().openSession();  
  10. Transaction tx = session.beginTransaction();  
  11. session.saveOrUpdate(tuser);  
  12. session.saveOrUpdate(group);  
  13. tx.commit();  
  14. session.close();  

这时向用户表和用户组表中插入的数据是
用户表:
+----+-------+----------+------+----------+
| id | name  | password | age  | group_id |
+----+-------+----------+------+----------+
|  2 | tyqqw | liuhello |   12 |        1 |
+----+-------+----------+------+----------+
用户组表:
+----+------+
| id | name |
+----+------+
|  1 | haha |
+----+------+
从group_id与用户组id相同可以看出,他们通过group_id将两张表关联到了一起。
查询测试:
java 代码
 
  1. TUser tuser = new TUser();  
  2.     UserDAOImpl dao = (UserDAOImpl)userDAO;  
  3.     Session session = dao.getSessionFactory().openSession();  
  4.   
  5.     TGroup tgroup= (TGroup) session.load(TGroup.class,1);  
  6.     if(tgroup.getUser() != null){  
  7.         System.err.println(tgroup.getUser().getName());  
  8.     }  
  9.     session.close();  
输出:tyqqw
由于我们在表的设计时是双向关联的我们同样可以通过用户查询到用户组。
分享到:
评论

相关推荐

    hibernate one to one一对一关系示例

    总的来说,这个“hibernate one to one一对一关系示例”涵盖了如何在Hibernate中定义和操作一对一关联的基本步骤,包括实体类的注解配置、数据库表结构设计以及相关操作。通过对示例的深入学习,开发者能够更好地...

    Hibernate一对一,一对多,多对多实例

    例如,Student实体和IdCard实体可以建立一对一关系: ```java @Entity public class Student { @OneToOne(mappedBy = "student") private IdCard idCard; } @Entity public class IdCard { @OneToOne @...

    Hibernate教程05_关系映射之一对一双向外键关联

    在Hibernate中,一对一关系可以通过两种方式实现:外键关联和主键关联。本教程重点讨论的是外键关联,这意味着一方的表将包含指向另一方表的外键。双向关联意味着两个实体类都可以直接访问彼此。 接下来,我们将...

    hibernate多对一单向关联关系实现源码

    在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...

    Hibernate ORM - 一对一连接表关联关系

    标题"Hibernate ORM - 一对一连接表关联关系" 提示我们,这里主要讨论的是Hibernate ORM框架在处理数据库中一对一(One-to-One)关联映射的方法。Hibernate是一个流行的Java对象关系映射(ORM)工具,它允许开发者用...

    Hibernate一对一关系源码

    在Hibernate中,一对一关系是指两个实体类之间存在一个唯一的对应关系,通常通过主键外键关联实现。下面我们将详细探讨这种关系的配置、实现方式以及源码解析。 1. **配置一对一关系**: - 在实体类中使用`@...

    hibernate一对一的两种实现方式

    这种关联方式适用于实体间具有天然的一对一关系,例如用户与用户详细信息的关系。 1.2 实现方式 在Hibernate中,可以通过在映射文件或注解中指定`@OneToOne`和`@PrimaryKeyJoinColumn`来实现。例如,对于User和...

    hibernate 映射关系学习入门 一对一映射

    在提供的压缩包`TestHiberOnetoOne`中,可能包含了使用Eclipse创建的Hibernate一对一映射关系的项目源码。你可以通过运行这个项目来更直观地理解一对一映射的工作原理,包括实体类的定义、配置文件的编写以及如何在...

    Hibernate一对一,多对一关系源码

    在一对一关系中,Hibernate通常通过共享主键或附加的外键字段来实现。对于多对一关系,Hibernate会在子类表中创建一个外键字段,指向父类表的主键。 **性能优化** 在处理这种关联关系时,考虑以下优化策略: 1. *...

    hibernate中的对象关系模型

    在Hibernate中,可以通过`@OneToOne`注解来建立一对一的映射。 4. **一对多(OneToMany)**: 一个实体可以对应多个其他实体,如一个人可能有多种身份。使用`@OneToMany`注解来配置这种关系。 5. **多对一...

    Hibernate教程04_关系映射之一对一单向外键关联

    6. **懒加载与立即加载**:在一对一关系中,可以设置fetch属性来控制关联对象的加载策略,如懒加载(延迟加载)和立即加载。 7. **级联操作**:通过cascade属性,可以设置在操作主体对象时是否同时操作关联对象,...

    hibernate一对多项目

    本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先,一对多关系在数据库中很常见,...

    Hibernate一对一

    2. **一对一关系映射**:在数据库设计中,一对一关系是指两个表中的每个记录最多只能与另一个表中的一个记录相对应。在Hibernate中,这种关系可以通过@OneToOne注解来实现。它可以是单向或双向的,配置时需要注意...

    hibernate anotation 处理一对多关系

    本文将以一个实例为依托,深入解析如何使用注解来设置一对多关系以及多对一关系的映射。 在Hibernate中,处理一对多关系主要使用`@OneToMany`和`@ManyToOne`注解。一个简单的例子通常包括两个实体类:一个“父”类...

    Hibernate双向一对多经典实例

    本实例将聚焦于Hibernate中的一对多关系,这是一种常见的关联类型,尤其是在处理具有层次结构的数据时。双向一对多关系意味着一个实体可以拥有多个相关联的实体,同时每个相关联的实体也可以回指到原始实体。 **...

    Hibernate ORM - 一对多双向关联关系

    这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料,开发者能够深入理解如何在Java应用中利用Hibernate来处理...

    hibernate 一对一 多对多的关系

    在Hibernate中,实现一对一关系通常有两种方式:使用主键外键和使用唯一外键。通过`@OneToOne`注解,我们可以轻松地在Java类中定义这种关系。例如: ```java @Entity public class User { @Id @GeneratedValue...

    HIBERNATE - 符合Java习惯的关系数据库持久化

    3. **一对一关联**:两个实体之间存在唯一对应关系。 4. **多对多关联**:两个实体之间存在多对多的关系,通常需要通过关联表来实现。 #### 结论 Hibernate通过提供强大的对象关系映射功能,极大地简化了Java应用...

    hibernate一对一实例

    本教程“Hibernate一对一实例”是为初学者设计的,旨在帮助你们理解并掌握Hibernate框架中的一对一映射关系。 一、Hibernate简介 Hibernate是一个开源的对象关系映射(ORM)框架,它允许开发者用Java对象来表示...

    Hibernate双向一对多

    标题"Hibernate双向一对多"指的是Hibernate框架中的一个重要关系映射概念,即在一个实体类中,一个实例可以与多个另一个实体类的实例相关联,而在另一个实体类中,每个实例也可以关联到该实体类的一个实例。...

Global site tag (gtag.js) - Google Analytics