Muster-Code für einen BO_Synchronizer (Klasse für den Datenabgleich zwischen JAS und lokaler Datenbank)

Dieses Dokument enthält das Code-Muster für eine Klasse zum Synchronisieren der Daten zwischen lokaler Datenbank und JAS (Java Application Server).
So ein Datenabgleich ist notwendig wenn das Anwendungsprogramm in der Version 'MobileClient' ausgeführt ist und ein mobiles Gerät (z.B. Netbook) die Daten, die während der verbindungslosen Zeit erfasst wurden, auf die zentrale Datenbank am JAS übertragen muss bzw. die inzwischen auf der zentralen Datenbank erfassten Daten auf die lokale Datenbank übertragen muss.

Inhaltsverzeichnis:

Vorbedingung 

Muster-Code für die BO_Synchronizer Klasse 

Anleitung zur Adaptierung 
* Änderung des Namens der Java-Packages der Anwendung 
* Änderung des Namens der Klasse des CommandCenters 
* Adaptieren des Kommentars 
* Änderung des Namens dier Klasse und der 'Constructor-Methode'' 

Weitere Schritte und verwandte Dokumentation 

Vorbedingung:

• Tutorial für die Programmierung eines Heavyweight-Clients (Fat-Client) durchgearbeitet.

• Client-Side Klasse für das BO erstellt; siehe Muster-Code für ein BOC_Set (Liste mit Business-Objects, Client-Side-Klasse).
  Die Codierung der BOC-SetKlasse kann auch später erfolgen – in diesem Fall treten bei der Implementierung dieser Synchronizer-Klasse Fehler auf.

▲ zum Inhaltsverzeichnis

Muster-Code für die BO_Synchronizer Klasse

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie im Abschnitt
Anleitung zur Adaptierung.

package application_package.boc;
/*
 * Package und Klasse für den Vector mit den zu synchronisierenden BO. */
import java.util.Vector;
/*
 * Package und Basisklasse für Konstanten und Fehler für die BOs. */
import js_base.bo.JSBS_BO;
/*
 * Package und Basisklasse für das Task-Frame. */
import js_base.frame.JSBS_TaskFrame;
/*
 * Klasse für das CommandCenter (Start-Frame) der Anwendung. */
import application_package.client.application_CommandCenter;
/*
 * Packages mit der zugehörigen generellen Klasse des BO. */
import application_package.bo.*;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Klasse für den Datenabgleich zwischen JAS (Java Application Server) und lokaler Datenbank
 *  für Daten der Klasse application_entity_BO.
 *  Dieser Klasse ist notwendig wenn das Anwendungsprogramm auch für die Version 'MobileClient'
 *  implementiert ist und damit die Daten zwischen lokaler Datenbank des mobilen Client-Gerätes
 *  und den Daten auf dem JAS synchronisiert werden müssen.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public class application_entity_BO_Synchronizer extends Thread {
/* ---------------------
 * VARIABLE dieser Klasse.
 * --------------------- */
/* 
 * Referenz auf das Task-Frame, das das Objekt dieser Klasse 'konstruiert' hat.
 * Dieses wird als Parameter benötigt wenn ein BOC (Business-Object, Client-Side-Class)
 * konstruiert wird. */
    private JSBS_TaskFrame frmTF = null;
/* 
 * Referenz auf das CommandCenter (Start-Frame) der Anwendung.
 * Dieses wird als Parameter benötigt wenn ein BOC (Business-Object, Client-Side-Class)
 * konstruiert wird. */
    private application_CommandCenter frmCC = null;
/* 
 * Vector mit den Allgemeinen Attributen (CommonAttributes) der Business-Object, deren Daten zwischen
 * JAS und lokaler Datenbank abgeglichen werden sollen. */
    private Vector<JSBS_BO> vecBO_List_ToProcess = new Vector<JSBS_BO>();
/* ---------------------
 * CONSTRUCTOR-METHODE */
/* ---------------------
 * Als Parameter des 'Constructors' sind das aufrufende Task-Frame und
 * das 'CommandCenter' (Start-Frame) erforderlich. */
    public application_entity_BO_Synchronizer(application_CommandCenter parmfrmCC, JSBS_TaskFrame parmfrmTask) {
/*
 * Die im Parameter übergebenen Referenzen auf Start-Frame und Task-Frame
 * werden in den Variablen dieser Klasse'aufgehoben'. */
      frmCC = parmfrmCC;
      frmTF = parmfrmTask;
    }
/* --------------------- */
/* 
 * METHODE zum Übergeben eines einzelnen BO an diese Klasse und Starten des Abgleichs
 * von dessen Daten auf der lokalen Datenbank mit den Daten auf dem JAS. */
    public void passBO(application_entity_BO parmapplication_entity_BO) {
/*
 * Prüfen, ob die zu bearbeitenden Variablen nicht 'null' sind; sonst diese Methode beenden. */
      if (parmapplication_entity_BO == null) return;
/*
 * Wenn kein Task-Frame im Constructor-Parameter übergeben wurde dann diese Methode beenden.
 * Ein 'fehlendes' Task-Frame kann vorkommen wenn das konstruierende BOC oder BOC-Set aus
 * dem Start-Frame (CommandCenter) aufgerufen wurde. */
      if (frmTF == null) return;
/*
 * Neues BO konstruieren und die Werte des im Parameter übergebenen BO kopieren.
 * Ein neues BO ist deswegen notwendig, weil im Parameter nur die Referenz auf das BO übergeben wird.
 * Weil diese Klasse einen nebenläufigen Prozess enthält kann das BO im übergebenen Parameter schon wieder
 * 'verschwunden' sein wenn es bearbeitet werden soll. */
        JSBS_BO locJSBS_BO = new JSBS_BO();
        locJSBS_BO.copyFromJSBS_BO(parmapplication_entity_BO);
/* 
 * Gerade konstruiertes BO in den Vector der zu synchronisierenden BO einfügen.
 * Der Befehl wird 'synchronized' ausgeführt damit im nebenläufigen Prozess (Methode 'run')
 * nicht gleichzeitig eine Abfrage auf die Anzahl der Elemente im Vector erfolgen kann
 * und dort dann ein falscher Wert und Index verwendet werden würde. */
      synchronized (vecBO_List_ToProcess) {
        vecBO_List_ToProcess.addElement(locJSBS_BO);
      }
/*
 * Prüfen, ob der nebenläufige Prozess bereits gestartet ist und wenn nötig den
 * nebenläufigen Prozess starten. */
      if (! this.isAlive()) this.run();
    }
/* ---------------------------
 * METHODE zum Übergeben einer Liste von BO (BO-Set) an diese Klasse und Starten des Abgleichs
 * von deren Daten auf der lokalen Datenbank mit den Daten auf dem JAS. */
    public void passBOList(application_entity_BO_Set parmapplication_entity_BO_Set) {
/*
 * Prüfen, ob die zu bearbeitenden Variablen nicht 'null' sind; sonst diese Methode beenden. */
      if (parmapplication_entity_BO_Set == null) return;
      if (parmapplication_entity_BO_Set.vecRecordSet == null) return;
/*
 * Wenn kein Task-Frame im Constructor-Parameter übergeben wurde dann diese Methode beenden.
 * Ein 'fehlendes' Task-Frame kann vorkommen wenn das konstruierende BOC oder BOC-Set aus
 * dem Start-Frame (CommandCenter) aufgerufen wurde. */
      if (frmTF == null) return;
/* 
 * Variable für die Anzahl der Elemente im übergebenen Vector definieren, Anzahl ermitteln,
 * Variable für den Index definieren und die einzelnes BO aus dem übergebenen Parameter in der
 * for-Schleife übernehmen. */
      int intVectorSize = parmapplication_entity_BO_Set.vecRecordSet.size();
      int intVectorIndex;
      for (intVectorIndex = 0; intVectorIndex < intVectorSize; intVectorIndex++) {
/*
 * Variable für das BO für die Allgemeinen Attribute (CommonAttributes) definieren und die Werte
 * eines BO aus dem Parameter in den Vector dieser Klasse übernehmen. */
        JSBS_BO locJSBS_BO = new JSBS_BO();
        locJSBS_BO.copyFromJSBS_BO((JSBS_BO) parmapplication_entity_BO_Set.vecRecordSet.elementAt(intVectorIndex));
/* 
 * Das aus dem Parameter heraus gelöste BO in den Vector der zu synchronisierenden BO einfügen.
 * Der Befehl wird 'synchronized' ausgeführt damit im nebenläufigen Prozess (Methode 'run')
 * nicht gleichzeitig eine Abfrage auf die Anzahl der Elemente im Vector erfolgen kann
 * und dort dann ein falscher Wert und Index verwendet werden würde. */
        synchronized (vecBO_List_ToProcess) {
          vecBO_List_ToProcess.addElement(locJSBS_BO);
        }
      }
/*
 * Prüfen, ob der nebenläufige Prozess bereits gestartet ist und wenn nötig den
 * nebenläufigen Prozess starten. */
      if (! this.isAlive()) this.run();
    }
/* ---------------------
 * METHODE mit dem nebenläufigen Prozess.
 * ---------------------
 * In dieser Methode werden alle Elemente aus dem Vector mit den zu synchronisierenden BO
 * (vecBO_List_To_Process) und die Daten der jeweiligen BO zwischen JAS und lokaler Datenbank
 * abgeglichen. */
    public void run() {
/*
 * Die Methode mit diesem Namen muss in einem 'Thread' (nebenläufiger Prozess) unbedingt vorhanden
 * sein und eine 'try/catch'-Logik enthalten. */
      try {
/*
 * In einer endlosen for-Schleife jedes BO im Vector auslesen und abgleichen. */
        int intVectorSize;
        for (;;) {
/* 
 * Aktuelle Anzahl der Elemente im Vector mit den zu synchronisierenden BO ermitteln.
 * Der Befehl wird 'synchronized' ausgeführt damit nicht gleichzeitig ein neues Element
 * eingefügt werden kann und damit eventuell der nebenläufige Prozess nach dem Einfügen
 * nicht gestartet wird. */
          synchronized (vecBO_List_ToProcess) {
            intVectorSize = vecBO_List_ToProcess.size();
          }
/* 
 * Wenn im Vector kein Element mehr vorhanden ist dann wird die for-Schleife beendet -
 * und damit auch die nebenläufige Methode 'run()'.. */
          if (intVectorSize <= 0) break;
/* 
 * Methode aufrufen in der das erste BO im Vector (mit Index 0) synchronisiert wird. */
          synchronizeBO();
        }
      }
      catch (Exception e) {
/*
 * Es ist unwahrscheinlich, dass in einem so einfachen Thread ein Fehler auftritt.
 * Falls doch ein Fehler passiert bleibt dieser unbehandelt weil eine Unterbrechung dieses Thread
 * keine wesentlichen Auswirkungen auf das Anwendungsprogramm hat. */
      }
    }
/* ---------------------
 * METHODE zum Abgleichen der Daten eines BO zwischen JAS und lokaler Datenbank. */
/* ---------------------
 * Das erste Element aus dem Vector (mit Index 0) wird aus dem Vector ausgelesen.
 * Für dieses BO werden alle historischen Datensätze vom JAS und von der lokalen Datenbank gelesen.
 * Wurde das BO auf einer Seite verändert dann werden die Datensätze zwischen JAS und lokaler
 * Datenbank synchronisiert. */
    private void synchronizeBO() {
/*
 * Variable für die Allgemeinen Attribute (Common Attributes) eines BO aus dem Vector. */
      JSBS_BO locBO;
/* 
 * Prüfen ob überhaupt ein Element im Vector vorhanden ist – sonst diese Methode gleich beenden.
 * Anschließend das erste Element im Vector (mit Index 0) auslesen.
 * Die Befehle werden 'synchronized' ausgeführt damit nicht gleichzeitig ein neues Element
 * eingefügt werden kann und damit eventuell die Prüfung, ob der Vector leer ist ein falsches
 * Ergebnis liefert. */
        synchronized (vecBO_List_ToProcess) {
          if (vecBO_List_ToProcess.size() <= 0) return;
          locBO = (JSBS_BO) vecBO_List_ToProcess.elementAt(0);
        }
/*
 * BOC-Variable für das Lesen von der lokalen Datenbank konstruieren. */
        application_entity_BOC_Set structapplication_entity_BOC_Set_DB =
                new application_entity_BOC_Set(frmCC, frmTF);
/*
 * Alle Datensätze für das BO von der lokalen Datenbank lesen und auf Fehler prüfen. */
        structapplication_entity_BOC_Set_DB.selectAllByObjectID_DB(locBO.ObjectID);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC-Set abfragen. */
      switch(structapplication_entity_BOC_Set_DB.StatusCode) {
      case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      case JSBS_BO.CONST_NOT_FOUND:
/* Noch keine Daten erfaßt; kein Fehler.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      default:
/* Ein anderer Fehler ist beim Selektieren aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode) auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
        frmTF.handleErrorEvent(this.getClass().getName(), "selectAllByObjectID_DB",
          Integer.toString(structapplication_entity_BOC_Set_DB.StatusCode),
          structapplication_entity_BOC_Set_DB.StatusMsg);
        return;
      }
/*
 * BOC-Variable für das Lesen vom JAS (Java Application Server) konstruieren. */
        application_entity_BOC_Set structapplication_entity_BOC_Set_JAS =
                new application_entity_BOC_Set(frmCC, frmTF);
/*
 * Alle Datensätze für das BO vom JAS lesen und auf Fehler prüfen. */
        structapplication_entity_BOC_Set_JAS.selectAllByObjectID_JAS(locBO.ObjectID);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC-Set abfragen. */
      switch(structapplication_entity_BOC_Set_JAS.StatusCode) {
      case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      case JSBS_BO.CONST_NOT_FOUND:
/* Noch keine Daten erfaßt; kein Fehler.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      default:
/* Ein anderer Fehler ist beim Selektieren aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode) auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
        frmTF.handleErrorEvent(this.getClass().getName(), "selectAllByObjectID_JAS",
          Integer.toString(structapplication_entity_BOC_Set_JAS.StatusCode),
          structapplication_entity_BOC_Set_JAS.StatusMsg);
        return;
      }
/*
 * Variable für die jeweiligen Datensätze des BO aus den Listen (mit einzelnen, historischen Datensätzen
 * eines BO) von lokaler Datenbank und JAS. */
      application_entity_BO locBO_DB;
      application_entity_BO locBO_JAS;
/*
 * Variable für die Anzahl der Elemente in den jeweiligen Listen und Variable für die Indizes. */
      int intDBVectorSize = structapplication_entity_BOC_Set_DB.vecRecordSet.size();
      int intDBVectorIndex;
      int intJASVectorSize;
      int intJASVectorIndex;
/*
 * Merker, ob ein Datensatz des untersuchten BO bereits synchron auf beiden Datenbanken existiert. */
      boolean bolAlreadySynchronized;
/* 
 * for-Schleife für das Bearbeiten der einzelnen Datensätze des BO auf der lokalen Datenbank.
 * Die Untersuchung wird beim 'ältesten' Datensatz begonnen weil bereits geprüfte Datensätze
 * (Elemente im Vector) aus dem Vector entfernt werden. */
      for (intDBVectorIndex = intDBVectorSize - 1; intDBVectorIndex >= 0; intDBVectorIndex--) {
        locBO_DB = (application_entity_BO) structapplication_entity_BOC_Set_DB.vecRecordSet.elementAt(intDBVectorIndex);
/*
 * Setzen des Markers mit dem nach dem Untersuchen des Datensatzes von der lokalen Datenbank
 * festgestellt werden kann, ob dieser Datensatz mit gleichen Attributen bereits am JAS existiert. */
        bolAlreadySynchronized = false;
/*
 * Feststellen der Anzahl der Elemente in der Liste mit den Datensätzen vom JAS.
 * Dieses Feststellen muss bei jedem Durchlauf neu erfolgen, weil bereits synchronisierte
 * Datensätze aus dem Vector mit den Datensätzen vom JAS gelöscht werden. */
        intJASVectorSize = structapplication_entity_BOC_Set_JAS.vecRecordSet.size();
/* 
 * for-Schleife für das Bearbeiten der einzelnen Datensätze des BO auf der Datenbank des JAS.
 * Die Untersuchung wird beim 'ältesten' Datensatz begonnen weil bereits geprüfte Datensätze
 * (Elemente im Vector) aus dem Vector entfernt werden. */
        for (intJASVectorIndex = intJASVectorSize - 1; intJASVectorIndex >= 0; intJASVectorIndex--) {
          locBO_JAS = (application_entity_BO) structapplication_entity_BOC_Set_JAS.vecRecordSet.elementAt(intJASVectorIndex);
/* 
 * Prüfen, ob die Werte der Datensätze auf der lokalen Datenbank und auf dem JAS bereits komplett gleich sind. */
          bolAlreadySynchronized = ( (! locBO_JAS.isDifferent(locBO_DB))
                                    && (! locBO_JAS.differentValidTill(locBO_DB.ValidTill)));
          if (bolAlreadySynchronized) {
/* 
 * Werte der Datensätze auf beiden Seiten komplett gleich; aus dem jeweiligen Vector entfernen
 * und diese (innere) for-Schleife beenden. */
            structapplication_entity_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex);
            structapplication_entity_BOC_Set_JAS.vecRecordSet.removeElementAt(intJASVectorIndex);
            break;
          }
/* 
 * Prüfen, ob der Datensatz (mit gleicher ID) verändert wurde.
 * Nachdem auf komplette Gleichheit bereits im vorigen 'if' geprüft wurde, kann jetzt bei gleichem ID
 * nur mehr ein Unterschied in den Attributen vorhanden sein. */
          if (locBO_DB.DataSetID == locBO_JAS.DataSetID) {
/* 
 * Mindestens ein Wert verschieden.
 * Im folgenden if prüfen, welcher Datensatz später verändert wurde oder inzwischen beendet wurde und
 * die Werte von diesem auf 'die andere Seite' übertragen. */
            if ( (locBO_DB.ChangedAt.after(locBO_JAS.ChangedAt))
                || (! locBO_DB.ValidTill.after(locBO_JAS.ValidTill)))
                  synchronizeFromDB(locBO_DB);
            else synchronizeFromJAS(locBO_JAS);
/* 
 * Merker, dass die Datensätze synchronisiert sind, setzen,
 * beide Datensätze aus dem jeweiligen Vector entfernen und diese (innere) for-Schleife beenden. */
            bolAlreadySynchronized = true;
            structapplication_entity_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex);
            structapplication_entity_BOC_Set_JAS.vecRecordSet.removeElementAt(intJASVectorIndex);
            break;
          }
        }
/* 
 * Wenn der Datensatz auf der lokalen DB noch nicht auf dem JAS existiert dann den Datensatz auf dem
 * JAS einfügen.
 * Erkannt wird das daran, dass die innere for-Schleife (Set mit den Datensätzen vom JAS) komplett durchlaufen
 * wurde und der bearbeitete Datensatz aus der äusseren for-Schleife (Set mit den Datensätzen von der
 * lokalen Datenbank) im Set mit den Datensätzen vom JAS nicht gefunden wurde. */
        if (! bolAlreadySynchronized) {
/* Datensatz von der lokalen Datenbank auf die Datenbank des JAS übertragen und aus dem Set von der lokalen DB entfernen. */
            synchronizeFromDB(locBO_DB);
            structapplication_entity_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex);
        }
      }
/* 
 * Die jetzt noch im Set des JAS enthaltenen Datensätze wurden auf dem JAS erstellt während der
 * mobile Client nicht verbunden war. Diese Datensätze auf der lokalen Datenbank einfügen.
 * Zuerst die verbliebene Anzahl der Elemente in der Liste mit den Datensätzen vom JAS ermitteln. */
      intJASVectorSize = structapplication_entity_BOC_Set_JAS.vecRecordSet.size();
/* 
 * for-Schleife für das Bearbeiten der einzelnen Datensätze des BO auf der Datenbank des JAS. */
      for (intJASVectorIndex = intJASVectorSize - 1; intJASVectorIndex >= 0; intJASVectorIndex--) {
        locBO_JAS = (application_entity_BO) structapplication_entity_BOC_Set_JAS.vecRecordSet.elementAt(intJASVectorIndex);
        synchronizeFromJAS(locBO_JAS);
      }
/* 
 * Das gerade synchronisierte BO (das erste Element im Vector mit Index 0) aus dem Vector entfernen.
 * Der Befehl wird 'synchronized' ausgeführt damit nicht gleichzeitig geprüft werden kann
 * ob der Vector leer ist. */
      synchronized (vecBO_List_ToProcess) {
          vecBO_List_ToProcess.removeElementAt(0);
      }
    }
/* ---------------------
 * METHODE zum Übertragen des Daten des als Parameter übergebenen BO auf die DB des JAS. */
/* --------------------- */
    private void synchronizeFromDB(application_entity_BO parmapplication_entity_BO) {
/*
 * Merken des DataSetID des Datensatzes weil dieser eventuell auf der JAS-Seite geändert werden kann. */
      double dblOriginalDataSetID = parmapplication_entity_BO.DataSetID;
/*
 * BOC-Variable für das Speichern auf dem JAS konstruieren. */
        application_entity_BOC structapplication_entity_BOC =
                new application_entity_BOC(frmCC, frmTF);
/*
 * Daten aus dem Parameter auf das gerade konstruierte BOC übertragen. */
        structapplication_entity_BOC.copyFromapplication_entity_BO(parmapplication_entity_BO);
/*
 * Speichern des BO auf dem JAS. */
        structapplication_entity_BOC.synchronizedStore_JAS();
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des BOC abfragen. */
        switch(structapplication_entity_BOC.StatusCode) {
        case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
          break;
        default:
/* Ein anderer Fehler ist beim Speichern aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode) auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
          frmTF.handleErrorEvent(this.getClass().getName(), "synchronizeFromDB_JAS",
            Integer.toString(structapplication_entity_BOC.StatusCode),
            structapplication_entity_BOC.StatusMsg);
          return;
        }
/* 
 * Prüfen ob auf dem JAS die DataSetID geändert wurde. Das kann passieren wenn auf dem JAS für ein
 * anderes BO zufällig die gleiche DataSetID wie auf der lokalen DB für dieses BO vergeben wurde.
 * In diesem Fall wird die DataSetID auf der lokalen Datenbank geändert. */
      if (dblOriginalDataSetID != structapplication_entity_BOC.DataSetID) {
/*
 * Speichern des BO auf der lokalen DB. */
        structapplication_entity_BOC.synchronizedStore_DB(dblOriginalDataSetID);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des BOC abfragen. */
        switch(structapplication_entity_BOC.StatusCode) {
        case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
          break;
        default:
/* Ein anderer Fehler ist beim Speichern aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode) auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
          frmTF.handleErrorEvent(this.getClass().getName(), "synchronizeFromDB_DB",
            Integer.toString(structapplication_entity_BOC.StatusCode),
            structapplication_entity_BOC.StatusMsg);
          return;
        }
      }
    }
/* ---------------------
 * METHODE zum Übertragen des Daten des als Parameter übergebenen BO auf die lokale Datenbank. */
/* --------------------- */
    private void synchronizeFromJAS(application_entity_BO parmapplication_entity_BO) {
/*
 * BOC-Variable für das Speichern auf der lokalen DB konstruieren. */
        application_entity_BOC structapplication_entity_BOC =
                new application_entity_BOC(frmCC, frmTF);
/*
 * Daten aus dem Parameter auf das gerade konstruierte BOC übertragen. */
        structapplication_entity_BOC.copyFromapplication_entity_BO(parmapplication_entity_BO);
/*
 * Speichern des BO auf der lokalen Datenbank.
 * Durch den Parameter '0' wird geprüft, ob bereits ein Datensatz mit dem Wert des DataSetID
 * aus dem BO existiert.
 * In der Methode 'synchronizedStore_DB' wird auch geprüft, ob ein existierende Datensatz mit
 * dem gleichen DataSetID auch zu dem gerade bearbeiteten BO gehört.
 * Wurde zufällig bereits ein Datensatz mit gleichem DataSetID zu einem anderen BO erstellt
 * dann wird bei diesem Datensatz des anderen BO der Wert des DataSetID geändert. */
        structapplication_entity_BOC.synchronizedStore_DB(0);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des BOC abfragen. */
        switch(structapplication_entity_BOC.StatusCode) {
        case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
          break;
        default:
/* Ein anderer Fehler ist beim Speichern aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode) auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
          frmTF.handleErrorEvent(this.getClass().getName(), "synchronizeFromJAS",
            Integer.toString(structapplication_entity_BOC.StatusCode),
            structapplication_entity_BOC.StatusMsg);
          return;
        }
    }
}

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung

Am leichtesten funktioniert die Anpassung des Muster-Codes an die eigenen Erfordernisse durch Kopieren des Muster-Codes und Verwendung von Edit > Find/Replace... .

Für 'Platzhalter', die nur einmalig im Muster-Code vorkommen ist die 'Find'-Funktion hilfreich zum finden der beschriebenen 'Platzhalter'.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Java-Packages der Anwendung

package application_package.boc;
/*
. . . . .
. . . . .

Der Name dieses Packages kommt in der ersten Zeile des Muster-Codes und dann noch mehrmals beim Import der zugehörigen Packages mit der Generellen BO Klassen und der Klasse für das CommandCenter (Start-Frame) vor.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Klasse des CommandCenters

/*
 * Package und Basisklasse für das Task-Frame. */
import js_base.frame.JSBS_TaskFrame;
/*
 * Klasse für das CommendCenter (Start-Frame) der Anwendung. */
import application_package.client.application_CommandCenter;
/*
 * Packages mit der zugehörigen generellen Klasse des BO. */

Der Name dieser Klasse kommt mehrmals im Muster-Code vor.
Wenn Sie 'Find/Replace' zum Ersetzen verwenden, geben Sie bitte den Text application_CommandCenter als Suchbegriff ein; damit wird nur der Name dieser Klasse ersetzt und nicht auch Teile anderer 'Platzhalter' die application enthalten.

▲ zum Inhaltsverzeichnis

Adaptieren des Kommentars

'Kein Kommentar ist besser als ein falscher'.

Aus diesem Grund ist im Muster-Code auch keine Hintergrund-Information über Entwurfs-Entscheidungen für das BOC_Set vorhanden.
Meiner Erfahrung nach ist es ausreichend für die Beschreibung der Variablen des BO auf die Generelle Klasse für das BO zu verweisen.
Die einzelnen Methoden der BOC_Set-Klasse sind innerhalb des Codes kommentiert.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Klasse und der 'Constructor-Methode'

Der Name der Klasse kommt mehrmals im gesamten Code vor.
Deswegen empfehle ich, mit 'Find/Replace' alle Platzhalter application_entity_BO im Muster-Code durch den gewählten Klassen-Namen zu ersetzen.
application_entity_BO als Vergleichswert wird deswegen gewählt weil damit auch die Variable für die geerbte Klasse geändert wird.

Erstmals kommt der Name der zugehörigen Klasse im Kommentar vor:
. . . . .
. . . . .
 *
 * @description
 *  Klasse für den Datenabgleich zwischen JAS (Java Application Server) und lokaler Datenbank
 *  für Daten der Klasse application_entity_BO.
 *  Dieser Klasse ist notwendig wenn das Anwendungsprogramm auch für die Version 'MobileClient'
. . . . .
. . . . .

Wenn der Name im Kommentar nicht geändert wurde, muss bei der Deklaration der Klasse begonnen werden:
. . . . .
. . . . .
 */
public class application_entity_BO_Synchronizer extends Thread {
/* ---------------------
. . . . .
. . . . .

Dieser Name hier muss mit dem Namen der Klasse übereinstimmen, der beim Eröffnen der Klasse gewählt wurde.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis