BlogJava-Kira-2006-文章分类-hibernate

深入浅出Hibernate读书笔记--Hibernate常见优化策略

Kira-2006 — Wed, 28 May 2008 12:37:00 GMT

Hibernate一些常用的优化策略：
1. 在允许的情况下，选用最新版本的Hibernate的发行版。
2. 制定合理的缓存策略。
3. 采用合理的Session管理机制。
4. 尽量使用延迟加载特性。
5. 设定合理的批处理参数(batch_size)。
6. 如果可能，选用UUID作为主键生成器。
7. 如果可能，选用基于version的乐观锁策略替代悲观锁。
8. 开发过程中，打开Hibernate的SQL日志输出，通过观察Hibernate生成的sql语句进一步了解实现原理，从而指定更好的实现策略。

Kira-2006 2008-05-28 20:37 发表评论

深入浅出Hibernate学习笔记--Criteria Query

Kira-2006 — Sat, 10 May 2008 14:59:00 GMT

Criteria Query通过面向对象的设计，将数据查询条件封装为一个对象。简单来说，Criteria Query可以看作是传统SQL的对象化表示，如：

Criteria criteria=session.createCriteria(TUser.class);
criteria.add(Expression.eq("name","Erica"));
criteria.add(Expression.eq("sex",new Integer(1));

这里的criteria实例本质上是对SQL“select * from t_user where name='Erica' and sex=1”的封装。
Hibernate在运行期会根据Criteria中指定的查询条件生成相应的SQL语句。

Criteria查询表达式
Criteria本身只是一个容器，具体的查询条件要通过Criteria.add方法添加到Criteria实例中。

方法	描述
Expression.eq	对应SQL “field=value”表达式如：Expression.eq("name","Erica")
Expression.allEq	参数为一个Map对象，其中包含了多个属性-值对应关系。相当于多个Expression.eq关系的叠加
Expression.gt	对应SQL“field>value”表达式
Expression.ge	对应SQL“field>=value”表达式
Expression.lt	对应SQL“field
Expression.le	对应SQL“field<=value”表达式
Expression.between	对应SQL“between”表达式如：Expression.between("age",new Integer(13),new Integer(50));
Expression.like	对应SQL"field like valule"表达式
Expression.in	对应SQL“field in...”表达式
Expression.eqproperty	用于比较两个属性之间的值，对应SQL“field>field”
Expression.gtProperty	用于比较两个属性之间的值，对应SQL“field>=field”
Expression.ltProperty	用于比较两个属性之间的值，对应SQL"field
Expression.leProperty	用于比较两个属性之间的值，对应SQL"field<=field"
Expression.and	and关系组合，如： Expression.add(Expression.eq("name","Erica"),Expression.add("sex",new Integer(1)))
Expression.or	or关系组合，如： Expression.or(Expression.eq("name","Erica"),Expression.add("sex",new Integer(1)))
Expression.sql	作为补充，本方法提供了原生SQL语法的支持，我们可以通过这个方法直接通过SQL语句限定查询条件下面的代码返回所有名称以"Erica"其实的记录： Expression.sql("lower({alias}.name) like lower(?)","Erica%",Hibernate.STRING); 其中的"{alias}"将Hibernate在运行期使用当前关联的POJO别名替换

在Hibernate3中，引入了Restrictions类作为Expression的替代。

示例查询
Example类实现了Criteria接口，同样，它也可以用作Criteria的查询条件。Example的作用是：根据已有对象，查找属性与之相符的其他对象。

Criteria criteria=session.CreateCriteria(TUser.class);
TUser exampleUser=new TUser();
exapleUser.getName("Erica");
criteria.add(Example.create(exampleUser));

List<TUser> list=criteria.list();

for(TUser user:list){
System.out.println(user.getName());
}

新建一个TUser对象exampleUser，并作为范本，查询所有name属性与之相同的记录。

复合查询

Criteria criteria=session.createCriteria(TUser.class);
Criteria addrCriteria=criteria.createCriteria("addresses");
addrCriteria.add(Expression.like("addresses","%shanghai%"));

List<TUser> list = criteria.list();
for(TUser user:list){
    System.out.println(user.getName());
    Set<TAddress> addrSet=user.getAddresses();
    for(TAddress addr:addrSet){
        System.out.println(addr.getAddress());
    }
}

红色部分就是我们新增的复合查询条件，可以看到，我们可以通过Criteria.createCriteria方法在原有Criteria对象的基础上构建复合查询。

DetachedCriteria
Hibernate2中，Criteria生命周期位于其宿主Session生命周期中，也就是说，由某个session创建的Criteria实例，一旦session销毁，那么此Criteria实例也随之失效。
Hibernate3中引入了DetachedCriteria，DetachedCriteria可以脱离session实例独立存在，这样，我们就可以将某些通用的Criteria查询条件进行抽离，每次使用时再与当前session实例绑定以获得更好的代码重用效果。

DetachedCriteria deCriteria=DetachedCriteria.forClass(TUser.class);
deCriteria.add(Expression.eq("name","Erica"));
deCriteria.add(Expression.eq("sex",new Integer(1)));

Criteria criteria=deCriteria.getExecutableCriteria(session);
List<TUser> list=criteria.list();
for(TUser user:list){
System.out.println(user.getName());
}

DetachedCriteria的生存周期与session实例无关，我们可以独立创建DetachedCriteria实例，并在需要使用时与session相绑定，从而获得运行期Criteria实例。这样，我们就可以将查询逻辑和Criteria实例分离，以获得最大化代码的重用效果。
DetachedCriteria也可以用于子查询表达：

DetachedCriteria aveAge=DetachedCriteria.forClass(TUser.class);
avgAge.setProjection(Projections.avg("age"));

Criteria criteria=session.createCriteria(TUser.class);
criteria.add(Subqueries.propertyGT("age",avgAge));

通过Subqueries我们可以将DetachedCriteria纳入查询表达式，反映在SQL上则是一个典型的子查询语句。上例生成的SQL语句大致如：select ... from T_User where age > (select avg(age) from T_User)

Criteria高级特性
限定返回的记录范围
通过criteria.setFirstResult/setMaxResults方法可以限制一次查询返回的记录范围：

Criteria criteria=session.createCriteria(TUser.class);
//限定查询返回检索结果中，从100条结果开始的20条记录
criteria.setFirstResult(100);
criteria.setMaxResults(20);

记录排序：

//
//
Criteria criteria=session.createCriteria(TUser.class);
criteria.add(Expression.eq("groupId",new Integer(2)));

criteria.addOrder(Order.asc("name"));
criteria.addOrder(Order.desc("groupId"));

分组与统计
在Hibernate3中，我们还可以通过Criteria完成分组和统计。分组、统计表达式由Hibernate3新引入的Projections Class进行封装。

Criteria criteria=session.createCriteria(TUser.class);
criteria.setProjection(Projections.groupProperty("age"));

List<TUser> list=criteria.list();
for(TUser user:list){
System.out.println(user);
}

上例对当前的TUser记录按照年龄进行分组。通过Projections.groupProperty方法，我们指定了用于分组的目标属性“age”。生成的SQL语句：select this.age as y0_ from T_User this_group by this_.age。
另外，对于多条件组合的统计、分组功能，我们可以借助ProjectionList完成，下面的例子中，我们统计了各个年龄层次中的用户数量：

ProjectionList projectionlist=Projections.ProjectionList();
projectionList.add(Projections.groupProperty("age"));
projectionList.add9Projections.rowCount());

Criteria criteria=session.createCriteria(TUser.class);
criteria.setProjection(projectionList);

Kira-2006 2008-05-10 22:59 发表评论

深入浅出Hibernate学习笔记--数据关联

Kira-2006 — Sat, 10 May 2008 12:08:00 GMT

一对一关联
主键关联：即两张表通过主键形成一对一映射关系。

    用户TUser与护照TPassport关联
    TUer.hbm.xml

<hibernate-mapping>
<class
    name="TUser"
    table="T_User">

    <one-to-one
        name="passport"
        class="TPassport"
        cascade="all"
        outer-join="true"/>

class>
hibernate-mapping>

cascade="all"表示级联关系设置为“all”，即无论主空房执行任何操作，都会关联类执行相同的操作。

TPassport.hbm.xml

<hibernate-mapping>
<class
    name="TPassport"
    table="T_Passport">
    <one-to-one
        name="user"
        class="TUser"
        constrain="true">
    .
class>
hibernate-mapping>

constrain必须设定为“true”，以告知Hibernate当前主键上存在一个约束。

测试代码：

TUser user = new TUser();
user.setAge(new Integer(20));
user.setName("Carin");

TPassport passport = new TPassport();
passport.setSerial("PCN759386");
passport.setExpiry(new Integer(20080101));

//相互设置关联
passport.setUser(user);
user.setPassport(passport);

Transaction tx = sessioin.beginTransaction();
//由于TUser类的one-to-one节点被设置成
//cascade=“all”其关联的passport对象将被级联保存
session.save(user);

tx.commit();

以下代码完成关联对象的读取：

TUser user=(TUser)Hibernate.load(TUser.class,new Integer(15));
System.out.println("User name=>"+user.getName());
System.out.println("Passport Serial=>"+user.getPassport().getSerial());

控制台输出：

Hibernate:select tuser0_.id as id1_,
from T_USER tuser0_
left outer join
T_PASSPORT tpassport1_ on tuser0_.id=tpassport1_.id
where tuser0_.id=?
User name=>Carin
Passport Serial=>PCN759386

Hibernate通过left outer join将T_User表及其关联的T_Passport表同时读入，因为此时将out-join=“true”。若设置为false，则会分开读取两个表。

一对多关联
    用户TUser和地址TAddress的一对多关联。
    单向一对多关联
        主控方TUser的映射配置：

<hibernate-mapping>
<class
    name="TUser"
    table="t_user"
    dynamic-update="true"
    dynamic-insert="true">
.
    <set
        name="address"
        table="t_address"
        cascade="all"
        order-by="zipcode asc">
        <key column="user_id"/>
        <one-to-many class="TAddress">
    set>

class>
hibernate>

被动方TAddress的记录由Hibernate负责读取，之后存放在主控方TUser指定的Collection类型属性中。
单向一对多的实现比较简单，但是存在一个问题，由于是单向关联，为了保持关联关系，我们只能通过主控方对被动方进行级联更新。如果被关联方的关联字段为“NOT NULL”，当Hibernate创建或者更新时，可能出现约束违例。

双向多对一关联
实际上是“一对多”与“多对一”关联的组合。也就是说我们必须在主控方配置一对多关系的基础上，在被控方配置与其对应的多对一关联。
TUser.hbm.xml

<hibernate-mapping>
<class
    name="TUser"
    table="t_user"
    dynamic-update="true"
    dynamic-insert="true">
.
    <set
        name="address"
        table="t_address"
        lazy="false"
        inverse="true"
        cascade="all"
        sort="unsorted"
        order-by="zipcode asc">
        <key column="user_id"/>
        <one-to-many class="TAddress"/>
    set>
.
class>
hibernate>

inverse="true"，TUser不在作为主控方，而是将关联关系的维护工作交给关联对象TAddress来做。
在one-to-many关系中，将many一方设置为主控方（inverse=“true”）将有助于性能的改善。
TAddress.hbm.xml

<hibernat-mapping>
<class
    name="TAddress"
    table="t_address"
    dynamic-update="false"
    dynamic-insert="false">
.
    <many-to-one
        name="user"
        class="TUser"
        cascade="none"
        outer-join="auto"
        update="true"
        insert="true"
        access="property"
        column="user_id"
        not-null="true"/>
.
class>
hibernate-mapping>

多对多关联
需要借助中间表来完成多对多映射信息的保存。
    由于多对多关联的性能不佳（由于引入了中间表，一次读取操作需要反复多次查询），因此在设计中应该避免大量使用。同时，在多对多关系中，应根据情况，采取延迟加载机制来避免无谓的性能开销。
    TGroup与TRole的多对多关联：
    TGroup.hbm.xml：

<hibernate-mapping>
<class
    name="TGroup"
    table="t_group"
    dynamic-update="false"
    dynamic-insert="false">
.
    <set
        name="roles"
        table="t_group_role"
        lazy="false"
        inverse="false"
        cascade="save-update">
        <key column="group_id"/>
        <many-to-many
            class="TRole"
            column="role_id"/>
    set>
.
class>
hibernate>

t_group_role为t_group与t_role之间的映射表，它保存了group和role之间的映射关系。
cascade=“save-update”，对于多对多逻辑而言，很少出现删除一方需要级联删除所有关联数据的情况，如删除一个group，一般不会删除其中包含的Role。
column=“group_id”映射表中对于t_group表记录的标识字段。

TRole.hbm.xml：

<hibernate-mapping>
<class
    name="TRole"
    table="t_role"
    dynamic-update="false"
    dynamic-insert="false">
.
    <set
        name="groups"
        table="t_group_role"
        lazy="false"
        inverse="true"
        cascade="save-update"
        sort="unsorted">
        <key column="role_id"/>
        <many-to-many
            class="TGroup"
            column="group_id"
            outer-join="auto"/>
    set>
.
class>
hibernate>

多对多关系中，由于关联关系是两张表相互引用，因此在保存关联状态时必须对双方同时保存。

Kira-2006 2008-05-10 20:08 发表评论

深入浅出Hibernate笔记--1.2.1持久化设计与解耦

Kira-2006 — Fri, 02 May 2008 11:33:00 GMT

摘要: 解耦合的设计目标： 1. 应用层解耦合--应用逻辑与数据逻辑相分离。 2. 资源层解耦合--逻辑结构与物理结构相分离。 DAO模式：即Data Accessor模式和Active Domain Object模式。 Data Accessor模式... 阅读全文

Kira-2006 2008-05-02 19:33 发表评论

Hibernate生成器

Kira-2006 — Sat, 26 Apr 2008 10:15:00 GMT

设置主键生成器

Hibernate框架内建为主键提供了多种生成器，具体包括如下内容：
1. increment：用于为long，short，int类型生成唯一标识。
2. identity：对DB2，MySQL，MS SQL Server，Sybase和HypersonicSQL的内置标识字段提供支持。
3. sequence：在DB2，PostgreSQL，Oracle，SAPDB，McKoi中使用序列（sequence），而在Interbase中使用生成器（generator）。
4. hilo：使用一个高/低位算法高效生成long，short或int类型的标识符。给定一个表和字段（默认分别是hibernate_unique_key和next）作为高位值的来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。
5. seqhilo：使用一个高/低位算法高效生成long，short或int类型的标识符，给定一个数据库序列（sequence）的名字。
6. uuid.hex：用一个128-bit的UUID算法生成字符串类型的标识符。在一个网络中是唯一的（使用了IP地址）。UUID被编码位一个32位16进制数字的字符串。
7. uuid.string：使用同样的UUID算法。UUID被编码位一个16个字符长的任意ASCII字符组成的字符串。
8. native：根据底层数据库的能力选择identity、sequence、hilo中的一个。
9. assigned：让应用程序在插表之前为对象分配一个标识符。
10. foreign：使用另一个相关联的对象的标识符。通常被用在有关联关系的表中。

一般来说，在Hibernate中，不推荐用assigned作为主键生成器。因为对数据库表来说，以业务逻辑字段作为主键有潜在的危险性。当该业务逻辑字段在将来需要改变的时候，作为主键的应用就会相当麻烦。常用的手段是用一个和业务无关的字段作为主键，而在PO中定义这个字段成为变量属性，同事又作为该对象的惟一标识。

Kira-2006 2008-04-26 18:15 发表评论