BlogJava-honzeland-随笔分类-Hibernate

GWT 2 Spring 3 JPA 2 Hibernate 3.5 Tutorial – Eclipse and Maven 2 showcase

honzeland — Fri, 20 Aug 2010 05:01:00 GMT

See details at: http://www.javacodegeeks.com/2010/07/gwt-2-spring-3-jpa-2-hibernate-35.html

Executing Simple Joins Across Owned Relationships for gae: http://gae-java-persistence.blogspot.com/2010/03/executing-simple-joins-across-owned.html

honzeland 2010-08-20 13:01 发表评论

Hibernate Annotations

honzeland — Tue, 20 Apr 2010 09:20:00 GMT

Use one single table "blank_fields" for both A and B. "blank_fields" has fields: 'ref_id', 'blank_field', 'type'. 'type' is used to identify which entity the record belongs to. Use 'type' + 'ref_id' to specify the collection of elements for one entity.

@Entity
@Table(name = "table_a")
public class A {
    private Set<BlankField> blankFields = new HashSet<BlankField>();

    @CollectionOfElements
    @Fetch(FetchMode.SUBSELECT)
    @Enumerated(EnumType.ORDINAL)
    @JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "ref_id") })
    @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
    @Column(name = "blank_field", nullable = false)
    @SQLInsert(sql = "INSERT INTO blank_fields(ref_id, blank_field, type) VALUES(?,?,0)")
    @Where(clause = "type=0")
    public Set<BlankField> getBlankFields() { // BlankField is an enum
        return blankFields;
    }

    @SuppressWarnings("unused")
    private void setBlankFields(Set<BlankField> blankFields) {
        this.blankFields = blankFields;
    }
} // End B

@Entity
@Table(name = "table_b")
public class B {
    private Set<BlankField> blankFields = new HashSet<BlankField>();

    @CollectionOfElements
    @Fetch(FetchMode.SUBSELECT)
    @Enumerated(EnumType.ORDINAL)
    @JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "ref_id") })
    @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
    @Column(name = "blank_field", nullable = false)
    @SQLInsert(sql = "INSERT INTO blank_fields(ref_id, blank_field, type) VALUES(?,?,1)") // used for insert
    @Where(clause = "type=1") // used for query, if not @CollectionOfElements, such as @OneToMany, use @WhereJoinTable instead
    public Set<BlankField> getBlankFields() {
        return blankFields;
    }

    @SuppressWarnings("unused")
    private void setBlankFields(Set<BlankField> blankFields) {
        this.blankFields = blankFields;
    }
}

当然还有其他的方式来实现上面的需求，上面采用的单表来记录不同实体的associations（这儿是CollectionOfElements，并且返回的是Set，不是Set)，然后用'type'来区分不同的实体，这样做的好处是：数据库冗余少，易于扩展，对于新的实体，只需加一个type值，而不需更改数据库表结构。另外一种采用单表的方式是为每个实体增加新的字段，如"blank_fields": 'a_id', 'b_id', 'blank_field', a_id reference table_a (id), b_id reference table_b (id). 这样在映射的时候更简单，
对于A，映射为
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "a_id") })
对于B，映射为
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "b_id") })
这样作的缺点是：带来了数据库冗余，对于blank_fields来讲，任一条记录，a_id和b_id中只有一个不为null。当多个实体共用这个表时，用上面的方法更合理，如果共用实体不多时，这种方法更方便。

honzeland 2010-04-20 17:20 发表评论

One Hibernate Session Multiple Transactions

honzeland — Mon, 01 Mar 2010 03:47:00 GMT

The case to use One Hibernate Session Multiple Transactions:
each transaction would NOT affect others.
i.e., open multiple transactions on the same session, even though one transaction rolls back, other transactions can be committed. If one action fails, others should fail too, then we should use one transaction for all actions.

Note:
A rollback with a single Session will lead to that Session being cleared (through "Session.clear()").
So do lazy collections still work if the session is cleared? =>Not of any objects that you loaded up until the rollback. Only for new objects loaded afterwards.
We should load necessary objects to session for each transactional action to avoid LazyInitializationException, even if those objects are loaded before other forward transactional actions, since forward action may be rolled back and clear the session.

BTW, Hibernate Session.merge() is different with Session.update() by:

Item item2 = session.merge(item);
item2 == item; // false, item - DETACHED, item2 - PERSIST
session.update(item); // no return value, make item PERSIST

honzeland 2010-03-01 11:47 发表评论

org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

honzeland — Wed, 24 Feb 2010 10:02:00 GMT

发生这种异常的case:

    @Transactional
    public void foo() {
        try{
            bar();
        } catch (RuntimeException re) {
            // caught but not throw further

        }

    }

    @Transactional
    public void bar() {

    }

如果foo在调用bar的时候，bar抛出RuntimeException，Spring在bar return时将Transactional标记为Rollback only，而foo捕获了bar的RuntimeException，所以Spring将会commit foo的事务，但是foo和bar使用的是同一事务，因此在commit foo事务时，将会抛出UnexpectedRollbackException。注意：如果foo和bar在同一class中，不会出现这种情况，因为：

Since this mechanism is based on proxies, only 'external' method calls coming in through the proxy will be intercepted. This means that 'self-invocation', i.e. a method within the target object calling some other method of the target object, won't lead to an actual transaction at runtime even if the invoked method is marked with @Transactional!

可以通过配置log4j来debug Spring事务获取情况：
To delve more into it I would turn up your log4j logging to debug and also look at what ExerciseModuleController is doing at line 91, e.g.: add a logger for org.springframework.transaction

honzeland 2010-02-24 18:02 发表评论

Discussion for Open Session In View Pattern for Hibernate

honzeland — Fri, 29 Jan 2010 09:20:00 GMT

From: http://www.mail-archive.com/stripes-users@lists.sourceforge.net/msg02908.html

honzeland 2010-01-29 17:20 发表评论