001
014
015 package com.liferay.portal.kernel.transaction;
016
017 import com.liferay.portal.kernel.util.HashUtil;
018 import com.liferay.portal.kernel.util.StringBundler;
019 import com.liferay.portal.kernel.util.StringPool;
020
021 import java.util.Arrays;
022
023
026 public class TransactionConfig {
027
028 @Override
029 public boolean equals(Object obj) {
030 if (this == obj) {
031 return true;
032 }
033
034 if (!(obj instanceof TransactionConfig)) {
035 return false;
036 }
037
038 TransactionConfig transactionConfig = (TransactionConfig)obj;
039
040 if ((_isolation == transactionConfig._isolation) &&
041 Arrays.equals(
042 _noRollbackForClassNames,
043 transactionConfig._noRollbackForClassNames) &&
044 Arrays.equals(
045 _noRollbackForClasses,
046 transactionConfig._noRollbackForClasses) &&
047 (_propagation == transactionConfig._propagation) &&
048 (_readOnly == transactionConfig._readOnly) &&
049 Arrays.equals(
050 _rollbackForClassNames,
051 transactionConfig._rollbackForClassNames) &&
052 Arrays.equals(
053 _rollbackForClasses, transactionConfig._rollbackForClasses) &&
054 (_timeout == transactionConfig._timeout)) {
055
056 return true;
057 }
058
059 return false;
060 }
061
062 public Isolation getIsolation() {
063 return _isolation;
064 }
065
066 public Class<?>[] getNoRollbackForClasses() {
067 return _noRollbackForClasses;
068 }
069
070 public String[] getNoRollbackForClassNames() {
071 return _noRollbackForClassNames;
072 }
073
074 public Propagation getPropagation() {
075 return _propagation;
076 }
077
078 public Class<?>[] getRollbackForClasses() {
079 return _rollbackForClasses;
080 }
081
082 public String[] getRollbackForClassNames() {
083 return _rollbackForClassNames;
084 }
085
086 public int getTimeout() {
087 return _timeout;
088 }
089
090 @Override
091 public int hashCode() {
092 int hash = HashUtil.hash(0, _isolation);
093
094 if (_noRollbackForClassNames == null) {
095 hash = HashUtil.hash(hash, 0);
096 }
097 else {
098 for (String noRollbackForClassName : _noRollbackForClassNames) {
099 hash = HashUtil.hash(hash, noRollbackForClassName);
100 }
101 }
102
103 if (_noRollbackForClasses == null) {
104 hash = HashUtil.hash(hash, 0);
105 }
106 else {
107 for (Class<?> noRollbackForClass : _noRollbackForClasses) {
108 hash = HashUtil.hash(hash, noRollbackForClass);
109 }
110 }
111
112 hash = HashUtil.hash(hash, _propagation);
113
114 hash = HashUtil.hash(hash, _readOnly);
115
116 if (_rollbackForClassNames == null) {
117 hash = HashUtil.hash(hash, 0);
118 }
119 else {
120 for (String rollbackForClassName : _rollbackForClassNames) {
121 hash = HashUtil.hash(hash, rollbackForClassName);
122 }
123 }
124
125 if (_rollbackForClasses == null) {
126 hash = HashUtil.hash(hash, 0);
127 }
128 else {
129 for (Class<?> rollbackForClass : _rollbackForClasses) {
130 hash = HashUtil.hash(hash, rollbackForClass);
131 }
132 }
133
134 hash = HashUtil.hash(hash, _timeout);
135
136 return hash;
137 }
138
139 public boolean isReadOnly() {
140 return _readOnly;
141 }
142
143 @Override
144 public String toString() {
145 StringBundler sb = new StringBundler(17);
146
147 sb.append("{isolation=");
148 sb.append(_isolation);
149 sb.append(", noRollbackForClassNames=");
150 sb.append(Arrays.toString(_noRollbackForClassNames));
151 sb.append(", noRollbackForClasses=");
152 sb.append(Arrays.toString(_noRollbackForClasses));
153 sb.append(", propagation=");
154 sb.append(_propagation);
155 sb.append(", readOnly=");
156 sb.append(_readOnly);
157 sb.append(", rollbackForClassNames=");
158 sb.append(Arrays.toString(_rollbackForClassNames));
159 sb.append(", rollbackForClasses=");
160 sb.append(Arrays.toString(_rollbackForClasses));
161 sb.append(", timeout=");
162 sb.append(_timeout);
163 sb.append(StringPool.CLOSE_CURLY_BRACE);
164
165 return sb.toString();
166 }
167
168 public static class Builder {
169
170 public TransactionConfig build() {
171 return new TransactionConfig(this);
172 }
173
174 public Builder setIsolation(Isolation isolation) {
175 _isolation = isolation;
176
177 return this;
178 }
179
180 public Builder setNoRollbackForClasses(
181 Class<?>... noRollbackForClasses) {
182
183 _noRollbackForClasses = noRollbackForClasses;
184
185 return this;
186 }
187
188 public Builder setNoRollbackForClassNames(
189 String... noRollbackForClassNames) {
190
191 _noRollbackForClassNames = noRollbackForClassNames;
192
193 return this;
194 }
195
196 public Builder setPropagation(Propagation propagation) {
197 _propagation = propagation;
198
199 return this;
200 }
201
202 public Builder setReadOnly(boolean readOnly) {
203 _readOnly = readOnly;
204
205 return this;
206 }
207
208 public Builder setRollbackForClasses(Class<?>... rollbackForClasses) {
209 _rollbackForClasses = rollbackForClasses;
210
211 return this;
212 }
213
214 public Builder setRollbackForClassNames(
215 String... rollbackForClassNames) {
216
217 _rollbackForClassNames = rollbackForClassNames;
218
219 return this;
220 }
221
222 public Builder setTimeout(int timeout) {
223 _timeout = timeout;
224
225 return this;
226 }
227
228 private static final Class<?>[] _emptyClassArray = new Class<?>[0];
229
230 private Isolation _isolation = Isolation.DEFAULT;
231 private Class<?>[] _noRollbackForClasses = _emptyClassArray;
232 private String[] _noRollbackForClassNames = StringPool.EMPTY_ARRAY;
233 private Propagation _propagation = Propagation.REQUIRED;
234 private boolean _readOnly;
235 private Class<?>[] _rollbackForClasses = _emptyClassArray;
236 private String[] _rollbackForClassNames = StringPool.EMPTY_ARRAY;
237 private int _timeout = TransactionDefinition.TIMEOUT_DEFAULT;
238
239 }
240
241 public static class Factory {
242
243 public static TransactionConfig create(
244 Isolation isolation, Propagation propagation, boolean readOnly,
245 int timeout, Class<?>[] rollbackForClasses,
246 String[] rollbackForClassNames, Class<?>[] noRollbackForClasses,
247 String[] noRollbackForClassNames) {
248
249 Builder builder = new Builder();
250
251 builder.setIsolation(isolation);
252 builder.setPropagation(propagation);
253 builder.setReadOnly(readOnly);
254 builder.setTimeout(timeout);
255 builder.setRollbackForClasses(rollbackForClasses);
256 builder.setRollbackForClassNames(rollbackForClassNames);
257 builder.setNoRollbackForClasses(noRollbackForClasses);
258 builder.setNoRollbackForClassNames(noRollbackForClassNames);
259
260 return builder.build();
261 }
262
263 public static TransactionConfig create(
264 Propagation propagation, Class<?>[] rollbackForClasses,
265 Class<?>... noRollbackForClasses) {
266
267 return create(
268 Isolation.PORTAL, propagation, false, -1, rollbackForClasses,
269 new String[0], noRollbackForClasses, new String[0]);
270 }
271
272 }
273
274 private TransactionConfig(Builder builder) {
275 _isolation = builder._isolation;
276 _noRollbackForClassNames = builder._noRollbackForClassNames;
277 _noRollbackForClasses = builder._noRollbackForClasses;
278 _propagation = builder._propagation;
279 _readOnly = builder._readOnly;
280 _rollbackForClassNames = builder._rollbackForClassNames;
281 _rollbackForClasses = builder._rollbackForClasses;
282 _timeout = builder._timeout;
283 }
284
285 private final Isolation _isolation;
286 private final Class<?>[] _noRollbackForClasses;
287 private final String[] _noRollbackForClassNames;
288 private final Propagation _propagation;
289 private final boolean _readOnly;
290 private final Class<?>[] _rollbackForClasses;
291 private final String[] _rollbackForClassNames;
292 private final int _timeout;
293
294 }