View Javadoc

1   ////////////////////////////////////////////////////////////////////////////////
2   //CabaWeb
3   //Copyright (C) 2004  Thomas Vogt <Thomas.Vogt@TVC-Software.com>
4   //
5   //This library is free software; you can redistribute it and/or
6   //modify it under the terms of the GNU Lesser General Public
7   //License as published by the Free Software Foundation; either
8   //version 2.1 of the License, or (at your option) any later version.
9   //
10  //This library is distributed in the hope that it will be useful,
11  //but WITHOUT ANY WARRANTY; without even the implied warranty of
12  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  //Lesser General Public License for more details.
14  //
15  //You should have received a copy of the GNU Lesser General Public
16  //License along with this library; if not, write to the Free Software
17  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ////////////////////////////////////////////////////////////////////////////////
19  
20  package org.fhw.cabaweb.ojb.abstracts;
21  
22  import java.util.ArrayList;
23  import java.util.Arrays;
24  import java.util.Collection;
25  import java.util.Iterator;
26  import java.util.List;
27  
28  import org.apache.ojb.broker.PersistenceBroker;
29  import org.apache.ojb.broker.PersistenceBrokerException;
30  import org.apache.ojb.broker.TransactionAbortedException;
31  import org.apache.ojb.broker.TransactionInProgressException;
32  import org.apache.ojb.broker.TransactionNotInProgressException;
33  import org.apache.ojb.broker.metadata.FieldHelper;
34  import org.apache.ojb.broker.query.Criteria;
35  import org.apache.ojb.broker.query.Query;
36  import org.apache.ojb.broker.query.QueryByCriteria;
37  import org.apache.ojb.broker.query.QueryByIdentity;
38  import org.apache.ojb.broker.util.ObjectModificationDefaultImpl;
39  
40  import org.apache.commons.logging.Log;
41  import org.apache.commons.logging.LogFactory;
42  
43  import org.fhw.cabaweb.ojb.interfaces.UseCase;
44  
45  /***
46   * Abstrakte Klasse f&uuml;r die OJB Kapselung der Datenbankoperationen
47   *
48   * @author  <a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
49   * @version Version 1.0 12.04.-22.07.2004
50   */
51  public abstract class AbstractUseCase implements UseCase
52  {
53      /*** Instanz des Persistenzbrokers */
54      private PersistenceBroker broker;
55  
56      /***
57       * The <code>Log</code> instance for this application.
58       */
59      protected Log log = LogFactory.getLog("org.fhw.cabaweb.ojb.abstracts.AbstractUseCase");
60  
61      /***
62       * AbstractUseCase Konstruktor.
63       *
64       * @param   broker Der Persistenzbroker
65       */
66      public AbstractUseCase(PersistenceBroker broker)
67      {
68          this.broker = broker;
69      }
70  
71      /***
72       * Methode zum Umsetzen der gelieferten Strings in ein OJB Objekt
73       * und erzeugen des Persistenzobjektes
74       *
75       * @param   arg Das Objekt das persistent werden soll
76       * @return  Gibt true zurueck wenn der Vorgang erfolgreich abgeschlossen wurde, sonst false.
77       */
78      public abstract boolean erzeugen(Object arg);
79  
80      /***
81       * Methode zum Umsetzen der gelieferten Strings in ein OJB Objekt
82       * und editieren des bereits bestehenden Persistenzobjektes, dass
83       * Anhand seines Promary Keys indentifiziert wird
84       *
85       * @param   arg Das Objekt das editiert werden soll
86       * @return  Gibt true zurueck wenn der Vorgang erfolgreich abgeschlossen wurde, sonst false.
87       */
88      public abstract boolean editieren(Object arg);
89  
90      /***
91       * Methode zum loeschen eines OJB Objekts
92       *
93       * @param   arg Das Objekt das gelöscht werden soll
94       * @return  Gibt true zurueck wenn der Vorgang erfolgreich abgeschlossen wurde, sonst false.
95       */
96      public abstract boolean loeschen(Object arg);
97  
98      /***
99       * Methode zum suchen eines OJB Objekts nach PrimaryKey
100      *
101      * @param   arg Das Objekt mit den PrimaryKeys nach denen gesucht werden soll
102      * @return  Object mit dem Inhalt des gesuchten Objekts
103      */
104     public abstract Object sucheObjekt(Object arg);
105 
106     /***
107      * Methode zum suchen mehrerer OJB Objekte
108      *
109      * @param   arg Das Objekt mit den Argumenten nach denen gesucht werden soll
110      * @return  Collection mit den gefundenen Objekten
111      */
112     public abstract Collection sucheObjekte(Object arg);
113 
114     /***
115      * Methode zur Suche aller Persistenzobjekte einer Klasse
116      *
117      * @param   suche Die Klasse deren Objekte gesucht werden sollen
118      * @return  Collection mit allen Persistenzobjekten der Klasse
119      */
120     public Collection sucheAlle(Class suche)
121     {
122         Collection rueckgabeWert = null;
123 
124         // Wir haben keine Referenz zum gesuchten Objekt,
125         // also müssen wir erst nach dem Objekt suchen,
126         // das machen wirt durch Query By Example (QBE):
127         // 1. Das Objekt mit den übereinstimmenden PrimaryKey Werten wird übergeben:
128         // 2. Erzeugen einer QueryByIdentity von dieser Beispielinstanz:
129         Query query = new QueryByCriteria(suche, null);
130         try
131         {
132             /*
133             if (log.isDebugEnabled())
134             {
135                 log.debug(" Clearing the Cache");
136             }
137             clearCache();
138             */
139             if (log.isDebugEnabled())
140             {
141                 log.debug(" Starting Transaction SucheAlle");
142             }
143             // 3. Start der Transaktion
144             beginTransaction();
145 
146             if (log.isDebugEnabled())
147             {
148                 log.debug(" Making get Collection By Query : " + query);
149             }
150             // 4. Den Broker anweisen alle Objekte der gesuchten Klasse zu holen
151             //    und als Collection zurückzugeben
152             rueckgabeWert = this.broker.getCollectionByQuery(query);
153 
154             if (log.isDebugEnabled())
155             {
156                 log.debug(" End Transaction SucheAlle");
157             }
158             // 5. Beenden der Transaktion
159             endTransaction();
160         }
161         catch (TransactionInProgressException ex)
162         {
163             // Im Fall das etwas Schief läuft - Rollback
164             this.broker.abortTransaction();
165             // Loggen der Fehlerdaten in das Log Objekt
166             log.fatal(" Error on trying to store a new Object - Transaction In Progress");
167             log.fatal(ex.getMessage(), ex);
168         }
169         catch (TransactionAbortedException ex)
170         {
171             // Im Fall das etwas Schief läuft - Rollback
172             this.broker.abortTransaction();
173             // Loggen der Fehlerdaten in das Log Objekt
174             log.fatal(" Error on trying to store a new Object - Transaction Aborted");
175             log.fatal(ex.getMessage(), ex);
176         }
177         catch (TransactionNotInProgressException ex)
178         {
179             // Im Fall das etwas Schief läuft - Rollback
180             this.broker.abortTransaction();
181             // Loggen der Fehlerdaten in das Log Objekt
182             log.fatal(" Error on trying to store a new Object - Transaction Not In Progress");
183             log.fatal(ex.getMessage(), ex);
184         }
185         catch (PersistenceBrokerException ex)
186         {
187             String result = new String();
188             List traceElements = Arrays.asList(ex.getStackTrace());
189             Iterator traceElementsIter = traceElements.iterator();
190 
191             while (traceElementsIter.hasNext())
192             {
193                 result += traceElementsIter.next().toString();
194                 result += "\n";
195             }
196 
197             // Im Fall das etwas Schief läuft - Rollback
198             this.broker.abortTransaction();
199             // Loggen der Fehlerdaten in das Log Objekt
200             log.fatal(" Error on trying to do Collection By Query - Persistence Broker Exception");
201             log.fatal(ex.getMessage(), ex);
202             log.fatal(result.toString());
203 
204         }
205         catch (Exception ex)
206         {
207             // Im Fall das etwas Schief läuft - Rollback
208             this.broker.abortTransaction();
209             // Loggen der Fehlerdaten in das Log Objekt
210             log.fatal(" Error on trying to do Collection By Query");
211             log.fatal(ex.getMessage(), ex);
212         }
213 
214         return rueckgabeWert;
215     }
216 
217     /***
218      * Methode zur Erzeugung von Persistenzobjekten
219      *
220      * @param   neuesObjekt Das zu erstellende Objekt
221      */
222     protected final boolean anlegen(Object neuesObjekt)
223     {
224         boolean retval = true;
225 
226         // Abarbeitung der Persistenzoperationen
227         try
228         {
229             if (log.isDebugEnabled())
230             {
231                 log.debug(" Starting Transaction anlegen");
232             }
233             // 1. Begin der Transaktion
234             beginTransaction();
235 
236             if (log.isDebugEnabled())
237             {
238                 log.debug(" Storing Object : " + neuesObjekt);
239             }
240             // 2. Erzeugen des neuen Persistenzobjekts ---
241             this.broker.store(neuesObjekt, new ObjectModificationDefaultImpl(true, false));
242 
243             if (log.isDebugEnabled())
244             {
245                 log.debug(" Commiting Transaction");
246             }
247             // 3. Comitten des neuen Persistenzobjekts
248             endTransaction();
249         }
250         catch (TransactionInProgressException ex)
251         {
252             // Im Fall das etwas Schief läuft - Rollback
253             this.broker.abortTransaction();
254             // Loggen der Fehlerdaten in das Log Objekt
255             log.fatal(" Error on trying to store a new Object - Transaction In Progress");
256             log.fatal(ex.getMessage(), ex);
257 
258             retval = false;
259         }
260         catch (TransactionAbortedException ex)
261         {
262             // Im Fall das etwas Schief läuft - Rollback
263             this.broker.abortTransaction();
264             // Loggen der Fehlerdaten in das Log Objekt
265             log.fatal(" Error on trying to store a new Object - Transaction Aborted");
266             log.fatal(ex.getMessage(), ex);
267 
268             retval = false;
269         }
270         catch (TransactionNotInProgressException ex)
271         {
272             // Im Fall das etwas Schief läuft - Rollback
273             this.broker.abortTransaction();
274             // Loggen der Fehlerdaten in das Log Objekt
275             log.fatal(" Error on trying to store a new Object - Transaction Not In Progress");
276             log.fatal(ex.getMessage(), ex);
277 
278             retval = false;
279         }
280         catch (PersistenceBrokerException ex)
281         {
282             // Im Fall das etwas Schief läuft - Rollback
283             this.broker.abortTransaction();
284             // Loggen der Fehlerdaten in das Log Objekt
285             log.fatal(" Error on trying to store a new Object");
286             log.fatal(ex.getMessage(), ex);
287 
288             retval = false;
289         }
290         catch (Exception ex)
291         {
292             // Im Fall das etwas Schief läuft - Rollback
293             this.broker.abortTransaction();
294             // Loggen der Fehlerdaten in das Log Objekt
295             log.fatal(" Error on trying to do Collection By Query");
296             log.fatal(ex.getMessage(), ex);
297 
298             retval = false;
299         }
300 
301         return retval;
302     }
303 
304     /***
305      * Methode zur Suche nach allen den Query Paramtern QBC (Query By Criteria)
306      * entsprechenden Persistenzobjekte einer Klasse
307      *
308      * @param   klasse Die Klasse für die gesucht werden soll
309      * @param   criteria Die Kriterien nach denen die Objekte gesucht werden sollen
310      * @param   orderBy ArrayListe mit den FieldHelper Objekten, nach denen sortiert werden sollen
311      * @return  Collection mit den entsprechenden Persistenzobjekten der Klasse
312      */
313     public final Collection sucheQBC(Class klasse, Criteria criteria, ArrayList orderBy)
314     {
315         Collection rueckgabeWert = null;
316 
317         // Wir haben keine Referenz zum gesuchten Objekt,
318         // also müssen wir erst nach dem Objekt suchen,
319         // das machen wir durch Query:
320         // 1. Erzeugen der Query
321         QueryByCriteria query = new QueryByCriteria(klasse, criteria);
322 
323         // 1A. Einfügen der OrderBy Statements
324         if (orderBy != null)
325         {
326             for (int i = 0; i < orderBy.size(); i++)
327             {
328                 query.addOrderBy((FieldHelper) orderBy.get(i));
329             }
330         }
331 
332         try
333         {
334             if (log.isDebugEnabled())
335             {
336                 log.debug(" Starting Transaction Suche Query By Criteria");
337             }
338             // 2. Start der Transaktion
339             beginTransaction();
340 
341             if (log.isDebugEnabled())
342             {
343                 log.debug(" Making get Collection By Query : " + query);
344             }
345             // 3. Den Broker anweisen alle Objekte der gesuchten Klasse zu holen
346             //    und als Collection zurückzugeben
347             rueckgabeWert = this.broker.getCollectionByQuery(query);
348 
349             if (log.isDebugEnabled())
350             {
351                 log.debug(" End Transaction Suche Query By Criteria");
352             }
353             // 4. Beenden der Transaktion
354             endTransaction();
355         }
356         catch (TransactionInProgressException ex)
357         {
358             // Im Fall das etwas Schief läuft - Rollback
359             this.broker.abortTransaction();
360             // Loggen der Fehlerdaten in das Log Objekt
361             log.fatal(" Error on trying to do Collection By Query - Transaction In Progress");
362             log.fatal(ex.getMessage(), ex);
363         }
364         catch (TransactionAbortedException ex)
365         {
366             // Im Fall das etwas Schief läuft - Rollback
367             this.broker.abortTransaction();
368             // Loggen der Fehlerdaten in das Log Objekt
369             log.fatal(" Error on trying to do Collection By Query - Transaction Aborted");
370             log.fatal(ex.getMessage(), ex);
371         }
372         catch (TransactionNotInProgressException ex)
373         {
374             // Im Fall das etwas Schief läuft - Rollback
375             this.broker.abortTransaction();
376             // Loggen der Fehlerdaten in das Log Objekt
377             log.fatal(" Error on trying to do Collection By Query - Transaction Not In Progress");
378             log.fatal(ex.getMessage(), ex);
379         }
380         catch (PersistenceBrokerException ex)
381         {
382             // Im Fall das etwas Schief läuft - Rollback
383             this.broker.abortTransaction();
384             // Loggen der Fehlerdaten in das Log Objekt
385             log.fatal(" Error on trying to do Collection By Query");
386             log.fatal(ex.getMessage(), ex);
387         }
388         catch (Exception ex)
389         {
390             // Im Fall das etwas Schief läuft - Rollback
391             this.broker.abortTransaction();
392             // Loggen der Fehlerdaten in das Log Objekt
393             log.fatal(" Error on trying to do Collection By Query");
394             log.fatal(ex.getMessage(), ex);
395         }
396 
397         return rueckgabeWert;
398     }
399 
400     /***
401      * Methode zur Suche von Persistenzobjekten anhand eines Beispielobjekts
402      *
403      * @param   suchObjekt Das Beispielobjekt anhand dem gesucht werden soll
404      * @return  Das anhand der Suchparameter gefundene Objekt
405      */
406     protected final Object sucheQBE(Object suchObjekt)
407     {
408         Object rueckgabeWert = null;
409 
410         // Wir haben keine Referenz zum gesuchten Objekt,
411         // also müssen wir erst nach dem Objekt suchen,
412         // das machen wirt durch Query By Example (QBE):
413         // 1. Das Objekt mit den übereinstimmenden PrimaryKey Werten wird übergeben:
414         // 2. Erzeugen einer QueryByIdentity von dieser Beispielinstanz:
415         Query query = new QueryByIdentity(suchObjekt);
416         try
417         {
418             if (log.isDebugEnabled())
419             {
420                 log.debug(" Getting Object By Query");
421             }
422 
423             // 3. Suche nach dem durch die QBE specifizierten Objekt
424             rueckgabeWert = this.broker.getObjectByQuery(query);
425         }
426         catch (TransactionInProgressException ex)
427         {
428             // Im Fall das etwas Schief läuft - Rollback
429             this.broker.abortTransaction();
430             // Loggen der Fehlerdaten in das Log Objekt
431             log.fatal(" Error on trying to do Object By Query - Transaction In Progress");
432             log.fatal(ex.getMessage(), ex);
433         }
434         catch (TransactionAbortedException ex)
435         {
436             // Im Fall das etwas Schief läuft - Rollback
437             this.broker.abortTransaction();
438             // Loggen der Fehlerdaten in das Log Objekt
439             log.fatal(" Error on trying to do Object By Query - Transaction Aborted");
440             log.fatal(ex.getMessage(), ex);
441         }
442         catch (TransactionNotInProgressException ex)
443         {
444             // Im Fall das etwas Schief läuft - Rollback
445             this.broker.abortTransaction();
446             // Loggen der Fehlerdaten in das Log Objekt
447             log.fatal(" Error on trying to do Object By Query - Transaction Not In Progress");
448             log.fatal(ex.getMessage(), ex);
449         }
450         catch (PersistenceBrokerException ex)
451         {
452             // Im Fall das etwas Schief läuft - Rollback
453             this.broker.abortTransaction();
454             // Loggen der Fehlerdaten in das Log Objekt
455             log.fatal(" Error on trying to do Object By Query");
456             log.fatal(ex.getMessage(), ex);
457         }
458         catch (Exception ex)
459         {
460             // Im Fall das etwas Schief läuft - Rollback
461             this.broker.abortTransaction();
462             // Loggen der Fehlerdaten in das Log Objekt
463             log.fatal(" Error on trying to do Collection By Query");
464             log.fatal(ex.getMessage(), ex);
465         }
466 
467         return rueckgabeWert;
468     }
469 
470     /***
471      * Methode zum Starten einer Transaktion
472      */
473     protected final boolean beginTransaction()
474     {
475         boolean retval = true;
476 
477         try
478         {
479             if (log.isDebugEnabled())
480             {
481                 log.debug(" Starting Transaction");
482             }
483 
484             // Start der Broker Transaktion
485             this.broker.beginTransaction();
486         }
487         catch (TransactionInProgressException ex)
488         {
489             // Im Fall das etwas Schief läuft - Rollback
490             this.broker.abortTransaction();
491             // Loggen der Fehlerdaten in das Log Objekt
492             log.fatal(" Error on trying to begin transaction - Transaction In Progress");
493             log.fatal(ex.getMessage(), ex);
494 
495             retval = false;
496         }
497         catch (TransactionAbortedException ex)
498         {
499             // Im Fall das etwas Schief läuft - Rollback
500             this.broker.abortTransaction();
501             // Loggen der Fehlerdaten in das Log Objekt
502             log.fatal(" Error on trying to begin transaction - Transaction Aborted");
503             log.fatal(ex.getMessage(), ex);
504 
505             retval = false;
506         }
507         catch (TransactionNotInProgressException ex)
508         {
509             // Im Fall das etwas Schief läuft - Rollback
510             this.broker.abortTransaction();
511             // Loggen der Fehlerdaten in das Log Objekt
512             log.fatal(" Error on trying to begin transaction - Transaction Not In Progress");
513             log.fatal(ex.getMessage(), ex);
514 
515             retval = false;
516         }
517         catch (PersistenceBrokerException ex)
518         {
519             // Im Fall das etwas Schief läuft - Rollback
520             this.broker.abortTransaction();
521             // Loggen der Fehlerdaten in das Log Objekt
522             log.fatal(" Error on trying to begin transaction");
523             log.fatal(ex.getMessage(), ex);
524 
525             retval = false;
526         }
527         catch (Exception ex)
528         {
529             // Im Fall das etwas Schief läuft - Rollback
530             this.broker.abortTransaction();
531             // Loggen der Fehlerdaten in das Log Objekt
532             log.fatal(" Error on trying to do Collection By Query");
533             log.fatal(ex.getMessage(), ex);
534 
535             retval = false;
536         }
537 
538         return retval;
539     }
540 
541     /***
542      * Methode zum Beenden der Transaktion
543      */
544     protected final boolean endTransaction()
545     {
546         boolean retval = true;
547 
548         try
549         {
550             if (log.isDebugEnabled())
551             {
552                 log.debug(" Commiting Transaction");
553             }
554 
555             // Commiten der Broker Transaktion
556             this.broker.commitTransaction();
557         }
558         catch (TransactionInProgressException ex)
559         {
560             // Im Fall das etwas Schief läuft - Rollback
561             this.broker.abortTransaction();
562             // Loggen der Fehlerdaten in das Log Objekt
563             log.fatal(" Error on trying to commit transaction - Transaction In Progress");
564             log.fatal(ex.getMessage(), ex);
565 
566             retval = false;
567         }
568         catch (TransactionAbortedException ex)
569         {
570             // Im Fall das etwas Schief läuft - Rollback
571             this.broker.abortTransaction();
572             // Loggen der Fehlerdaten in das Log Objekt
573             log.fatal(" Error on trying to commit transaction - Transaction Aborted");
574             log.fatal(ex.getMessage(), ex);
575 
576             retval = false;
577         }
578         catch (TransactionNotInProgressException ex)
579         {
580             // Im Fall das etwas Schief läuft - Rollback
581             this.broker.abortTransaction();
582             // Loggen der Fehlerdaten in das Log Objekt
583             log.fatal(" Error on trying to commit transaction - Transaction Not In Progress");
584             log.fatal(ex.getMessage(), ex);
585 
586             retval = false;
587         }
588         catch (PersistenceBrokerException ex)
589         {
590             // Im Fall das etwas Schief läuft - Rollback
591             this.broker.abortTransaction();
592             // Loggen der Fehlerdaten in das Log Objekt
593             log.fatal(" Error on trying to commit transaction");
594             log.fatal(ex.getMessage(), ex);
595 
596             retval = false;
597         }
598         catch (Exception ex)
599         {
600             // Im Fall das etwas Schief läuft - Rollback
601             this.broker.abortTransaction();
602             // Loggen der Fehlerdaten in das Log Objekt
603             log.fatal(" Error on trying to do Collection By Query");
604             log.fatal(ex.getMessage(), ex);
605 
606             retval = false;
607         }
608 
609         return retval;
610     }
611 
612     /***
613      * Methode zum Speichern eines editierten Objekts Beenden der Transaktion
614      *
615      * @param   editObjekt Das editierte Objekt das gespeichert werden soll
616      */
617     protected final boolean storeAndEndTransaction(Object editObjekt)
618     {
619         boolean retval = true;
620 
621         try
622         {
623             if (log.isDebugEnabled())
624             {
625                 log.debug(" Storing Object : " + editObjekt);
626             }
627 
628             // 1. Broker um Speicherung des editierten Persistenzobjekts bitten
629             this.broker.store(editObjekt);
630 
631             if (log.isDebugEnabled())
632             {
633                 log.debug(" Commiting Transaction");
634             }
635 
636             // 2. Commiten der Broker Transaktion
637             this.broker.commitTransaction();
638         }
639         catch (TransactionInProgressException ex)
640         {
641             // Im Fall das etwas Schief läuft - Rollback
642             this.broker.abortTransaction();
643             // Loggen der Fehlerdaten in das Log Objekt
644             log.fatal(" Error on trying to store object and commit transaction - Transaction In Progress");
645             log.fatal(ex.getMessage(), ex);
646 
647             retval = false;
648         }
649         catch (TransactionAbortedException ex)
650         {
651             // Im Fall das etwas Schief läuft - Rollback
652             this.broker.abortTransaction();
653             // Loggen der Fehlerdaten in das Log Objekt
654             log.fatal(" Error on trying to store object and commit transaction - Transaction Aborted");
655             log.fatal(ex.getMessage(), ex);
656 
657             retval = false;
658         }
659         catch (TransactionNotInProgressException ex)
660         {
661             // Im Fall das etwas Schief läuft - Rollback
662             this.broker.abortTransaction();
663             // Loggen der Fehlerdaten in das Log Objekt
664             log.fatal(" Error on trying to store object and commit transaction - Transaction Not In Progress");
665             log.fatal(ex.getMessage(), ex);
666 
667             retval = false;
668         }
669         catch (PersistenceBrokerException ex)
670         {
671             // Im Fall das etwas Schief läuft - Rollback
672             this.broker.abortTransaction();
673             // Loggen der Fehlerdaten in das Log Objekt
674             log.fatal(" Error on trying to store object and commit transaction");
675             log.fatal(ex.getMessage(), ex);
676 
677             retval = false;
678         }
679         catch (Exception ex)
680         {
681             // Im Fall das etwas Schief läuft - Rollback
682             this.broker.abortTransaction();
683             // Loggen der Fehlerdaten in das Log Objekt
684             log.fatal(" Error on trying to do Collection By Query");
685             log.fatal(ex.getMessage(), ex);
686 
687             retval = false;
688         }
689 
690         return retval;
691     }
692 
693     /***
694      * Methode zum Löschen eines Objekts Beenden der Transaktion
695      *
696      * @param   loeschObjekt Das Objekt das gelöscht werden soll
697      */
698     protected final boolean deleteAndEndTransaction(Object loeschObjekt)
699     {
700         boolean retval = true;
701 
702         try
703         {
704             if (log.isDebugEnabled())
705             {
706                 log.debug(" Deleting Object : " + loeschObjekt);
707             }
708 
709             // 1. Broker um Löschung des Persistenzobjekts bitten
710             this.broker.delete(loeschObjekt);
711 
712             if (log.isDebugEnabled())
713             {
714                 log.debug(" Commiting Transaction");
715             }
716 
717             // 2. Commiten der Broker Transaktion
718             this.broker.commitTransaction();
719         }
720         catch (TransactionInProgressException ex)
721         {
722             // Im Fall das etwas Schief läuft - Rollback
723             this.broker.abortTransaction();
724             // Loggen der Fehlerdaten in das Log Objekt
725             log.fatal(" Error on trying to delete object and commit transaction - Transaction In Progress");
726             log.fatal(ex.getMessage(), ex);
727 
728             retval = false;
729         }
730         catch (TransactionAbortedException ex)
731         {
732             // Im Fall das etwas Schief läuft - Rollback
733             this.broker.abortTransaction();
734             // Loggen der Fehlerdaten in das Log Objekt
735             log.fatal(" Error on trying to delete object and commit transaction - Transaction Aborted");
736             log.fatal(ex.getMessage(), ex);
737 
738             retval = false;
739         }
740         catch (TransactionNotInProgressException ex)
741         {
742             // Im Fall das etwas Schief läuft - Rollback
743             this.broker.abortTransaction();
744             // Loggen der Fehlerdaten in das Log Objekt
745             log.fatal(" Error on trying to delete object and commit transaction - Transaction Not In Progress");
746             log.fatal(ex.getMessage(), ex);
747 
748             retval = false;
749         }
750         catch (PersistenceBrokerException ex)
751         {
752             // Im Fall das etwas Schief läuft - Rollback
753             this.broker.abortTransaction();
754             // Loggen der Fehlerdaten in das Log Objekt
755             log.fatal(" Error on trying to delete object and commit transaction");
756             log.fatal(ex.getMessage(), ex);
757 
758             retval = false;
759         }
760         catch (Exception ex)
761         {
762             // Im Fall das etwas Schief läuft - Rollback
763             this.broker.abortTransaction();
764             // Loggen der Fehlerdaten in das Log Objekt
765             log.fatal(" Error on trying to do Collection By Query");
766             log.fatal(ex.getMessage(), ex);
767 
768             retval = false;
769         }
770 
771         return retval;
772     }
773 
774     /***
775      * Methode zum Aufräumen des Transaktionscaches
776      *
777      * @return  Wurde der Cache aufgeräumt ??
778      */
779     public final boolean clearCache()
780     {
781         boolean retval = true;
782 
783 		try
784 		{
785 			if (log.isDebugEnabled())
786 			{
787 			    log.debug(" Clearing Cache");
788 			}
789 			
790 			// Clear Cache der Broker Transaktion
791 			this.broker.clearCache();
792 		}
793         catch (PersistenceBrokerException ex)
794         {
795             // Im Fall das etwas Schief läuft - Rollback
796             this.broker.abortTransaction();
797             // Loggen der Fehlerdaten in das Log Objekt
798             log.fatal(" Error on trying to clear cache");
799             log.fatal(ex.getMessage(), ex);
800 
801             retval = false;
802         }
803         catch (Exception ex)
804         {
805             // Im Fall das etwas Schief läuft - Rollback
806             this.broker.abortTransaction();
807             // Loggen der Fehlerdaten in das Log Objekt
808             log.fatal(" Error on trying to clear cache");
809             log.fatal(ex.getMessage(), ex);
810 
811             retval = false;
812         }
813 
814         return retval;
815     }
816 }