TransactionTemplate.java
5.26 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/*
* Decompiled with CFR 0_118.
*
* Could not load the following classes:
* javax.transaction.HeuristicMixedException
* javax.transaction.HeuristicRollbackException
* javax.transaction.NotSupportedException
* javax.transaction.RollbackException
* javax.transaction.SystemException
* javax.transaction.Transaction
* javax.transaction.TransactionManager
* org.slf4j.Logger
* org.slf4j.LoggerFactory
*/
package com.adobe.pdfg.transaction;
import com.adobe.pdfg.transaction.DefaultTransactionDefinition;
import com.adobe.pdfg.transaction.TransactionCallback;
import com.adobe.pdfg.transaction.TransactionDefinition;
import com.adobe.pdfg.transaction.exception.TransactionException;
import com.adobe.pdfg.transaction.exception.TransactionSystemException;
import java.lang.reflect.UndeclaredThrowableException;
import javax.transaction.HeuristicMixedException;
import javax.transaction.HeuristicRollbackException;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/*
* This class specifies class file version 49.0 but uses Java 6 signatures. Assumed Java 6.
*/
public class TransactionTemplate
extends DefaultTransactionDefinition {
protected final Logger logger;
private TransactionManager transactionManager;
public TransactionTemplate() {
this.logger = LoggerFactory.getLogger(this.getClass());
}
public TransactionTemplate(TransactionManager transactionManager) {
this.logger = LoggerFactory.getLogger(this.getClass());
this.transactionManager = transactionManager;
}
public TransactionTemplate(TransactionManager transactionManager, TransactionDefinition transactionDefinition) {
super(transactionDefinition);
this.logger = LoggerFactory.getLogger(this.getClass());
this.transactionManager = transactionManager;
}
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public TransactionManager getTransactionManager() {
return this.transactionManager;
}
public void afterPropertiesSet() {
if (this.transactionManager == null) {
throw new IllegalArgumentException("Property 'transactionManager' is required");
}
}
public <T> T execute(TransactionCallback<T> action) throws TransactionException {
T result;
boolean selfOwned = true;
try {
selfOwned = this.acquireTransaction();
result = action.doInTransaction();
if (selfOwned) {
this.commitTransaction();
}
}
catch (RuntimeException ex) {
this.rollbackOnException(ex, selfOwned);
throw ex;
}
catch (Error err) {
this.rollbackOnException(err, selfOwned);
throw err;
}
catch (Exception ex) {
this.rollbackOnException(ex, selfOwned);
throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
}
return result;
}
private void rollbackOnException(Throwable ex, boolean selfOwned) throws TransactionException {
this.logger.debug("Initiating transaction rollback on application exception", ex);
try {
if (selfOwned) {
this.rollbackTransaction();
} else {
this.transactionManager.setRollbackOnly();
}
}
catch (TransactionSystemException ex2) {
this.logger.error("Application exception overridden by rollback exception", ex);
this.logger.trace(ex2.getMessage(), (Throwable)ex2);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException ex2) {
this.logger.error("Application exception overridden by rollback exception", ex);
this.logger.trace(ex2.getMessage(), (Throwable)ex2);
throw ex2;
}
catch (Error err) {
this.logger.error("Application exception overridden by rollback error", ex);
this.logger.trace(err.getMessage(), (Throwable)err);
throw err;
}
catch (SystemException ex3) {
this.logger.error("Application exception overridden by rollback exception", ex);
throw new TransactionSystemException("SystemException while rolling back transaction", (Throwable)ex3);
}
}
private boolean acquireTransaction() throws SystemException, NotSupportedException {
Transaction trans = this.transactionManager.getTransaction();
if (trans != null && trans.getStatus() == 0) {
return false;
}
this.transactionManager.begin();
return true;
}
private void commitTransaction() throws SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException, SystemException {
this.transactionManager.commit();
}
private void rollbackTransaction() throws IllegalStateException, SecurityException, SystemException {
this.transactionManager.rollback();
}
}