Extension des classes définies par l'utilisateur depuis les classes d'implémentation générées

Vous pouvez écrire les classes étendues par les classes d'implémentation que pureQuery Generator génère.

Pourquoi et quand exécuter cette tâche

L'utilitaire pureQuery Generator génère les classes qui, à la fois, implémentent une interface déclarant des méthodes annotées et étendent l'implémentation de l'interface Data. Les applications n'ayant généralement pas besoin d'accéder à de nombreuses méthodes de l'interface Data, lors de l'exécution, les méthodes incluses dans DataFactory qui instancient des classes d'implémentation pour des interfaces de méthodes annotées particulières retournent les instances de ces interfaces.

Par exemple, si l'une de ces méthodes DataFactory instancie une implémentation de l'interface MyInterface, et que myObject est défini pour retourner la valeur de la méthode, myObject est du type MyInterface. Pour permettre à votre application d'accéder aux méthodes Data dans myObject, l'application doit transtyper myObject dans un objet Data.

Lorsque l'utilitaire pureQuery Generator génère une classe d'implémentation, cette classe étend par défaut une implémentation de l'interface Data nommée BaseData. La classe d'implémentation peut toutefois étendre une classe différente étendant elle-même BaseData.

Vous voudrez peut-être laisser une classe d'implémentation s'occuper de cette opération pour l'une des raisons suivantes :
  • Data possède quelques méthodes auxquelles vous voulez accéder dans votre classe d'implémentation générée sans qu'il soit nécessaire de transtyper la classe comme type Data.
  • Vous voulez accéder à l'une des méthodes de Data au moyen d'un nom différent.
  • Il existe au moins une méthode à implémenter vous-même (au lieu de générer son implémentation) et dont vous pouvez disposer dans la classe d'implémentation que l'utilitaire Generator génère. Par exemple, vous voudrez peut-être implémenter une méthode vous-même si vous souhaitez que l'implémentation soit différente de ce que l'implémentation générée devrait être, ou si la méthode n'est pas une méthode pouvant être générée comme méthode annotée.
Avertissement : La classe étendant BaseData ne doit pas remplacer les méthodes implémentées dans BaseData.

L'unité d'exécution des objets de données n'est pas sécurisée. Ne les partagez pas entre plusieurs unités d'exécution. Utilisez un objet Data uniquement dans la même unité d'exécution que celle dans laquelle il a été créé.

Procédure

Pour étendre votre classe à partir d'une classe d'implémentation générée par l'utilitaire Generator :

  1. Créez une classe étendant com.ibm.pdq.runtime.generator.BaseData et définissant des méthodes que vous souhaitez rendre disponibles depuis la classe d'implémentation générée.
  2. Exécutez pureQuery Generator, en fournissant à l'interface concernée par la création une classe d'implémentation et le nom de la classe que vous voulez étendre.
    1. Fournissez le nom de l'interface de méthode annotée pour laquelle générer une classe d'implémentation.
    2. A l'aide de l'option baseDataOverride de pureQuery Generator, fournissez le nom de la classe dont vous souhaitez étendre la classe d'implémentation générée.

Exemple

Supposons que vous souhaitiez ajouter des méthodes à la classe d'implémentation que pureQuery Generator génère pour une interface déclarant des méthodes annotées. Les méthodes supplémentaires assurent les fonctions suivantes :
  • Lot hétérogène
  • SQL d'interrogation dynamique retournant une table "Bean"
  • Insertion, mise à jour, suppression, SQL DDL dynamique
Vous créez l'interface suivante pour stocker les méthodes :
package customer;
public interface CommonInterface
{
  public void startHeterogeneousBatch (); // cette méthode "renomme" la méthode Data Interface
  public int[][] endHeterogeneousBatch (); // cette méthode "renomme" la méthode Data Interface
  public int dynamicSQLUpdate (String updateSQL, Object... parameters); // cette méthode "renomme" la méthode Data Interface
  public <T> T[] dynamicQueryArray (String sql, Class<T> returnClass, Object... parameters); // cette méthode "renomme" la méthode Data Interface
  public void commit ();
  public void rollback ();
  // toute autre méthode Data Interface peut également être codée ici
}
Vous implémentez cette interface avec la classe suivante :
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 ();
  }
}

Notez que cette classe étend com.ibm.pdq.runtime.generator.BaseData.

Maintenant, supposons que vous créez une interface déclarant une méthode annotée :
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);
}
Modifiez l'interface de sorte à étendre CommonInterface :
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);
}

Lorsque vous utilisez pureQuery Generator pour générer la classe d'implémentation de cette interface, vous spécifiez customer.BaseData pour l'option baseDataOverride.


Commentaires