您的位置：首页 > 其它

映射关联关系

2016-05-30 22:56 447 查看

一关联关系的种类

1. 单向多对 1

  2. 单向 1 对多

  3. 双向多对1

  4. 双向 1 对多

  5. 一对一

①. 外键映射

②. 主键映射

  6. 单向多对多

[b] 7. 双向多对多
[/b]

8. 继承关系

解释：

什么是单向？
单向就是：可以通过A 中 B 的id 查找的B 中的对象，

但是,不能通过B查到A 中的对象，

说白一点就是，可以通过我找到你，但是不能通过你来找我

什么是双向？双向就是：可以通过A 中 B 的id 查找的B 中的对象，

但是,也能通过B查到A 中的对象，

说白一点就是，可以通过我找到你，[b]也可以通过你来找我[/b]

什么是多？多：就是集合 set

什么是1？ 1 ：就是1那一端的类的一个对象

因此：把 “对”字后面的放入前面里面：后面是多，就放set 集合

后面是 1 ，就放一个类的对象

单向 1 对多：就是在1 这一端放入一个多那一端的set集合；

单向多对 1：就是在 多这一端，放入一个 1
这一端类的对象

双向多对 1：就是在多这一端，放入一个 1
这一端类的对象；

再[b]在[b]1 这一端放入一个多那一端的set集合[/b][/b]

双向 1 对多：[b]在[b]1 这一端放入一个多那一端的set集合[/b] [/b]

  再在 [b][b]多 这一端，放入一个 1
这一端类的对象[/b][/b]

1 对 1
：就是分别在对方中放一个自己类的对象(注意：是一个对象，不是一个集合)

多对多：就是分别在对方中放一个自己类的集合(注意：是一个集合，不是一个对象)

关联关系常用到的属性：

~~~~~~~~~分割线~~~~~~下面是示例~~~~~~~~~

orders：订单表 customer：客户表

1. 单向多对 1 ：一个客户可以有多个定点，因此，客户是1
订单是多，需要该订单中添加Customer 类的属性

持久化类

Customer.java

package com.baidu.n21;

//演示单项   多对一
public class Customer {
private Integer customerId;
private String customerName;

public Integer getCustomerId() {
return customerId;
}
public void setCustomerId(Integer customerId) {
this.customerId = customerId;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
}

Order.java

package com.baidu.n21;

public class Order {
private Integer orderId;
private String orderName;

private Customer customer;

public Integer getOrderId() {
return orderId;
}
public void setOrderId(Integer orderId) {
this.orderId = orderId;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}

public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}

对象关系映射

Customer.hbm.xml

<?xml version="1.0"?>
<!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.baidu.n21.Customer" table="CUSTOMERS">

<id name="customerId" type="java.lang.Integer">
<column name="CUSTOMER_ID" />
<generator class="native" />
</id>

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

</class>

</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-5-20 13:07:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.baidu.n21">

<class name="Order" table="ORDERS">

<id name="orderId" type="java.lang.Integer">
<column name="ORDER_ID" />
<generator class="native" />
</id>

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

<!--
映射 多对一 的关联关系，使用many-to-one 来映射多对1 的关联关系，
name：多这一端关联的一那一端的属性的名称
class： 一那一端的属性对应的类名
column：一那一端在多的一端对应的数据表中的外键的名字，这个名字可以和一那一端的不一样
如：	一那一端的之间可以为： 			CUSTOMER_ID，
而器在多这一端表中的名字可以为：	CUS_ID
-->
<many-to-one name="customer" class="Customer" column="CUSTOMER_ID" ></many-to-one>

</class>

</hibernate-mapping>

测试代码详见：
点我去看详解代码

2. 单向 1 对多

班级 class，学生 student

班级和学生是 1 对多，一个班级里可以有多名学生

持久化类

Classbj.java

package com.baidu.l2n;

import java.util.HashSet;
import java.util.Set;

//单向    1 对  多  。 1 这一端
public class Classbj {

/**
* orders
*
* 1. 声明集合类型时，需要使用接口类型，
* 		因为hibernate 在获取集合类型时，返回的是Hibernate 内置的集合类型，
* 		而不是JaveSE 的一个标准的集合实现
* 2. 需要把集合进行初始化，可防止 发生空指针异常
*/

private Integer classId;
private String  className;

private Set<Student> stus = new HashSet<Student>();

public Integer getClassId() {
return classId;
}
public void setClassId(Integer classId) {
this.classId = classId;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Set<Student> getStus() {
return stus;
}
public void setStus(Set<Student> stus) {
this.stus = stus;
}
}

Student.java

package com.baidu.l2n;

// 单向    1 对  多  。 多这一端
public class Student {

private Integer stuId;
private String stuName;

public Integer getStuId() {
return stuId;
}
public void setStuId(Integer stuId) {
this.stuId = stuId;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
@Override
public String toString() {
return "Student [stuId=" + stuId + ", stuName=" + stuName + "]";
}

}

对象关系映射

Clazz.hbm.xml

<hibernate-mapping package="com.baidu.l2n">

<class name="Clazz" table="CLAZZS">

<id name="clazzId" type="java.lang.Integer">
<column name="CLAZZ_ID" />
<generator class="native" />
</id>

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

<!-- 映射1 对多的那个集合属性  -->
<!--
set:映射set类型的属性，
table：set 中的元素对应的记录放到哪一个数据表中。该值需要和多对1 的多的那个表中的名字一致
inverse：指定 inverse=true，使1 的一端放弃维护关联关系
column:
lazy:

cascade：设置级联操作： 开发时，不建议设定该属性，建议使用手工的方式来处理
级联操作的取值有一下几种：
all: 所有情况下均进行关联操作，即save-update和delete。
none: 所有情况下均不进行关联操作。这是默认值。
save-update: 在执行save/update/saveOrUpdate时进行关联操作。
delete: 在执行delete 时进行关联操作。
all-delete-orphan: 当一个节点在对象图中成为孤儿节点时，删除该节点
-->

<set name="stus" table="STUDENTS" inverse="false" >
<!-- 指定多的表中的外键列的名字  -->
<key>
<column name="CLAZZ_IDQ" />
</key>
<!-- 指定映射类型  -->
<one-to-many class="Student" />
</set>

</class>

</hibernate-mapping>

Student.hbm.xml

<?xml version="1.0"?>
<!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.baidu.l2n.Student" table="STUDENTS">

<id name="stuId" type="java.lang.Integer">
<column name="STU_ID" />
<generator class="native" />
</id>

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

</class>

</hibernate-mapping>

测试代码详见： 点我去看详解代码

1. 对象关系映射

Customer.hbm.xml

<hibernate-mapping package="com.baidu.doubleOne2Many">

<class name="Customer" table="CUSTOMERS">

<id name="customerId" type="java.lang.Integer">
<column name="CUSTOMER_ID" />
<generator class="native" />
</id>

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



<set name="orders" table="ORDERS" >

<key column="CUST_ID" ></key>

<one-to-many class="Order" />
</set>

</class>

</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.doubleOne2Many">

<class name="Order" table="ORDERS">

<id name="orderId" type="java.lang.Integer">
<column name="ORDER_ID" />
<generator class="native" />
</id>

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

<many-to-one name="customer" class="Customer" >
<column name="CUST_ID" />
</many-to-one>

</class>

</hibernate-mapping>

2. 两个持久化类

/**
*orders
*
* 1. 声明集合类型时，需要使用接口类型Set，
*因为hibernate 在获取集合类型时，返回的是Hibernate 内置的集合类型，
*而不是JaveSE 的一个标准的集合实现
* 2.需要把集合进行初始化，可放在发送空指针异常
*/

测试代码详见：点我去看详解代码

一对一关联：主键关联与外键关联

主键关联：不必加额外的字段，只是主表和辅表的主键相关联，即这两个主键的值是一样的。

外键关联：辅表有一个额外的字段和主表相关联，或者两个表都有额外的字段与对应表的相关联。

(1) name: 属性的名字。

(2) class (可选 - 默认是通过反射得到的属性类型)：被关联的类的名字。

(3) cascade(级联) (可选)：表明操作是否从父对象级联到被关联的对象。

(4) constrained(约束) (可选)：表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键
引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序以及决定
该关联能否被委托(也在schema export tool中被使用).

(5) fetch (可选 - 默认设置为选择): 在外连接抓取或者序列选择抓取选择其一.

(6) property-ref (可选):指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，会使用对方关联类的主键。

(7) access (可选 - 默认是 property): Hibernate用来访问属性的策略。

(8) formula (可选):绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中，你可能会指向其他的一个或多个字段，或者是一个表达式，这些情况下，你可以用一个SQL公式来表示。（可以
在org.hibernate.test.onetooneformula找到例子）

(9) lazy (可选 - 默认为 proxy): 默认情况下，单点关联是经过代理的。lazy="no-proxy"指定此属性应该在实例变量第一次
被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。 lazy="false"指定此关联总是被预先抓取。注意，如果constrained="false", 不
可能使用代理，Hibernate会采取预先抓取！

(10) entity-name (可选): 被关联的类的实体名。

1. 外键关联

例: Person 和Card，一个用户对应一个卡

这种关联Card 中是用 many-to-one，然后用unique="true" 做限制，限制成一对一的关系。所以，一对一的外键关联其实就是多对一关联的一种特例。

1. 持久化类

Card.java

package com.baidu.one2one.foreign;

public class Card {

private  Integer cardId;
private String  cardName;

private Person person;

public Integer getCardId() {
return cardId;
}
public void setCardId(Integer cardId) {
this.cardId = cardId;
}

public String getCardName() {
return cardName;
}
public void setCardName(String cardName) {
this.cardName = cardName;
}

public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}

Person.java

package com.baidu.one2one.foreign;

public class Person {
private  Integer personId;
private String  personName;
private Integer age;

private Card card;

public Integer getPersonId() {
return personId;
}
public void setPersonId(Integer personId) {
this.personId = personId;
}

public String getPersonName() {
return personName;
}
public void setPersonName(String personName) {
this.personName = personName;
}

public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}

public Card getCard() {
return card;
}
public void setCard(Card card) {
this.card = card;
}
}

2. hbm.xml

Card.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.foreign">

<class name="Card" table="CARDS">

<id name="cardId" type="java.lang.Integer">
<column name="CARD_ID" />
<generator class="native" />
</id>

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

<!-- 使用many-to-one 的方式来映射  one-to-one关联关系的外键 -->
<many-to-one name="person" class="Person" column="PERS_ID" unique="true"></many-to-one>

</class>

</hibernate-mapping>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.foreign">

<class name="Person" table="PERSONS">

<id name="personId" type="java.lang.Integer">
<column name="PERSON_ID" />
<generator class="native" />
</id>

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

<property name="age" type="java.lang.Integer">
<column name="AGE" />
</property>

<!-- 映射 one-to-one关联关系：因为在对应的数据表中已经有外键了，
当前持久化类使用one-to-one 进行映射

这种关联Card 中是用 many-to-one， 然后用unique="true" 做限制，限制成一对一的关系。
所以，一对一的外键关联其实就是多对一关联的一种特例。
-->
<one-to-one name="card" class="Card" ></one-to-one>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

2. 主键关联

1. 持久化类

Card.java

public class Card {

private  Integer cardId;
private String  cardName;

private Person person;

...这里是getter 和setter
}

Person.java

package com.baidu.one2one.primary;

public class Person {
private  Integer personId;
private String  personName;
private Integer age;

private Card card;

....这里是getter 和setter

}

2. hbm.xml

Card.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.primary">

<class name="Card" table="CARDS">

<id name="cardId" type="java.lang.Integer">
<column name="CARD_ID" />
<!-- 使用外键的方式来生成当前的主键 -->
<generator class="foreign">
<!-- property 属性指定使用当前持久化类的哪一属性的主键作为外键 -->
<param name="property">person</param>
</generator>
</id>

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

<!--
使用foreign 主键生成器策略的一端  增加one-to-one 元素映射关联关系属性，
其中one-to-one 节点 还应增加 constrained="true" 属性; 以使当前的主键上添加外键约束。
另一端增加 one-to-one 元素映射关联属性
-->
<one-to-one name="person" class="Person" constrained="true"></one-to-one>

</class>

</hibernate-mapping>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.primary">

<class name="Person" table="PERSONS">

<id name="personId" type="java.lang.Integer">
<column name="PERSON_ID" />
<generator class="native" />
</id>

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

<property name="age" type="java.lang.Integer">
<column name="AGE" />
</property>

<one-to-one name="card" class="Card"></one-to-one>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

多对多关联是常见的一种关联关系，如User与Role，一个用户可以对应多个角色，一个角色也可以对应多个用户。

1. 单向多对多

持久化类：

Role.java

public class Role {

private Integer rId;
private String rName;
下面是getter 和setter..
}

User.java

import java.util.Set;

public class User {
private Integer uId;
private String uName;

private Set<Role> roles;

下面是getter 和setter..
}

关系映射：

Role.hbm.xml

<hibernate-mapping>

<class name="com.baidu.many2many.Role" table="ROLES">

<id name="rId" type="java.lang.Integer">
<column name="R_ID" />
<generator class="native" />
</id>

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

</class>

</hibernate-mapping>

User.hbm.xml

<hibernate-mapping package="com.baidu.many2many">

<class name="User" table="USERS">

<id name="uId" type="java.lang.Integer">
<column name="U_ID" />
<generator class="native" />
</id>

<property name="uName" type="java.lang.String">
<column name="U_NAME" />
</property>
<!-- table：指定中间表 -->
<set name="roles" table="T_USERS_ROLES">
<key>
<column name="U_ID" />
</key>
<!-- 使用many-to-many 指定多对多的关联关系 column：指定Set 集合中的持久化类在中间表的外键列的名称 -->
<many-to-many class="Role">
<column name="R_ID"></column>
</many-to-many>
</set>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

2. 双向多对多

修改持久化类

Role.java

package com.baidu.many2many;

import java.util.HashSet;
import java.util.Set;

public class Role {

private Integer rId;
private String rName;
//修改这里
private Set<User> users = new HashSet<User>() ;

下面是getter 和setter..
}

修改对象关系映射

Role.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping  package="com.baidu.doublemany2many">

<class name="Role" table="ROLE">

<id name="rId" type="java.lang.Integer" >
<column name="R_ID" />
<generator class="native" />
</id>

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

<set name="users" table="T_USER_ROLE" inverse="true">
<key>
<column name="R_ID" />
</key>
<many-to-many class="User">
<column name="U_ID"></column>
</many-to-many>
</set>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

继承关系

持久化类：

Person.java

public class Person {

private Integer id;
private  String  name;

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;
}
}

Student.java

public class Student extends Person {

private  String school;

public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}

}

<hibernate-mapping package="com.baidu.subclass">

<!-- discriminator-value 的值：PERSON 可以随便写 -->
<class name="Person" table="PERSONS" discriminator-value="PERSON">

<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id>

<!-- 指定辨别者列  -->
<discriminator column="TYPE" type="string"></discriminator>

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

<property name="age" type="int">
<column name="AGE" />
</property>

<!-- 映射子类Strudent ，使用subclass 进行映射 -->
<subclass name="Student" discriminator-value="STUDENT">
<property name="school" type="string" column="SCHOOL"></property>
</subclass>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

<hibernate-mapping package="com.baidu.jionSubclass">

<!-- discriminator-value 的值：PERSON 可以随便写 -->
<class name="Person" table="PERSONS">

<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id>

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

<property name="age" type="int">
<column name="AGE" />
</property>

<!-- 映射子类Strudent ，使用joined-subclass 进行映射 -->

<joined-subclass name="Student" table="STUDENTS">
<key column="STUDENT_ID"></key>
<property name="school" type="string" column="SCHOOL"></property>
</joined-subclass>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

<hibernate-mapping package="com.baidu.UnionSubclass">

<!-- discriminator-value 的值：PERSON 可以随便写 -->
<class name="Person" table="PERSONS">

<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="hilo" />
</id>

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

<property name="age" type="int">
<column name="AGE" />
</property>

<!-- 映射子类Strudent ，使用union-subclass 进行映射 -->

<union-subclass name="Student" table="STUDENTS">
<property name="school" type="string" column="SCHOOL"></property>
</union-subclass>

</class>

</hibernate-mapping>

测试代码详见：点我去看详解代码

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

映射 关联关系

映射关联关系