← Back to branch summary

~ubuntu-branches/ubuntu/wily/libhibernate3-java/wily-proposed

« back to all changes in this revision

Viewing changes to src/org/hibernate/transaction/CacheSynchronization.java

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-10-14 14:43:34 UTC
  • Revision ID: james.westby@ubuntu.com-20071014144334-eamc8i0q10gs1aro
Tags: upstream-3.2.5
Import upstream version 3.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/hibernate/transaction/CacheSynchronization.java
 
1
//$Id: CacheSynchronization.java 9239 2006-02-08 22:34:34Z steveebersole $
 
2
package org.hibernate.transaction;
 
3
 
 
4
import javax.transaction.Status;
 
5
import javax.transaction.Synchronization;
 
6
import javax.transaction.SystemException;
 
7
import javax.transaction.Transaction;
 
8
 
 
9
import org.apache.commons.logging.Log;
 
10
import org.apache.commons.logging.LogFactory;
 
11
import org.hibernate.TransactionException;
 
12
import org.hibernate.jdbc.JDBCContext;
 
13
import org.hibernate.util.JTAHelper;
 
14
 
 
15
/**
 
16
 * @author Gavin King
 
17
 */
 
18
public final class CacheSynchronization implements Synchronization {
 
19
 
 
20
        private static final Log log = LogFactory.getLog(CacheSynchronization.class);
 
21
 
 
22
        private final TransactionFactory.Context ctx;
 
23
        private JDBCContext jdbcContext;
 
24
        private final Transaction transaction;
 
25
        private final org.hibernate.Transaction hibernateTransaction;
 
26
 
 
27
        public CacheSynchronization(
 
28
                        TransactionFactory.Context ctx, 
 
29
                        JDBCContext jdbcContext, 
 
30
                        Transaction transaction, 
 
31
                        org.hibernate.Transaction tx
 
32
        ) {
 
33
                this.ctx = ctx;
 
34
                this.jdbcContext = jdbcContext;
 
35
                this.transaction = transaction;
 
36
                this.hibernateTransaction = tx;
 
37
        }
 
38
 
 
39
        public void beforeCompletion() {
 
40
                log.trace("transaction before completion callback");
 
41
 
 
42
                boolean flush;
 
43
                try {
 
44
                        flush = !ctx.isFlushModeNever() &&
 
45
                                ctx.isFlushBeforeCompletionEnabled() && 
 
46
                                !JTAHelper.isRollback( transaction.getStatus() ); 
 
47
                                        //actually, this last test is probably unnecessary, since 
 
48
                                        //beforeCompletion() doesn't get called during rollback
 
49
                }
 
50
                catch (SystemException se) {
 
51
                        log.error("could not determine transaction status", se);
 
52
                        setRollbackOnly();
 
53
                        throw new TransactionException("could not determine transaction status in beforeCompletion()", se);
 
54
                }
 
55
                
 
56
                try {
 
57
                        if (flush) {
 
58
                                log.trace("automatically flushing session");
 
59
                                ctx.managedFlush();
 
60
                        }
 
61
                }
 
62
                catch (RuntimeException re) {
 
63
                        setRollbackOnly();
 
64
                        throw re;
 
65
                }
 
66
                finally {
 
67
                        jdbcContext.beforeTransactionCompletion(hibernateTransaction);
 
68
                }
 
69
        }
 
70
 
 
71
        private void setRollbackOnly() {
 
72
                try {
 
73
                        transaction.setRollbackOnly();
 
74
                }
 
75
                catch (SystemException se) {
 
76
                        log.error("could not set transaction to rollback only", se);
 
77
                }
 
78
        }
 
79
 
 
80
        public void afterCompletion(int status) {
 
81
                if ( log.isTraceEnabled() ) {
 
82
                        log.trace("transaction after completion callback, status: " + status);
 
83
                }
 
84
                try {
 
85
                        jdbcContext.afterTransactionCompletion(status==Status.STATUS_COMMITTED, hibernateTransaction);
 
86
                }
 
87
                finally {
 
88
                        if ( ctx.shouldAutoClose() && !ctx.isClosed() ) {
 
89
                                log.trace("automatically closing session");
 
90
                                ctx.managedClose();
 
91
                        }
 
92
                }
 
93
        }
 
94
        
 
95
        public String toString() {
 
96
                return CacheSynchronization.class.getName();
 
97
        }
 
98
 
 
99
}