Benutzerdefinierte Klassen aus generierten Implementierungsklassen erweitern

Sie können Klassen schreiben, die durch Implementierungsklassen erweitert werden, die der pureQuery-Generator generiert.

Informationen zu diesem Vorgang

Das pureQuery-Dienstprogramm Generator generiert Klassen, die eine Schnittstelle implementieren, die mit Annotationen versehene Methoden implementiert, und eine Implementierung der Schnittstelle Data erweitert. Da Anwendungen in der Regel keinen Zugriff auf die vielen Methoden der Schnittstelle Data benötigen, geben die Methoden in DataFactory, die Implementierungsklassen für bestimmte Schnittstellen instanziieren, die mit Annotationen versehene Methoden deklarieren, während der Ausführung Instanzen dieser Schnittstellen zurück.

Wenn z. B. eine dieser DataFactory-Methoden eine Implementierung der Schnittstelle MyInterface instanziiert und myObject auf den Rückgabewert der Methode gesetzt ist, ist MyInterface der Typ von myObject. Ihre Anwendung muss myObject in ein Datenobjekt umsetzen, damit sie auf die Datenmethoden in myObject zugreifen kann.

Wenn das pureQuery-Dienstprogramm Generator eine Implementierungsklasse generiert, erweitert diese Klasse standardmäßig eine Implementierung der Datenschnittstelle namens BaseData. Die Implementierungsklasse kann jedoch eine andere Klasse erweitern, die selbst BaseData erweitert.

Eine Implementierungsklasse soll möglicherweise aus einem der folgenden Gründe so handeln:
  • Es gibt einige Methoden in Data, auf die Sie in Ihrer generierten Implementierungsklasse zugreifen wollen, ohne die Klasse als Typ Data umzusetzen.
  • Sie wollen auf eine der Methoden in Data über einen anderen Namen zugreifen.
  • Mindestens eine Methode wollen Sie selbst implementieren (anstatt ihre Implementierung generieren zu lassen) und in der Implementierungsklasse verfügbar haben, die das Dienstprogramm Generator generiert. Beispielsweise wollen Sie eine Methode selbst implementieren, wenn diese Implementierung von der generierten Implementierung abweichen soll oder wenn die Methode nicht als mit Annotationen versehene Methode generiert werden kann.
Achtung: Die Klasse, die BaseData erweitert, darf keine Methoden überschreiben, die in BaseData implementiert werden.

Datenobjekte sind nicht threadsicher. Nutzen Sie sie nicht threadübergreifend. Verwenden Sie ein Objekt Data nur in dem Thread, es erstellt wurde.

Vorgehensweise

Gehen Sie wie folgt vor, um Ihre Klasse von einer Implementierungsklasse zu erweitern, die das Dienstprogramm Generator generiert:

  1. Erstellen Sie eine Klasse, die com.ibm.pdq.runtime.generator.BaseData erweitert und Methoden definiert, die von der generierten Implementierungsklasse verfügbar sein sollen.
  2. Führen Sie den pureQuery-Generator aus. Geben Sie dabei die Schnittstelle an, für die Sie eine Implementierungsklasse erstellen wollen, und den Namen der Klasse, die Sie erweitern wollen.
    1. Geben Sie den Namen der Schnittstelle an, die mit Annotationen versehene Methoden deklariert, für die Sie eine Implementierungsklasse generieren wollen.
    2. Geben Sie mit der Option 'baseDataOverride' für den pureQuery-Generator den Namen der Klasse an, die die generierte Implementierungsklasse erweitern soll.

Beispiel

Angenommen, Sie wollen der Implementierungsklasse, die der pureQuery-Generator für eine Schnittstelle generiert, die mit Annotationen versehene Methoden deklariert, Methoden hinzufügen. Die zusätzlichen Methoden führen die folgenden Funktionen aus:
  • Heterogener Stapel
  • Dynamische Abfrage-SQL, das ein "Bean"-Array zurückgibt
  • Dynamisches Einfüge-, Aktualisierungs-, Lösch-, DDL-SQL
Sie erstellen die folgende Schnittstelle für die Methoden:
package customer;
public interface CommonInterface
{
  public void startHeterogeneousBatch (); // this method "renames" the Data Interface method
  public int[][] endHeterogeneousBatch (); // this method "renames" the Data Interface method
  public int dynamicSQLUpdate (String updateSQL, Object... parameters); // this method "renames" the Data Interface method
  public <T> T[] dynamicQueryArray (String sql, Class<T> returnClass, Object... parameters); // this method "renames" the Data Interface method
  public void commit ();
  public void rollback ();
  // any other Data Interface method can be coded here also
}
Sie implementieren diese Schnittstelle mit der folgenden Klasse:
package customer;

public class BaseData extends com.ibm.pdq.runtime.generator.BaseData implements CommonInterface
{
  public <T> T[] dynamicQueryArray (String sql, Class<T> returnClass, Object... parameters)
  {
    return queryArray (sql, returnClass, parameters);
  }
  public int dynamicSQLUpdate (String updateSQL, Object... parameters)
  {
    return update (updateSQL, parameters);
  }
  public void startHeterogeneousBatch ()
  {
    startBatch (heterogeneousModify__);
    return;
  }
  public int[][] endHeterogeneousBatch ()
  {
    return endBatch ();
  }
}

Beachten Sie, dass diese Klasse com.ibm.pdq.runtime.generator.BaseData erweitert.

Angenommen, Sie erstellen nun eine Schnittstelle, die eine mit Annotationen versehene Methode deklariert:
import com.ibm.pdq.annotation.Update;

public interface AutoGeneratedKeysInterface
{
  @Update(sql = "insert into MYEMPLOYEE (name, salary, deptno) values(:name, :salary, :deptno)")
  int createEmployee (MyEmployeeBean bean);
}
Sie modifizieren die Schnittstelle, damit sie CommonInterface erweitert:
import com.ibm.pdq.annotation.Update;

public interface AutoGeneratedKeysInterface extends customer.CommonInterface
{
  @Update(sql = "insert into MYEMPLOYEE (name, salary, deptno) values(:name, :salary, :deptno)")
  int createEmployee (MyEmployeeBean bean);
}

Wenn Sie über den pureQuery-Generator die Implementierungsklasse für diese Schnittstelle generieren, geben Sie 'customer.BaseData' für die Option 'baseDataOverride' an.


Feedback