hibernate 双向关联 单向关联
- 作者: 逝去的快乐呢
- 来源: 51数据库
- 2020-11-18
有两个对象a，b，单向关联就是a中有关系属性，b中没有或者b中有关系属性，而a中没有。双向关联就是ab中都有关系属性，我比较喜欢单向关联，双向的太麻烦了
一段时间没用~不知道记的清楚不了~
数据库都一样~程序不一样~
比如 A B~ 无论你是单项还是双向~你B表里都有个 字段 以A表 ID或其他什么做为外键~
如果只单向关联~A one to many B~ 当hibernate查询A的时候回自动加载相关的B~ 用A.getBorder()之类的就能得到B~（看你设置的方法是什么就是什么~打比方是getBorder()）
当查询B的时候~不会加载A~也就是说从B中是读不到A的~没有B.getAorder()之类的方法在B类里~
双向关联就是~查询A会自动加载B~用A类相应方法得到A类相应的B类~
同时查询B也会自动加载A类~用B类相应方法得到B类相应的A类~
差不多就这样~
单向关联 双向关联2007-10-24 21:18 当使用单向关联时，由父类管理关联关系，子类无法管理，而这时，父亲知道自己的儿子，但是，从儿子对象不知道父亲是谁。
单向关联时，只指定<one-to-many>
当使用双向关联时，关联关系的管理可以通过inverse指定，这时，儿子能清楚的知道自己的父亲是谁。 双向关联时，还要指定<many-to-one>
使用双向关联和单向关联的区别就是我在上面提到的呀。
Cascade属性是来控制进行级联操作的。从父类这边，父亲知道自己的孩子是谁，可以进行级联操作，但从子类那边，它是不清楚自己的父亲是谁的，所以，不能进行级联操作的。
使用双向关联和单向关联的区别就是我在上面提到的呀。
Cascade属性是来控制进行级联操作的。从父类这边，父亲知道自己的孩子是谁，可以进行级联操作，但从子类那边，它是不清楚自己的父亲是谁的，所以，不能进行级联操作的。
按常理来论，关联都应该是双向的，那么单向关联是什么呢？什么时候应该使用单向关联，什么时候应该使用双向关联？
hibernate_reference：确实如此，hibernate 建议用双向关联。不过，既然存在，就有道理。省点事而已。比如，
user <--> city ；
class user{
city;
}
不需要
class city{
// List users; // this is unnecessary for business , 不需要 .
}
对象层不需要，persistance 层 当然不需要了。就省了吧。
两个类如下:::
public class Person {
private String id;
private String name;
private String email;
//对应的get/set方法
}
public class Author {
private String id;
private String alias;
private Person person;
//对应的get/set方法
}
person.hbm.xml如下
<hibernate-mapping>
<class name="com.hibernate.Person" table="person">
<id name="id" type="string">
<generator class="uuid.hex"/>
</id>
<property name="name"/>
<property name="email"/>
</class>
</hibernate-mapping>
author.hbm.xml如下:
<hibernate-mapping>
<class name="com.hibernate.Author" table="author">
<id name="id" column="id">
<generator class="foreign">
<param name="property">person</param>
</generator>
</id>
<property name="alias" type="string"/>
<one-to-one name="person" class="com.hibernate.Person" cascade="all" constrained="true"/>
</class>
</hibernate-mapping>
A. 首先我在MYSQL中建立USER的表：
CREATE TABLE USER (
USER_ID VARCHAR(10) NOT NULL PRIMARY KEY,
NAME VARCHAR(16) NOT NULL
);
建立ROOM表：
CREATE TABLE ROOM(
ROOM_ID VARCHAR(10)NOT NULL PRIMARY KEY,
ADDRESS VARCHAR(32) NOT NULL);
B. 建立每个表对应的实体：
首先是user表对应的实体
package com.po;
public class User {
private long id;
private String name;
private house room;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public house getRoom() {
return room;
}
public void setRoom(house room) {
this.room = room;
}
}
接着是ROOM表对应的实体：
Package com.po;
public class Room {
private long id;
private String address;
private person user;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public person getUser() {
return user;
}
public void setUser(person user) {
this.user = user;
}
}
C. 与之两个表对应的XML配置文件:
User的配置文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
" http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="com.po.User" table="USER">
<id name="id" column="USER_ID" unsaved-value="0">
<generator class="increment"/>
</id>
<property name="name">
<column name="NAME" length="16" not-null="true"/>
</property>
<one-to-one name="room"
class="com.po.Room"
cascade="all"/>
</class>
</hibernate-mapping>
Room的配置文件:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
1. " http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="com.po..Room" table="ROOM">
<id name="id" column="ROOM_ID" unsaved-value="0">
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
<property name="address" type="string"/>
<one-to-one name="user"
class="com.po.User"
constrained="true"/>
</class>
</hibernate-mapping>
在这里注意一下，我们使用的是one to one 映射，一般One to One映射有两种实现的方式，一种是是通过外键参考，也就是在多对一的时候中可以限制为多对一为一对多，那个时候只要在<many-to-one>的many方加上unique=”true”就可以，具体的在以后讨论。在这里我们仅仅讨论One To One的那种情况，我们需要在Room的One To One的时候使用constrained="true"，表示Room的主键参考User的主键。在这个地方，开始的时候我没有弄明白，后来参考了这些属性的解释说明才明白。大家可以看一下，Room的id要多了几个属性，现在我就每个属性说一下他的运用：
在<id></id>中 name: 标识属性的名字。Column:对应数据库中的列，unsaved-value: 默认为null, 一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这种实例和从以前的session中装载过（可能又做过修改--译者注）但未再次持久化的实例区分开来。重要的是<generator></<generator>这个属性，class=”forgign”,表示使用另外一个相关联的对象的标识符。<param name="property">user</param>表示要关联的实体。
D. 测试往数据库中插入数据的程序：
import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
public class HibernateTest {
public static void main(String[] args) throws HibernateException {
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Room room = new Room();
room.setAddress("NTU-M8-419");
User user1 = new User();
user1.setName("bush");
user1.setRoom(room);
room.setUser(user1);
Session session = sessionFactory.openSession();
Transaction tx= session.beginTransaction();
session.save(user1);
tx.commit();
session.close();
sessionFactory.close();
}
}
推荐阅读
