TKDBManager


1   
2   package com.teamkonzept.db;
3   
4   import java.sql.*;
5   import java.util.Enumeration  ;
6   import java.util.Properties  ;
7   
8   import com.teamkonzept.lib.*;
9   import org.apache.log4j.Category;
10  
11  /**
12   * A manager for database connections of an application context.
13   * <br><br>
14   * Each thread is assigned to an application context. For each context this class
15   * manages a pool of database connections using an object of class {@link TKDBConnectionManager TKDBConnectionManager}.
16   * <br><br>
17   * Having initialized the database pool for each context,
18   * a concrete connection is assigned to each thread after the first request,
19   * until an explicit release of the connection.
20   * <br><br>
21   * Simultaneously, a thread can maintain several opened connections to different databases.
22   * Each context is then assigned to a single connection. By changing the context a thread
23   * may switch to another database connection.
24   * <br><br>
25   * This class is never instantiated.
26   * <br><br>
27   * @author  $Author: alex $
28   * @version $Revision: 1.26 $
29   * @see TKDBConnectionManager
30   */
31  public class TKDBManager {
32  
33      /** Logging Category */
34      private static final Category CAT = Category.getInstance(TKDBManager.class);
35  
36      /**
37       * A hashtable, which maps each context to its connection manager.
38       * <br><br>
39       * key(Object aContext) =&gt; value(TKDBConnectionManager aConnectionManager)
40       */
41  //      private static TKHashtable contextManager = new TKHashtable();
42  
43      /**
44       * A hashtable, which maps each thread to the connection manager
45       * of its actual context.
46       * <br><br>
47       * key(Thread aThread) =&gt; value(TKDBConnectionManager aConnectionManager)
48       */
49  //      private static TKHashtable threadManager = new TKHashtable();
50  
51      /**
52      * aktueller Kontext
53      */
54      // Thread, Context
55  //      private static TKHashtable currentContext  = new TKHashtable();
56      
57      /**
58       * A hashtable, which maps each thread to a hashtable of all contexts and the
59       * connection managers assigned to the contexts, where the thread has registered.
60       * <br><br>
61       * key(Thread aThread) =&gt; value(TKHashtable aTKHashtable(key (Object aContext) =&gt;
62       * value(TKDBConnectionManager aConnectionManager)))
63       */
64  //      private static TKHashtable threadContexts = new TKHashtable();
65  
66      /**
67      * Default Context
68      */
69  //      public final static Object DEFAULT_CONTEXT  = "com.teamkonzept.db.TKDBManagerDefaultContext";
70    
71      /**
72       * Ensures, that for the specified context exists a <code>TKDBConnectionManager</code>.
73       * <br><br>
74       * The specified context becomes the actual context of the specified thread.
75       * <br>
76       * Returns the responsible <code>TKDBConnectionManager</code>.
77       *
78       * @param thread    gets the specified context as actual context
79       * @return the responsible <code>TKDBConnectionManager</code> of the specified thread.
80       */
81  //      private static synchronized TKDBConnectionManager ensureManager( Thread thread, Object context )
82  //      {
83  //          TKDBConnectionManager currManager = (TKDBConnectionManager)contextManager.get(context);
84  //          if ( currManager == null ) 
85  //          {
86  
87  //              final Object currContext = getCurrentContext();
88  //              if (currContext != null) {
89  //                  // hole den Manager zum aktuellen Kontext
90  //                  currManager = (TKDBConnectionManager)contextManager.get( currContext );
91  //              }
92  
93  //  //              final boolean toClone;
94  //              if (currManager == null) {
95  //                  // hole den default-Manager
96  //                  currManager = (TKDBConnectionManager)contextManager.get(DEFAULT_CONTEXT);
97  //                  if (currManager == null) {
98  //                      // erzeuge einen neuen Manager
99  //                      // currManager = new TKDBConnectionManager();
100 //                      currManager = TKDBConnectionManager.getInstance();
101 //  //                      toClone = false;
102 //                  } 
103 //  //                  else {
104 //  //                      toClone = true;
105 //  //                  }
106 //              } 
107 //  //              else {
108 //  //                  toClone = true;
109 //  //              }
110 //  //              if ( toClone ) 
111 //  //              {
112 
113 //  //                  currManager = (TKDBConnectionManager)currManager.clone();
114 //  //              }
115 //              contextManager.put(context, currManager);
116 //          }
117 //          threadManager.put(thread, currManager);
118 //          return currManager;
119         //        return TKDBConnectionManager.getInstance();
120 //      }
121 
122     /**
123      * Registers the specified thread at this <code>TKDBManager</code>.
124      * @param currThread    the thread to be registered.
125      */
126     protected static final void register( Thread   currThread )
127     {
128 //          threadContexts.put( currThread, new TKHashtable() );
129     }
130 
131     /**
132      * Registers the current thread at this <code>TKDBManager</code>.
133      */
134     public static void register()
135     {
136 //          register( Thread.currentThread() );
137     }
138 
139     /**
140      * Registers the current thread at this <code>TKDBManager</code>
141      * and sets the specified context as its initial context.
142      *
143      * @param initialContext    the initial context to be assigned to the current thread.
144      */
145     public static void register( Object   initialContext )
146     {
147 //          Thread currThread = Thread.currentThread();
148 //          register( currThread );
149 //          try {
150 //              enterContext( currThread, initialContext, false );
151 //          }
152 //          catch( SQLException e ) {
153 //              throw new Error("Impossible error");
154 //          }
155     }
156 
157     /**
158      * Changes the context of the specified thread to the specified nextContext.
159      * Depending on the specified value of leaveOldContext, the connection in the
160      * previous context is released.
161      *
162      * @param currThread    the thread, of which the context has to be changed.
163      * @param nextContext   this context replaces the previous context of the specified thread.
164      * @param leaveOldContext   indicates if the connection in the previous context is released.
165      * @throws SQLException  normaler SQL Fehler
166      */
167     protected static void enterContext( Thread   currThread, Object   nextContext, boolean leaveOldContext ) throws SQLException
168     {
169         if( leaveOldContext ) {
170 //              TKDBConnectionManager connManager =
171 //                  (TKDBConnectionManager) threadManager.get( currThread );
172 //              if( connManager != null ) {
173 //                  connManager.freeConnection();
174 //              }
175             TKDBConnectionManager.getInstance().freeConnection();
176         }
177 
178 //          TKHashtable contextHash = (TKHashtable)threadContexts.get( currThread );
179 //          contextHash.put( nextContext, ensureManager( currThread, nextContext ) );
180 //          currentContext.put( currThread, nextContext );
181     }
182 
183     /**
184      * Replaces the context of the current thread with the specified nextContext.
185      */
186      /*
187     private static void enterContext( Object nextContext )
188     {
189         try {
190             enterContext( Thread.currentThread(), nextContext, false );
191         }
192         catch( SQLException e ) {
193             throw new Error("Impossible error");
194         }
195     }
196 */
197     /**
198      * Replaces the context of the current thread with the specified nextContext.
199      * Depending on the specified value of leaveOldContext, the connection in the
200      * previous context is released.
201      *
202      * @param nextContext   this context replaces the previous context of the specified thread.
203      * @param leaveOldContext   indicates if the connection in the previous context is released.
204      * @throws SQLException
205      */
206      /*
207     private static void enterContext( Object nextContext, boolean leaveOldContext )
208         throws SQLException
209     {
210         enterContext( Thread.currentThread(), nextContext, leaveOldContext );
211     }
212 */
213     /**
214      * Closes all opened connections in the <code>TKDBConnectionManager</code> assigned to
215      * the current thread.
216     */
217     protected static void resetContext()
218     {
219         getManager().resetConnections();
220     }
221 
222     /**
223      * Deregisters the current thread from this <code>TKDBManager</code>.
224      * The specified value of doClose indicates, if all the connections contained
225      * in the <code>TKDBConnectionManager</code> assigned to the current thread are
226      * closed or only released.
227      *
228      * @param doClose   if <code>true</code> close connections of the current thread
229      *                  else only release them for other threads.
230      * @throws SLQException  normaler SQL Fehler
231      */
232     public static synchronized void deregister( boolean doClose ) throws SQLException
233     {
234         
235 //          Thread currThread = Thread.currentThread();
236 
237 //          threadManager.remove( currThread );
238 //          TKHashtable contexts = (TKHashtable)threadContexts.remove( currThread );
239 //          if( contexts == null ) return;
240 
241 //          Enumeration e = contexts.elements();
242 //          if( doClose ) {
243 //              while( e.hasMoreElements() ) {
244 //                  ((TKDBConnectionManager)e.nextElement()).closeConnection();
245 //              }
246 //          }
247 //          else {
248 //              while( e.hasMoreElements() ) {
249 //                  ((TKDBConnectionManager)e.nextElement()).freeConnection();
250 //              }
251 //          }
252         TKDBConnectionManager.getInstance().freeConnection();
253     }
254 
255     /**
256      * Returns the <code>TKDBConnectionManager</code> assigned to the actual context of the current thread.
257      * @return the connection manager of the current thread.
258     */
259     public static TKDBConnectionManager getManager()
260     {
261 //          Thread currThread = Thread.currentThread();
262 //          TKDBConnectionManager currManager = (TKDBConnectionManager)threadManager.get( currThread );
263 //          if( currManager == null ) {
264 //              currManager = ensureManager( currThread, DEFAULT_CONTEXT );
265 //          }
266 //          return currManager;
267         return TKDBConnectionManager.getInstance();
268     }
269 
270     /**
271      * Returns the connection of the current thread in the actual context
272      * @throws SQLException
273      */
274     public static Connection getConnection() throws SQLException
275     {
276         return getManager().getConnection();
277     }
278 
279 
280     /**
281       * Using the methods <code>beginTransaction</code>, <code>commitTransaction</code>
282       * and <code>rollbackTransaction</code>, it is possible to encapsulate several queries
283       * in one transaction.
284       * <br>
285       * Usage:
286       * <br>
287       * <pre>
288       * TKDBManager.beginTransaction();
289       * try{
290       *     q_1.execute();
291       *     q_1.close();
292       *     .
293       *     .
294       *     .
295       *     q_n.execute();
296       *     q_n.close();
297       *     commitTransaction();
298       * }
299       * catch(Throwable e){
300       *     TKDBManager.rollbackTransaction();
301       * }
302       * </pre>
303       * <br>
304       * It is important to call <code>close</code> for each <code>TKQuery</code>,
305       * because only then the statement will be completed and SQLExceptions will be thrown.
306       * <br>
307       * As well important is to catch <code>Throwable</code>, because <code>close</close> may
308       * throw a <code>SQLError</code>!
309       * <br>
310       *
311       * For details see method {@link #executeAsTran(TKQuery [] queryArray) executeAsTran}
312      * @throws SQLException
313       */
314     public static void beginTransaction() throws SQLException
315     { 
316         getManager().beginTransaction();
317     }
318 
319     /**
320      * Commits a transaction begun in the <code>TKDBConnection</code>
321      * in the actual context of the current thread
322      * <i>(connection is retrieved over <code>TKDBConnectionManager</code>)</i>
323      * @throws SQLException
324      */
325     public static void commitTransaction() throws SQLException
326     { 
327         getManager().commitTransaction();
328     }
329 
330     /**
331      * Rollbacks a transaction begun in the <code>TKDBConnection</code>
332      * in the actual context of the current thread
333      * <i>(connection is retrieved over <code>TKDBConnectionManager</code>)</i>
334      */
335     public static void rollbackTransaction() throws SQLException
336     { 
337         getManager().rollbackTransaction();
338     }
339 
340     /**
341      * Rollbacks a transaction begun in the <code>TKDBConnection</code>
342      * in the actual context of the current thread
343      * <i>(connection is retrieved over <code>TKDBConnectionManager</code>)</i>.
344      * <br>
345      * Is called by {@link executeAsTran(TKQuery [] queryArray) executeAsTran}
346      * in the catch-clause and analyzes the specified <code>Throwable</code>.
347      * Throws a <code>TKSQLError</code>, which encapsulates a <code>SQLException</code>.
348      * @param t Ursprungsexception
349      */
350     public static void safeRollbackTransaction(Throwable   t)
351     {
352         try{
353             CAT.error("Rollback Reason: ", t);
354             rollbackTransaction();
355 
356         }
357         catch(SQLException e){
358             CAT.debug("SQLException during rollback", e);
359         }
360 
361         if (t instanceof SQLException)
362         {
363             throw new TKSQLError("Rollback: " + t.getMessage(), (SQLException) t);
364         }
365 
366         if (t instanceof TKSQLError)
367         {
368             throw new TKSQLError("Rollback: " + t.getMessage(), ((TKSQLError) t).getSQLException());
369         }
370 
371         throw new TKSQLError("Rollback: " + t.getMessage());
372     }
373 
374 
375     /**
376      * Closes all queries within the connection of the actual context,
377      * not implementing the interface <code>SensitiveQuery</code>
378      * by calling the queries&acute; <code>close</code> method.
379      * @throws SQLException
380      */
381     public static void closeNonsensitiveQueries() throws SQLException
382     { 
383         getManager().closeNonsensitiveQueries();
384     }
385 
386 
387 
388     /**
389       * Executes the queries in the specified queryArray within one transaction.
390       * If one <code>TKQuery</code> throws an exception, all
391       * queries are rollbacked.
392       * <br>
393       * This method should be used, if the returned resultsets are not needed.
394       * @param queryArray   Array of TKQuery, to be executed within a transaction
395       */
396     public static void executeAsTran(TKQuery [] queryArray) {
397         try{
398             beginTransaction();
399             int i;
400             for(i = 0; i < queryArray.length; i++){
401                 queryArray[i].execute();
402                 queryArray[i].close();
403             }
404             commitTransaction();
405         }
406         catch( Throwable   t){
407             safeRollbackTransaction(t);
408         }
409     }
410 
411     //***************************************************************************
412     /**
413         Erzeugt ein neues Query-Objekt im aktuellen Kontext des laufenden Threads.
414         Die Query-Klasse wird im uebergebenen Java-Package gesucht.
415     */
416     /*
417     public static TKQuery newQuery( String queryId, String basePackage )
418         throws SQLException
419         {return getManager()._newQuery( queryId, basePackage );}
420     */
421     /**
422         Erzeugt ein neues Query-Objekt im aktuellen Kontext des laufenden Threads.
423         Die Query-Klasse wird im default-Base-Package gesucht.
424     */
425     /*
426     public static TKQuery newQuery( String queryId ) throws SQLException
427         {return getManager()._newQuery( queryId );}
428     */
429     /**
430         Erzeugt ein neues Query-Objekt im aktuellen Kontext des laufenden Threads.
431         Die Query-Klasse wird �bergeben oder anhand der uebergebenen Objektes gesucht.
432     */
433     /*
434     public static TKQuery newQuery( TKPackageInformer query ) throws SQLException
435          { return getManager()._newQuery( query ); }
436     */
437     //***************************************************************************
438 
439     /**
440       * Returns an instance of the specified queryClass registered in the
441       * <code>TKDBConnectionManager</code> responsible for the actual context
442       * of the current thread.
443       *
444       * @param queryClass   the class to instantiate a new <code>TKQuery</code>
445       * @see TKQuery
446       * @see TKDBConnectionManager
447       * @see TKDBConnection
448      * @return die erzeugte Query
449     */
450     public static TKQuery newQuery( Class   queryClass ) throws SQLException
451     {
452         return getManager().newQuery( queryClass );
453     }
454 
455     /**
456         Setzt das Default-Java-Package in dem nach Query-Klassen fuer den
457         aktuellen Kontext des laufenden Threads gesucht wird
458     */
459     /*
460     public static void setBasePackage( String basePackage )
461         {getManager()._setBasePackage( basePackage );}
462     */
463 
464     /**
465       * Sets all values within the <code>TKDBConnectionManager</code> responsible
466       * for the context of the current thread, necessary to connect to database.
467       * @param dbId     a string which determines the vendor of the used database
468       * @param serverId the connect string
469       * @param prop     properties of the used database connection
470       *                 (database, user_name, password, server, ...)
471       */
472     public static void prepareConnection(Properties   prop )
473         throws SQLException
474     {
475         getManager().prepareConnection( prop );
476     }
477 
478     /**
479       * Closes the connection of the current thread.
480       */
481     public static void closeConnection() throws SQLException
482     {
483         getManager().closeConnection();
484     }
485 
486     /**
487       * Releases the connection of the current thread, so it can be used later.
488       */
489     public static void freeConnection() throws SQLException
490     {
491         getManager().freeConnection();
492     }
493 
494     /**
495       * Limits the number of opened connections of the current thread to
496       * the specified value of count.
497       */
498     public static void limitConnections( int count )
499     {
500         getManager().limitConnections( count );
501     }
502         
503     /**
504     * Liefert den aktuellen Kontext des Threads
505     */
506 //      private static Object getCurrentContext() 
507 //      {
508         //return currentContext.get( Thread.currentThread() );
509 //          return TKDBConnectionManager.getInstance();
510 //      }
511     /**
512       * Returns the vendor of database out of the connect data within
513       * the  <code>TKDBConnectionManager</code> responsible for the actual context
514       * of the current thread.
515       */
516     public static int getDBVendor()
517     {
518         TKConnectData connectData = getManager().getConnectionData();
519         
520         if(connectData == null){
521             return QueryConstants.DONTKNOW;
522         }       
523         if(connectData instanceof TKOracleConnectData){
524             return QueryConstants.ORACLE;
525         }
526         if(connectData instanceof TKSybaseConnectData){
527             return QueryConstants.SYBASE;
528         }
529         if(connectData instanceof TKPostgreSQLConnectData){
530             return QueryConstants.POSTGRESQL;
531         }
532         else{
533             return QueryConstants.DONTKNOW;
534         }
535         
536     }
537 
538 
539 }
540 
541
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags