一 关联关系的种类
1. 单向 多对 1
2. 单向 1 对多
3. 双向 多对1
4. 双向 1 对多
5. 一对一
①. 外键映射
②. 主键映射
6. 单向 多对多
7. 双向 多对多
8. 继承关系
解释：
什么是单向？ 单向就是： 可以通过A 中 B 的id 查找的B 中的对象，
但是,不能通过B查到A 中的对象，
说白一点就是，可以通过我找到你，但是不能通过你来找我
什么是双向？双向就是： 可以通过A 中 B 的id 查找的B 中的对象，
但是,也能通过B查到A 中的对象，
说白一点就是，可以通过我找到你，也可以通过你来找我
什么是多？多：就是集合 set
什么是1？ 1 ：就是1那一端的类的一个对象
因此：把 “对”字后面的放入前面里面： 后面是 多，就放set 集合
后面是 1 ，就放一个类的对象
单向 1 对多：就是 在1 这一端放入一个多那一端的set集合；
单向 多对 1：就是在 多 这一端，放入一个 1 这一端类的对象
双向 多对 1：就是在 多 这一端，放入一个 1 这一端类的对象；
再在1 这一端放入一个 多 那一端的set集合
双向 1 对多：在1 这一端放入一个 多 那一端的set集合
再在 多 这一端，放入一个 1 这一端类的对象
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;
}
}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>
<!-- 映射1 对多的那个集合属性 -->
<!--
set:映射set类型的属性，
table：set 中的元素对应的记录放到哪一个数据表中。该值需要和多对1 的多的那个表中的名字一致
inverse：指定 inverse=true，使1 的一端放弃维护关联关系
cascade：设置级联操作： 开发时，不建议设定该属性，建议使用手工的方式来处理
级联操作的取值有一下几种：
all: 所有情况下均进行关联操作，即save-update和delete。
none: 所有情况下均不进行关联操作。这是默认值。
save-update: 在执行save/update/saveOrUpdate时进行关联操作。
delete: 在执行delete 时进行关联操作。
all-delete-orphan: 当一个节点在对象图中成为孤儿节点时，删除该节点
-->
<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;
}
}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>
<?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
}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..
}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><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;
}
}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>测试 代码详见： 点我去看详解代码
扫一扫
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
