001: package com.completex.objective.components.persistency.core.adapter;
002:
003: import com.completex.objective.components.log.Log;
004: import com.completex.objective.components.log.adapter.StdErrorLogAdapter;
005: import com.completex.objective.components.persistency.OdalRuntimePersistencyException;
006: import com.completex.objective.components.persistency.core.DatabasePolicy;
007: import com.completex.objective.components.persistency.core.PolicyAware;
008: import com.completex.objective.components.persistency.core.impl.DatabasePolicyFactory;
009: import com.completex.objective.components.persistency.core.impl.DatabaseTransactionManager;
010: import com.completex.objective.components.persistency.transact.JoiningTransactionManagerFactory;
011: import com.completex.objective.components.persistency.transact.TransactionManager;
012: import com.completex.objective.components.persistency.transact.TransactionManagerFactory;
013: import com.completex.objective.components.persistency.transact.impl.JoiningNullTransactionManagerImpl;
014: import com.completex.objective.components.persistency.transact.impl.JoiningTransactionManagerImpl;
015: import com.completex.objective.util.TypeUtil;
016:
017: import javax.sql.DataSource;
018: import java.util.HashMap;
019:
020: /**
021: * Transaction Manager Factory dispatcher - redirects newTransactionManager() to
022: * a concrete TransactionManagerFactory.
023: *
024: * Currently, 3 types of concrete TransactionManagerFactory classes are internally registered:
025: * JDBC (default), JDBC_PRIMITIVE and JTA. Use <code>setType</code> method to set a different concrete factory.
026: *
027: * @see JdbcTransactionManagerFactory
028: * @see JtaTransactionManagerFactory
029: *
030: *
031: *
032: * @author Gennady Krizhevsky
033: */
034: public class DefaultTransactionManagerFactory implements
035: TransactionManagerFactory, PolicyAware,
036: JoiningTransactionManagerFactory {
037:
038: protected static final Log DEFAULT_LOG = StdErrorLogAdapter
039: .newLogInstance();
040:
041: /**
042: * Transaction types
043: */
044: public static final String TYPE_JDBC = "JDBC";
045: public static final String TYPE_JDBC_PRIMITIVE = "JDBC_PRIMITIVE";
046: public static final String TYPE_JTA = "JTA";
047:
048: //
049: // Register default concrete factories:
050: //
051: private HashMap concreteFactories = new HashMap();
052:
053: public DefaultTransactionManagerFactory() {
054: registerConcreteFactory(TYPE_JDBC,
055: new JdbcTransactionManagerFactory());
056: registerConcreteFactory(TYPE_JDBC_PRIMITIVE,
057: new JdbcPrimitiveTransactionManagerFactory());
058: registerConcreteFactory(TYPE_JTA,
059: new JtaTransactionManagerFactory());
060:
061: }
062:
063: /**
064: * Default types are TYPE_XXX constants
065: */
066: private String type = TYPE_JDBC;
067:
068: private BasicPersistencyAdapter databasePersistency;
069:
070: private DataSource dataSource;
071: private DatabasePolicy databasePolicy;
072: private int stmtCacheSize;
073: private boolean useBatchModify;
074: private String userTransactionName;
075: private boolean checkForBadConnection;
076: private Log logger;
077: //
078: // Set the following in case datasource is null:
079: //
080: private String driver;
081: private String url;
082: private String user;
083: private String password;
084: private long timeout;
085: private int maxConnections;
086:
087: /**
088: * Retuns new instance of non commiting/rollbacking wrapper for coreTransactionManager
089: *
090: * @param coreTransactionManager
091: * @return new instance of non commiting/rollbacking wrapper for coreTransactionManager
092: */
093: public TransactionManager newJoiningNullTransactionManager(
094: TransactionManager coreTransactionManager) {
095: return new JoiningNullTransactionManagerImpl(
096: coreTransactionManager);
097: }
098:
099: /**
100: * Retuns new instance of non-releasing wrapper for coreTransactionManager.
101: * The returned TransactionManager instance will commit/rollback the current transaction
102: * w/o returning it to the pool. TransactionManager.begin() method will retrun current transaction.
103: *
104: * @param coreTransactionManager
105: * @return new instance of non-releasing wrapper for coreTransactionManager
106: */
107: public TransactionManager newJoiningTransactionManager(
108: TransactionManager coreTransactionManager) {
109: return new JoiningTransactionManagerImpl(coreTransactionManager);
110: }
111:
112: /**
113: * @see com.completex.objective.components.persistency.transact.TransactionManagerFactory#newTransactionManager()
114: */
115: public TransactionManager newTransactionManager() {
116: validateInit();
117:
118: TransactionManagerFactory factory = getConcreteFactory(type);
119:
120: if (factory == null) {
121: throw new OdalRuntimePersistencyException(
122: "Factory with type [" + type
123: + "] is not registered");
124: }
125: setup(factory);
126:
127: return factory.newTransactionManager();
128: }
129:
130: protected void setup(TransactionManagerFactory factory) {
131: if (factory instanceof BaseTransactionManagerFactory) {
132: BaseTransactionManagerFactory base = (BaseTransactionManagerFactory) factory;
133: if (databasePolicy == null && url != null) {
134: databasePolicy = DatabasePolicyFactory.getInstance()
135: .getDatabasePolicy(url);
136: if (databasePolicy == null) {
137: throw new OdalRuntimePersistencyException(
138: "databasePolicy == null "
139: + "and cannot find registered database policy by db url "
140: + url);
141: }
142: }
143: base.setCheckForBadConnection(checkForBadConnection);
144: base.setDatabasePolicy(getDatabasePolicy());
145: base.setDataSource(getDataSource());
146: base.setLogger(logger);
147: base.setStmtCacheSize(getStmtCacheSize());
148: base.setUseBatchModify(isUseBatchModify());
149: if (factory instanceof JtaTransactionManagerFactory) {
150: JtaTransactionManagerFactory jtaFactory = (JtaTransactionManagerFactory) factory;
151: jtaFactory.setUserTransactionName(userTransactionName);
152: } else if (factory instanceof JdbcTransactionManagerFactory) {
153: JdbcTransactionManagerFactory jdbcFactory = (JdbcTransactionManagerFactory) factory;
154: if (getDataSource() == null) {
155: DefaultDataSourceFactory datasourceFactory = new DefaultDataSourceFactory();
156: datasourceFactory.setDriver(driver);
157: datasourceFactory.setLogger(logger);
158: datasourceFactory.setMaxConnections(maxConnections);
159: datasourceFactory.setPassword(password);
160: datasourceFactory.setTimeout(timeout);
161: datasourceFactory.setUrl(url);
162: datasourceFactory.setUser(user);
163: dataSource = datasourceFactory.newDataSource();
164: jdbcFactory.setDataSource(dataSource);
165: }
166: }
167: }
168: }
169:
170: public TransactionManagerFactory getConcreteFactory(String key) {
171: return (TransactionManagerFactory) concreteFactories.get(key);
172: }
173:
174: public synchronized void registerConcreteFactory(String key,
175: TransactionManagerFactory factory) {
176: concreteFactories.put(key, factory);
177: }
178:
179: public synchronized void unregisterConcreteFactory(String key,
180: TransactionManagerFactory factory) {
181: concreteFactories.remove(key);
182: }
183:
184: protected void validateInit() {
185: TypeUtil.assertNotNull(type, "Type");
186: }
187:
188: public String getType() {
189: return type;
190: }
191:
192: public void setType(String type) {
193: this .type = type;
194: }
195:
196: public DataSource getDataSource() {
197: return databasePersistency != null ? databasePersistency
198: .getDataSource() : dataSource;
199: }
200:
201: public void setDataSource(DataSource dataSource) {
202: this .dataSource = dataSource;
203: }
204:
205: public DatabasePolicy getDatabasePolicy() {
206: return databasePolicy;
207: }
208:
209: public void setDatabasePolicy(DatabasePolicy databasePolicy) {
210: this .databasePolicy = databasePolicy;
211: }
212:
213: public int getStmtCacheSize() {
214: return databasePersistency != null ? databasePersistency
215: .getStmtCacheSize() : stmtCacheSize;
216: }
217:
218: public boolean isUseBatchModify() {
219: return databasePersistency != null ? databasePersistency
220: .isUseBatchModify() : useBatchModify;
221: }
222:
223: /**
224: * Returns JNDI user transaction name
225: *
226: * @return JNDI user transaction name
227: */
228: public String getUserTransactionName() {
229: return userTransactionName;
230: }
231:
232: /**
233: * Sets JNDI user transaction name
234: *
235: * @param userTransactionName
236: */
237: public void setUserTransactionName(String userTransactionName) {
238: this .userTransactionName = userTransactionName;
239: }
240:
241: public Log getLogger() {
242: return logger;
243: }
244:
245: public void setLogger(Log logger) {
246: this .logger = logger;
247: }
248:
249: public boolean isCheckForBadConnection() {
250: return checkForBadConnection;
251: }
252:
253: public void setCheckForBadConnection(boolean checkForBadConnection) {
254: this .checkForBadConnection = checkForBadConnection;
255: }
256:
257: //
258: // Default datasource attributes:
259: //
260:
261: public String getDriver() {
262: return driver;
263: }
264:
265: public void setDriver(String driver) {
266: this .driver = driver;
267: }
268:
269: public String getUrl() {
270: return url;
271: }
272:
273: public void setUrl(String url) {
274: this .url = url;
275: }
276:
277: public String getUser() {
278: return user;
279: }
280:
281: public void setUser(String user) {
282: this .user = user;
283: }
284:
285: public String getPassword() {
286: return password;
287: }
288:
289: public void setPassword(String password) {
290: this .password = password;
291: }
292:
293: public long getTimeout() {
294: return timeout;
295: }
296:
297: public void setTimeout(long timeout) {
298: this .timeout = timeout;
299: }
300:
301: public int getMaxConnections() {
302: return maxConnections;
303: }
304:
305: public void setMaxConnections(int maxConnections) {
306: this .maxConnections = maxConnections;
307: }
308:
309: public void setStmtCacheSize(int stmtCacheSize) {
310: this .stmtCacheSize = stmtCacheSize;
311: }
312:
313: public void setUseBatchModify(boolean useBatchModify) {
314: this .useBatchModify = useBatchModify;
315: }
316:
317: public void setUseBatchModify(
318: TransactionManager transactionManager,
319: boolean useBatchModify) {
320: if (transactionManager instanceof DatabaseTransactionManager) {
321: ((DatabaseTransactionManager) transactionManager)
322: .setUseBatchModify(useBatchModify);
323: }
324: }
325:
326: public void setDatabasePersistency(
327: BasicPersistencyAdapter databasePersistency) {
328: this .databasePersistency = databasePersistency;
329: }
330:
331: public BasicPersistencyAdapter getDatabasePersistency() {
332: return databasePersistency;
333: }
334:
335: public static boolean isJdbcType(String typeName) {
336: return TYPE_JDBC.equals(typeName);
337: }
338:
339: public static boolean isJdbcGroupType(String typeName) {
340: return TYPE_JDBC.equals(typeName)
341: || TYPE_JDBC_PRIMITIVE.equals(typeName);
342: }
343:
344: }
|