Hibernate的检索方式：（查询/加载）
1． 通过OID加载 session.get(Users.class, 1); *
2． 通过HQL/SQL 检索
hibernate query language (面向对象的查询语言) *
a) 不再操纵表，它操纵的是持久化类的对象
b) 面向对象的
3． QBC ( query by criteria ) 更加面向对象
4． QBE ( query by Example )
5． SQL
Hibernate的检索策略：
1． 延迟检索（加载）映射文件中改变lazy
a) Lazy的取值：
i. Many-to-one
1. false
2. proxy
3. no-proxy
ii. set 一对多
1. true
2. false
3. extra 根据对set容器的不同，可以产生高效的sql访问
数据库
2． 批量检索：batch-size＝3
a) 可以使用批量检索：
b) 在内存中，如果有多个set（代理）容器需要初始化, 则当访问任何一个代理set容器时，一次初始化n个set容器，减少sql语句；
c) 产生的语句是：select * from ….. where FK in (?,?,?... …n);
3． 迫切(fetch)左外连接检索:
a) 在映射文件中设置：fetch(抓取)
i. Select 什么都不做
ii. Subselect 当访问内存中的一个代理容器时，一次将所有的set容器用一个子查询，全部初始化
iii. Join
1. 对OID检索方式有用
2. 对hql检索方式没有用
b) 在hql中要使用迫切左外连接时，必须加 left join fetch 对象.关系属性
i. 如果不加fetch关键字，则
hibernate不会抓取关系属性，但会遍历关系属性所对应的表
ii. 不加fetch关键字时，select 要指定返回的对象，否则它要返回数组
iii. 条件：持久化类之间有关系属性映射
Hibernate级联操作对象的关系属性：
映射文件中设置：
1． Cascade
a) none
b) Save-update 当使用session的api对当前对象进行save,update操作时，对它的关系属性也进行save或者update
c) Delete
d) All = delete + save-update
e) Delete-orphan 只是删除父子关系的子对象
f) All-delete-orphan 父子关系的表设为此值，表示，当删除一个父对象时，将这个set容器中的子对象全部删除
2． Inverse 只能在set映射时使用；它的作用是：是否根据set容器中存放的对象，产生update语句，维护关系（子）表的外键属性;取值为true时，将不产生update语句。当inverse设为true时，通过父亲增儿子时，必须建立双向关系.
Session的一级缓存：(相当于一系列的map容器，它是需要维护的)
1． 提高效率
2． 维护缓存中的对象和
数据库中对应表的记录之间进行同步
3． 当一级缓存中的对象状态（属性）发展生改变时，session在特定的时刻清理缓存：
a) 清理缓存的时间点：
i. Transaction.commit(); 事务提交时
ii. Session.flush();
4． 管理session一级缓存的方法
a) Session.evict(obj)从session的一级缓存中移出一个对象
b) Session.clear() 将一级缓存中的所有对象全部清空
c) Session.close() 关闭一个session
对象的状态和对象的生命周期：
持久化类的对象，在
hibernate应用中可以处于三种状态（根据对象和session之间的关系进行划分）：
1. 临时态，瞬态：特点：
a) 在
数据库中没有记录和它对应
b) 和session没有任何关系
c) New 出来的对象，都处于临时态
2. 持久态：特点：
a) 处于session的一级缓存中
b)
数据库中有一条记录和它对应
c) Session会在特定的时刻(清理缓存时)维护这个对象和
数据库中的记录进行同步
d) 在同一个session的缓存中，具有相同OID的持久态对象，只有一个（同一个session的一缓存中，不可能同时有两个OID相同的同一个持久化类的对象存在）
3. 游离态，脱管
a) 不在一级缓存之中
b)
数据库可能有记录和它对应，也可能没有记录和它对应
c) 从一个持久态对象转化过来的，从session的一级缓存中出来的，因为调用了session的一些方法，产生了这种对象（session.close()）
SessionFctory:
Hibernate映射一对多关系：
public class Dept implements java.io.Serializable {
// Fields
private Integer deptid;
private String deptname;
private Integer deptnum;
private Integer actNum;
private Date cdate;
private Set emps = new HashSet(0) ;
//getter/setter方法 略…
}
映射文件：
<
hibernate-mapping>
<class name="org.wllt.www.po.Dept " table="dept " catalog="
hibernate">
<id name="deptid" type="java.lang.Integer" >
<column name="deptid" />
<generator class="native" />
</id>
<property name="deptname" type="java.lang.String">
<column name="deptname" length="20" />
</property>
<property name="deptnum" type="java.lang.Integer">
<column name="deptnum" />
</property>
<property name="actNum" type="java.lang.Integer">
<column name="actNum" />
</property>
<property name="cdate" type="java.util.Date">
<column name="cdate" length="19" />
</property>
<set name="emps" inverse ="true" lazy="true" cascade="none" batch-size="2" fetch="join" >
<key>
<column name="deptid" />
</key>
<one-to-many class="org.wllt.www.po.Emp" />
</set>
</class>
</
hibernate-mapping>
Hibernate映射多对一:
public class Emp implements java.io.Serializable {
private Integer empid;
private Dept dept;
private String empname;
//getter/setter方法略
}
<
hibernate-mapping>
<class name="org.wllt.www.po.Emp" table="emp" catalog="
hibernate">
<id name="empid" type="integer">
<column name="empid" />
<generator class="native" />
</id>
<many-to-one name="dept" class="org.wllt.www.po.Dept" fetch="select" cascade ="none" lazy ="proxy">
<column name="deptid" />
</many-to-one>
<property name="empname" type="string">
<column name="empname" length="30" />
</property>
</class>
</
hibernate-mapping>
Hibernate映射一对一(通过主键实现一对一的关系)
//主PO对象（一个员工对个应一个身份证）
public class Employees implements Serializable{
private Integer empid;
private String name;
private String sex;
private Date birthday;
private Double salary;
//关系属性：
private Idcard idcard;
}
<
hibernate-mapping package ="org.wllt.www.po">
<class name="Employees" table="emp">
<id name="empid" type="java.lang.Integer">
<generator class="increment"/>
</id>
… 属性映射略
<one-to-one name="idcard" class="Idcard" fetch="select" lazy="proxy" cascade ="save-update">
</one-to-one>
</class>
</
hibernate-mapping>
//子PO对象
public class Idcard {
private Integer empid;
private String cardno;
private String addr;
private String fzjg;
private Date enddate;
//关系属性
private Employees emp;
}
<
hibernate-mapping package="org.wllt.www.po3">
<class name="Idcard">
<id name="empid" type="java.lang.Integer">
<generator class="foreign ">
<param name="property ">emp</param>
</generator>
</id>
<one-to-one name="emp" class="Employees" fetch="join" constrained="true" cascade="save-update" >
</one-to-one>
<property name="cardno" type="java.lang.String" />
<property name="addr" type="java.lang.String" />
<property name="fzjg" type="java.lang.String" />
<property name="enddate" type="java.util.Date"/>
</class>
</
hibernate-mapping>
Hibernate映射一对一(通过外键实现一对一的关系)
子表引用主表的主键做外键，这个外键建立了unique约束、not-null约束
//主对象：
public class Dept implements java.io.Serializable {
private Integer deptid;
private String deptname;
private Integer deptnum;
private Integer actNum;
private Date cdate;
//关系属性
private Phonenote phonenote;
}
<
hibernate-mapping>
<class name="org.wllt.www.po.Dept" table="dept"
catalog="
hibernate">
<id name="deptid" type="java.lang.Integer">
<column name="deptid" />
<generator class="native" />
</id>
<-- …property 映射略 -->
<one-to-one name="phonenote" class="org.wllt.www.po.Phonenote"
property-ref="dept" cascade ="all" fetch="join" >
</one-to-one>
</class>
</
hibernate-mapping>
子对象
public class Phonenote implements java.io.Serializable {
// Fields
private Integer phonid;
private Dept dept;
private String phonecode;
}
<
hibernate-mapping>
<class name="org.wllt.www.po.Phonenote" table="phonenote" catalog="
hibernate">
<id name="phonid" type="java.lang.Integer">
<column name="phonid" />
<generator class="native" />
</id>
<many-to-one name="dept" class="org.wllt.www.po.Dept" fetch="select" cascade ="all">
<column name="deptid" unique="true" />
</many-to-one>
<property name="phonecode" type="java.lang.String">
<column name="phonecode" length="20" not-null="true" />
</property>
</class>
</
hibernate-mapping>
Hibernate映射多对多(两个一对多实现多对多)
表：材料表和产品表多对多，在
数据库中有中间表即产品材料表用来存放两个表之间的关系
Java类：材料PO，产品PO，中间PO,中间PO的复合主键类（由于是两个一对多形成的多对多，所以，这里只讲一个一对多，另一个是相同的映射方法）
//产品类：
public class Product {
private Integer cpbh;
private String cpmc;
private String gg;
private String sh;
private String nbxh;
private String txm;
private String bzfs;
private Set proMals = new HashSet(0);
}
<
hibernate-mapping package="org.wllt.www.po">
<class name="Product" table="prod">
<id name="cpbh" type="java.lang.Integer">
<column name="pro_id"></column>
<generator class="increment"/>
</id>
<-- property 映射略 -->
<set name="proMals" inverse="true" cascade="all-delete-orphan">
<key>
<column name="pro_id"></column>
</key>
<one-to-many class="ProMal"/>
</set>
</class>
</
hibernate-mapping>
中间PO
public class ProMal {
private ProMalId id;
}
复合主键类：
public class ProMalId implements Serializable{
private Product product;
private Clzb clzb;
}
<
hibernate-mapping package="org.wllt.www.po">
<class name="ProMal" table="pro_mat">
<composite-id name="id" class ="ProMalId">
<key-many-to-one name ="product" class ="Product"
lazy="proxy" column="pro_id" >
</key-many-to-one>
<key-many-to-one name="clzb" class="Clzb"column="mat_id">
</key-many-to-one>
</composite-id>
</class>
</
hibernate-mapping>
Hibernate映射多对多(两个PO类直接实现多对多)
表：材料表和产品表多对多，在
数据库中有中间表即产品材料表用来存放两个表之间的关系
Java类：材料PO，产品PO，这两个PO分别包含一个set容器, 相互放对方的对象,没有中间PO, 程序员因为得不到中间PO对象,所以不能直接操作
数据库的中间表。中间表中的记录的维护工作，只能交给
hibernate来处理，这时，set容器的inverse属性必须设为false
主PO：
public class Users implements java.io.Serializable {
private Integer uerid;
private String name;
private String passwd;
private Set roles = new HashSet(0);
}
<
hibernate-mapping>
<class name="org.wllt.www.po2.Users" table="users" atalog="
hibernate">
<id name="uerid" type="java.lang.Integer">
<column name="UERID" />
<generator class="increment" />
</id>
<-- property的映射略 -->
<set name="roles" inverse ="false" table ="USERANDROLE">
<key>
<column name="UERID" not-null="true" />
</key>
<many-to-many class="org.wllt.www.po2.Roles " column ="ROLESID"/>
</set>
</class>
</
hibernate-mapping>
2298
非常没帮助
没帮助
一般
有帮助
非常有帮助
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
