hibernate3 关系映射使用说明

最新推荐文章于 2024-04-06 19:53:40 发布

success_dream

最新推荐文章于 2024-04-06 19:53:40 发布

阅读量858

点赞数

文章标签： hibernate user server class generator integer

一.单向关系

建表脚本:

CREATE TABLE user (

id INT(11) NOT NULL auto_increment PRIMARY KEY,

name VARCHAR(100) NOT NULL default '',

room_id INT(11)

);

CREATE TABLE room (

id INT(11) NOT NULL auto_increment PRIMARY KEY,

address VARCHAR(100) NOT NULL default ''

);

1.1多对一

User.java

public class User {

private Integer id;

private String name;

private Room room;

…….

}

配置文件:

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.fhway.User" table="user">

<id name="id" column="id" type="java.lang.Integer">

<generator class="native"/>

</id>

<property name="name" column="name" type="java.lang.String"/>

<many-to-one name="room"

column="room_id"

class="com.fhway.Room"

cascade="all"

outer-join="true"/>

</class>

</hibernate-mapping>

说明: 关于Room的两个文件没有什么特殊说明;

在<many-to-one>的设定中，cascade表示主控方（User）进行save-update、delete等相关操作时，被控方（Room）是否也一并进行相关操作，简单的说，也就是您储存或更新User实例时，当中的Room实例是否一并对数据库发生储存或操作，设定为 all，表示主控方任何操作，被控方也进行对应操作。如果不设定cascade为true，则您必须分别对User实例与Room实例进行储存. 使用cascade自动持久化时，会先检查被关联对象的id属性，未被持久化的对象是否储存是藉由id属性的unsaved-value决定，预设是 null，也就是没有参考至任何值时储存对象，如果您使用int、long这样的原生型态（Primitive type）时，由于数据成员的初始会被设定为0，所以您必须自行指定默认值，例如（如果id的数据型态是long的话）.

Room.hbm.xml

…….

<id name="id" column="id" unsaved-value="0">

<generator class="native"/>

</id>

…..

注意到room_id 与 com.fhway.Room 对应那么room_id的值为 Room的id；

1.2一对多

多对一的反向;

配置文件:

Room.hbm.xml

…….

<set name="users" table="user" cascade="all">

<key column="room_id"/>

<one-to-many class="com.fhway.User"/>

</set>

…….

注意到在一对多的关系中Room为一,User为多;在Room.hbm.xml中采用一个Set来存放User; 使Room其id与User的room_id关联;并在Room.java中加入关联的Set,代码如下:

…….

private Set users;

public Set getUsers() {

return users;

}

public void setUsers(Set users) {

this.users = users;

}

public void addUser(User user) {

users.add(user);

}

public void removeUser(User user) {

users.remove(user);

}

……

于是在Room中达到操作User表的目的.

二.双向关系

图解:

配置文件:

User.hbm.xml

……

<many-to-one name="room"

column="room_id"

class="com.fhway.Room"

cascade="save-update"

outer-join="true"/>

……

Room.hbm.xml

……

<set name="users" table="user" cascade="save-update">

<key column="room_id"/>

<one-to-many class="com.fhway.User"/>

</set>

……

配置文件也体现了单向的双方组合many-to-one 与one-to-many,由表的关系确定了Set集合的一方( [一] 的一方);

映像文件双方都设定了cascade为save-update，所以您可以用多对一的方式来维持关联;

在User.java中声明一个Room的类及其操作方法;在Room中同样声明一个放User的Set容器及其操作方法;于是在操作的时候可以使用任何一方操作另一方;

User user1 = new User();

user1.setName("bush");

User user2 = new User();

user2.setName("caterpillar");

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

user1.setRoom(room1);

user2.setRoom(room1);

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.save(user1);

session.save(user2);

tx.commit();

session.close();

或是反过来由一对多的方式来维持关联：

User user1 = new User();

user1.setName("bush");

User user2 = new User();

user2.setName("caterpillar");

Room room1 = new Room();

room1.setUsers(new HashSet());

room1.setAddress("NTU-M8-419");

room1.addUser(user1);

room1.addUser(user2);

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.save(room1);

tx.commit();

session.close();

上面的程序写法表示关联由Room单方面维持，而主控方也是Room，User不知道Room的room_id是多少，所以必须分别储存Room与User之后，再更新user的room_id。

在一对多、多对一形成双向关联的情况下，可以将关联维持的控制权交给多的一方，这样会比较有效率，理由不难理解，就像是在公司中，老板要记住多个员工的姓名快，还是每一个员工都记得老板的姓名快。

所以在一对多、多对一形成双向关联的情况下，可以在「一」的一方设定控制权反转，也就是当储存「一」的一方时，将关联维持的控制权交给「多」的一方，以上面的例子来说，可以设定Room.hbm.xml如下：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.fhway.Room" table="room">

<id name="id" column="id">

<generator class="native"/>

</id>

<property name="address"

column="address"

type="java.lang.String"/>

<set name="users" table="user" cascade="save-update" inverse="true">

<key column="room_id"/>

<one-to-many class="com.fhway.User"/>

</set>

</class>

</hibernate-mapping>

由于关联的控制权交给「多」的一方了，所以直接储存「一」方前，「多」的一方必须意识到「一」的存在，所以程序片段必须改为如下：

User user1 = new User();

user1.setName("bush");

User user2 = new User();

user2.setName("caterpillar");

Room room1 = new Room();

room1.setUsers(new HashSet());

room1.setAddress("NTU-M8-419");

room1.addUser(user1);

room1.addUser(user2);

// 多方必须意识到单方的存在

user1.setRoom(room1);

user2.setRoom(room1);

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.save(room1);

tx.commit();

session.close();

上面的程序片段Hibernate将使用以下的SQL：

Hibernate: insert into room (address) values (?)

Hibernate: insert into user (name, room_id) values (?, ?)

如果控制权交给另一方了，而另一方没有意识到对方的存在的话会如何？试着将上面的程序片段中user1.setRoom(room1);与user2.setRoom(room1);移去，执行之后，您会发现数据库中room_id会出现null值，这种结果就好比在多对一中，您没有分配给User一个Room，理所当然的，room_id会出现null。

2.1一对一(唯一外键关联)

在对象方面，User的实例会参考至Room实例，而Room实例也参考至User实例; 使用外键来完成一对一，其实就是限制多对一关系中，「多」的一方只能有一个参考至「一」的一方，也就是多对一关系的一个特例，这可以在映像文件中使用<many-to-one>标签时，加上"unique"属性来设定;

User.hbm.xml

<many-to-one name="room"

column="room_id"

class="com.fhway.Room"

cascade="all"

outer-join="true"

unique="true"/>

到这边为止，单向一对一的映像已经完成，如果要再完成双向一对一的关系，则可以在Room.hbm.xml中使用<one-to-one>标签来定义：

Room.hbm.xml

<one-to-one name="user"

class="com.fhway.User"

property-ref="room"/>

在<one-to-one>中，property-ref告诉Hibernate，查询出user并将其参考至room。

在这里没有用到Set容器;

2.2一对一(主键关联)

图解:

User.hbm.xml

<one-to-one name="room"

class="com.fhway.Room"

cascade="all"/>

Room.hbm.xml

……

<hibernate-mapping>

<class name="com.fhway.Room" table="room">

<id name="id" column="id">

<generator class="foreign">

<param name="property">user</param>

</generator>

</id>

<property name="address"

column="address"

type="java.lang.String"/>

<one-to-one name="user"

class="com.fhway.User"

constrained="true"/>

</class>

</hibernate-mapping>

在Room的id主键上，使用foreign表示与外键共享主键，也就是与User实体共享主键，而constrained设定为true，表示约束room的主键必须与user中对应数据的主键相同。

一个储存的实例如下：

User user1 = new User();

user1.setName("bush");

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

// 互相设定关联

user1.setRoom(room1);

room1.setUser(user1);

User user2 = new User();

user2.setName("caterpillar");

Room room2 = new Room();

room2.setAddress("NTU-M8-418");

// 互相设定关联

user2.setRoom(room2);

room2.setUser(user2);

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.save(user1);

session.save(user2);

tx.commit();

session.close();

2.3多对多

图解:

在数据库表格上要进行多对多对应，可以藉由一个中介表格来完成，也就是藉由多对一、一对多来完成多对多关联。

多对多由于使用了中介表格，在查询效率不彰，且在程序的对象模式上，多对多会使得对象与对象之间彼此依赖，并不是一个很好的设计方式，在设计上应避免使用多对多关系。

如果一定要使用多对多关系的话，在表格上先如下建立：

CREATE TABLE user (

id INT(11) NOT NULL auto_increment PRIMARY KEY,

name VARCHAR(100) NOT NULL default ''

);

CREATE TABLE user_server (

user_id INT(11),

server_id INT(11)

);

CREATE TABLE server (

id INT(11) NOT NULL auto_increment PRIMARY KEY,

address VARCHAR(100) NOT NULL default ''

);

先设计User类别如下：

User.java

package com.fhway;

import java.util.Set;

public class User {

private Integer id;

private String name;

private Set servers;

public User() {

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Set getServers() {

return servers;

}

public void setServers(Set servers) {

this.servers = servers;

}

再来设计Server类别如下：

Server.java

package com.fhway;

import java.util.Set;

public class Server {

private Integer id;

private String address;

private Set users;

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public Set getUsers() {

return users;

}

public void setUsers(Set users) {

this.users = users;

}

在映像文件上，使用<many-to-many>标签来完成映像关系：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.fhway.User" table="user">

<id name="id" column="id" type="java.lang.Integer">

<generator class="native"/>

</id>

<property name="name" column="name" type="java.lang.String"/>

<set name="servers"

table="user_server"

cascade="save-update">

<key column="user_id"/>

<many-to-many class="com.fhway.Server"

column="server_id"/>

</set>

</class>

</hibernate-mapping>

注意到cascade是设定为save-update，因为在多对多的关系中，很少因为删除其中之一，而所关联的实体都要一并删除的，所以设定save-update，表示在save或update时，一并对关联的对象进行对应的save或update。

Server.hbm.xml的定义如下：

Server.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.fhway.Server" table="server">

<id name="id" column="id">

<generator class="native"/>

</id>

<property name="address" type="java.lang.String"/>

<set name="users" table="user_server" inverse="true"

cascade="save-update">

<key column="server_id"/>

<many-to-many class="com.fhway.User"

column="user_id"/>

</set>

</class>

</hibernate-mapping>

一个储存时的例子如下：

Server server1 = new Server();

server1.setAddress("PC-219");

server1.setUsers(new HashSet());

Server server2 = new Server();

server2.setAddress("PC-220");

server2.setUsers(new HashSet());

Server server3 = new Server();

server3.setAddress("PC-221");

server3.setUsers(new HashSet());

User user1 = new User();

user1.setName("caterpillar");

user1.setServers(new HashSet());

User user2 = new User();

user2.setName("momor");

user2.setServers(new HashSet());

// 多对多，互相参考

user1.getServers().add(server1);

user1.getServers().add(server2);

user1.getServers().add(server3);

server1.getUsers().add(user1);

server2.getUsers().add(user1);

server3.getUsers().add(user1);

user2.getServers().add(server1);

user2.getServers().add(server3);

server1.getUsers().add(user2);

server3.getUsers().add(user2);

Session session = sessionFactory.openSession();

Transaction tx= session.beginTransaction();

session.save(user1);

session.save(user2);

tx.commit();

session.close();

success_dream

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hibernate3 关系映射使用说明

一.单向关系建表脚本:CREATE TABLE user ( id INT(11) NOT NULL auto_increment PRIMARY KEY, name VARCHAR(100) NOT NULL default , room_id INT(11)); CREATE TABLE room ( id INT(11)
复制链接

扫一扫