Hibernate的多表设计以及加载策略

多对多配置

实体类

public class Course {
    private Integer id;
	private String name;
	private Set<Student> studentSet = new HashSet<Student>();
	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<Student> getStudentSet() {
		return studentSet;
	}
	public void setStudentSet(Set<Student> studentSet) {
		this.studentSet = studentSet;
	}
	
}

public class Student {

 private Integer id;
 private String name;
 private Set<Course> courseSet = new HashSet<Course>();
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<Course> getCourseSet() {
	return courseSet;
}
public void setCourseSet(Set<Course> courseSet) {
	this.courseSet = courseSet;
}
 
}

hbm.xml配置

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.study.hibernate" >
<!-- 实体类与数据库的对应关系 -->
<class   name="Student" table="t_student" dynamic-insert="false" select-before-update="true">
<id name="id" column="id" unsaved-value="1">
<!--主键生成策略  -->
<generator class="native"></generator>
</id>
<property name="name">
<column name="name"></column>
</property>

<!--
多对多配置:
set中的table:多对多关联的中间表
<key 中column:中间表中对应的列
<many-to-many表示是多对多关系，column表示与之对应的另一个表中的列
  -->
<set name="courseSet" table="t_student_course" inverse="false" cascade="save-update">
<key column="cno"></key>
<many-to-many class="Course" column="sno"/>
</set>
</class>
</hibernate-mapping>

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.study.hibernate" >
<!-- 实体类与数据库的对应关系 -->
<class   name="Course" table="t_course" dynamic-insert="false" select-before-update="true">
<id name="id" column="id" unsaved-value="1">
<!--主键生成策略  -->
<generator class="native"></generator>
</id>
<property name="name">
<column name="name"></column>
</property>
<!--通过学生来维护表之间的关系  -->
<set name="studentSet" table="t_student_course" inverse="true">
<key column="sno"></key>
<many-to-many class="Student" column="cno"/>
</set>
</class>
</hibernate-mapping>

加载策略:

按照其检索方式分为:

1.立即检索:立即查询，在执行查询语句时，立即查询所有的数据

2.延迟检索：延迟查询，在执行查询语句之后，在需要时查询

按照其检查策略的种类分为：

1.类级别检索:当前类的属性获取是否需要需要延迟

2.关联级别的检索：当前类关联另一个类是否需要延迟

 

类级别检索:

1.get方法:立即查询数据库，将数据初始化

2.load方法:hbm文件中,class元素的lazy属性决定是否需要延迟加载，true表示使用延迟加载。false表示不使用延迟加载，与get一样，立即加载数据，不配置则使用延迟加载

关联级别的加载策略:

在查询有关联关系的数据时，加载一方的数据是否需要将另一方立即查询出数据。默认情况下，关联的数据，在使用时才查询出数据。

关联级别的检索在set元素中有两个属性决定采用什么样的组合方式加载数据：

1.lazy: 是否对set数据使用懒加载
                    true:(默认值) 对集合使用时才加载
                    false: 集合将会被立即加载
                    extra: 极其懒惰,如果使用集合时,调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.

2.fetch : 决定加载集合使用的sql语句种类
                    select: (默认值) 普通select查询
                    join: 表链接语句查询集合数据
                    subselect: 使用子查询

 

一对多:

fetch="join"

lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询

fetch="select"

 

当前对象 和 关联对象 使用多条select语句查询。

lazy="false" , 立即，先查询客户select，立即查询订单select

lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

 lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）

<set name="orderSet" inverse="true" cascade="save-update" lazy="extra" fetch="select">

fetch="subselect"

 

使用子查询，注意一点：必须使用query查询才可以看到此现象

 

lazy:同上

 

多对一:

多对一:
        lazy
             false        加载数据时,会立即加载关联对象的数据
             proxy        看关联对象的类加载策略(lazy="true" 延迟加载，lazy="false" 立即加载)来决定
             no-proxy :
         fetch=
            select  : (默认值)使用普通select加载
            join    : 使用表链接加载数据，lazy无效
    
    fetch            lazy            结果
---------------------------------------------------
    select            false            加载对象时,立即加载关联对象数据.普通select语句加载关联对象.
    select            proxy            类加载策略为:lazy=false 同上
                                                 lazy=true    加载对象时,先不加载关联对象数据.使用关联对象数据时才加载
    join            false            使用表链接加载数据.lazy属性无效
    join            proxy            使用表链接加载数据.lazy属性无效

 

批量加载:

使用<set batch-size="5"> 表示每次加载关联对象时，加载几个.