标签：
一 关联关系的种类
1. 单向 多对 1
2. 单向 1 对多
3. 双向 多对1
4. 双向 1 对多
5. 一对一
①. 外键映射
②. 主键映射
6. 多对多
7. 继承关系
解释：
什么是单向？ 单向就是： 可以通过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;
}
}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;
}
}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 + "]";
}
}对象关系映射
Classbj.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.l2n">
<class name="Classbj" table="CLASSBJS">
<id name="classId" type="java.lang.Integer">
<column name="CLASS_ID" />
<generator class="native" />
</id>
<property name="className" type="java.lang.String">
<column name="CLASS_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="CLASS_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
<?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="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 (可选): 被关联的类的实体名。
外键关联
例: Person 和Card
，一个用户对应一个卡
这种关联Card 中是用 many-to-one， 然后用unique="true" 做限制，限制成一对一的关系。所以，一对一的外键关联其实就是多对一关联的一种特例。
标签：
原文地址：http://blog.csdn.net/chuck_kui/article/details/51541790
