Annotations dans les beans

Les annotations pureQuery ajoutent des métadonnées aux beans. Par exemple, vous pouvez ajouter un indicateur à une propriété afin d'indiquer qu'elle correspond à une colonne générée dans une table ou vue de base de données. Les métadonnées de l'annotation peuvent aussi affecter le traitement du bean, comme la modification du mappage par défaut entre une propriété et une colonne.

Les annotations peuvent aussi contenir des métadonnées qui contrôlent les options que pureQuery StaticBinder utilise lors de l'exécution d'une opération de liaison sur l'interface.

Annotations au niveau du bean

Les annotations au niveau du bean s'appliquent à la totalité du bean. Lorsque vous utilisez une annotation au niveau du bean, vous devez l'indiquer avant de commencer à définir le ce dernier, comme suit :
@ColumnOverride(propertyName="extension", column="PHONE") 
 
public class EmployeeNewCo extends Employee {...

Pour comprendre les conventions utilisées dans les diagrammes de syntaxe, voir Comment lire les diagrammes de syntaxe.

@ColumnOverride
Lire le diagrammeSauter le diagramme
>>-@ColumnOverride--(--propertyName--=--"--propriété--",--column--=--"--nom--")-><

Cette annotation spécifie une association entre une colonne SQL et une propriété du bean. Elle contient le nom de la colonne dans la table ou la vue implicitement ou explicitement associée à sa classe, ainsi que le nom de la propriété mappée par cette annotation. Le mappage indiqué dans cette annotation remplace les mappages de cette propriété vers d'autres colonnes, dont les mappages définis à un autre endroit de cette classe ou dans une superclasse.
@ColumnOverrides
Lire le diagrammeSauter le diagramme
>>-@ColumnOverrides--(------------------------------------------>

      .-,----------------------------------------------------------------------------.      
      V                                                                              |      
>--{----@ColumnOverride--(--propertyName--=--"--propriété--",--column--=--"--nom--")-+--}-->

>--)-----------------------------------------------------------><

Cette annotation indique un groupe d'annotations @ColumnOverride. Utilisez cette annotation lorsque vous avez besoin de définir plusieurs annotations@ColumnOverride.

Le groupe d'annotations @ColumnOverride apparaît entre accolades dans les parenthèses des annotations @ColumnOverrides.

@Table
Lire le diagrammeSauter le diagramme
>>-@Table--(--name--=--nom_de_table----------------------------->

>--+--------------------------------+--)-----------------------><
   |  (1)                           |      
   '-------schema--=--nom_de_schéma-'      

Remarques:
  1. schema est actuellement ignoré

Annotation facultative spécifiée au niveau de la classe indiquant un nom de table par défaut pour toutes les propriétés des beans. Cette annotation n'est pas obligatoire lorsque vous créez un ensemble de beans imbriqués pour des instructions SQL contenant des jointures. Toutefois, l'annotation simplifie la définition de beans.

Le nom de table par défaut peut être écrasé par le nom de table spécifié dans une annotation @Column.

L'annotation @Table n'indique pas un nom de table par défaut pour les annotations @JoinColumn.

Contrairement aux annotations @ColumnOverride et @ColumnOverrides dans le style intégré, l'annotation @Table est héritée par les sous-classes, dans le style DAO (Data Access Object) et intégré.

Annotations de niveau de propriété

pureQuery reconnaît les annotations de niveau de propriété uniquement dans les zones publiques et les méthodes publiques get() ou set(). Il ne reconnaît pas ces annotations dans des zones protégées ou confidentielles.

Pour comprendre les conventions utilisées dans le diagramme de syntaxe, voir Comment lire les diagrammes de syntaxe.

@Column
Lire le diagrammeSauter le diagramme
>>-@Column--(--name--=--nom_de_colonne--+------------------------+-><
                                        '-table--=--nom_de_table-'   

Cette annotation indique la colonne SQL dans un objet de base de données mappé par une propriété. Vous pouvez utiliser cette annotation uniquement sur des zones publiques et des méthodes publiques. Si vous l'utilisez en d'autres endroits, pureQuery l'ignore.

L'annotation @Column peut être utilisée pour deux raisons :

  • Le nom d'une colonne SQL et le nom d'une propriété dans un bean ne correspondent pas dans une recherche ignorant la casse. Dans ce cas, utilisez uniquement l'élément name de l'annotation.
    @Column(name="DEPTNO") 
    public String deptNum;
    @Column(name="EMPNO") 
    public String getEmpNum() {
        return empNum; 	
    }
  • Un résultat de requête d'une sélection de plusieurs tables contient deux colonnes ou plus portant le même nom. Dans ce cas, utilisez les éléments name et table de l'annotation. Si l'association du nom de table et de colonne s'affiche aussi en double, vous devez utiliser une clause AS dans votre requête SQL afin que les libellés de colonne soient uniques.

    Exemple

    Par exemple, si votre application exécute la simple requête suivante :
    	select a.col1, b.col1 from a, b where a.id=b.id;
    Les méthodes setA_col1 et setB_col1 appliquées aux propriétés suivantes dans les beans contenant les résultats de la requête doivent inclure des annotations @Column qui indiquent le nom de la table dans laquelle apparaissent les deux colonnes col1 :
    public class JoinExample{
    
      private int a_col1;
      private int b_col1;
    
      @Column (name="col1", table="a")
      public void setA_col1 (int a_col1)
      {
        this.a_col1 = a_col1;
      }
      public int getA_col1 ()
      {
        return a_col1;
      }
    
      @Column (name="col1", table="b")
      public void setB_col1 (int b_col1)
      {
        this.b_col1 = b_col1;
      }
      public int getB_col1 ()
      {
        return b_col1;
      }
    }
@GeneratedKey
Cette annotation indique que la colonne SQL est une colonne générée automatiquement. La valeur est automatiquement affectée par la base de données lors des opérations INSERT ou UPDATE.
Si un bean contenant cette annotation est fourni en tant que paramètre unique pour une opération INSERT ou UPDATE avec une méthode annotée, ou une méthode d'interface de données définie par int update(String sql, Object... parameters), les propriétés sont mises à jour avant que la commande soit renvoyée à votre application.
Avertissement : Si vous passez deux beans ou plus en tant que paramètres d'entrée pour une opération de mise à jour, avec au moins une annotation @GeneratedKey dans chaque bean, l'opération de mise à jour ne marche pas. Cette restriction s'applique à la méthode update() (pour le style de méthode intégrée) et aux méthodes dans les annotations @Update (pour le style DAO).
@Format
Lire le diagrammeSauter le diagramme
>>-@Format--(--fomatterClass--=--classe_formateur--------------->

>--+----------------------------------------+--)---------------><
   '-, -formattingOptions--=--chaîne_modèle-'      

Cette annotation indique la classe contenant le formateur appelé pour exécuter toutes les conversions nécessaires, ainsi que les options de formatage. Vous pouvez utiliser cette annotation sur une zone dans un objet de bean spécifié comme entrée ou sortie sur une méthode pureQuery. Ceci s'applique au style DAO et intégré.

Si l'élément formatterClass spécifie une classe de formateur fournie par l'utilisateur, cette classe doit fournir une méthode de construction utilisant un seul argument de chaîne. La chaîne transmise à ce constructeur correspond à la valeur de la chaîne formattingOptions.
formattingOptions
Cette valeur de chaîne informe la classe de formateur des caractéristiques d'exécution des opérations de formatage ou d'analyse syntaxique, quel que soit le format exigé par la classe de formateur. Par exemple, les exemples de classes de formateur fournis par pureQuery utilisent le format key=value, en séparant les spécifications de paires individuelles par un point-virgule.
La classe de formateur fournie par l'utilisateur doit aussi indiquer les deux méthodes suivantes :
public String format(Object)
Cette méthode est appelée par le code généré après l'extraction d'une ligne. Elle convertit la valeur du résultat à partir de la requête SQL au format String adéquat prévu dans la zone annotée de la méthode Return object.
public Object parse(String)
Cette méthode est appelée par le code généré pour configurer les paramètres d'entrée sur une instruction SQL. Elle utilise le paramètre au format String, procède à son analyse syntaxique et renvoie un objet adéquat au paramètre de l'instruction SQL cible.
L'interface API pureQuery fournit les classes de formateur suivantes pour formater les dates :
  • com.ibm.pdq.runtime.data.formatters.DateFormatter
  • com.ibm.pdq.runtime.data.formatters.TimeFormatter
  • com.ibm.pdq.runtime.data.formatters.TimestampFormatter

Cette classe de formateur convertit les zones String aux types JDBC DateTime adéquats pour les variables d'entrée, puis convertit et formate les types JDBC renvoyés aux variables String pour la sortie.

L'exemple suivant formate la zone startDate :

class MyBean {
…
@Format(formatter=com.ibm.pdq.Dateformatter.class, formattingOtions=”style=LONG; 
   timezone=UTC”)
String startDate;
…
}
@Required
Lorsqu'elle est spécifiée sur une zone utilisée comme entrée pour un paramètre SQL, l'annotation indique que la zone doit contenir une valeur définie. Ceci s'applique à une méthode DAO et intégrée.

L'annotation ne s'applique pas aux zones primitives Java car ces zones Java ne peuvent pas représenter de valeurs définies.

Si l'annotation @Required n'est pas spécifiée, le comportement par défaut consiste à reconnaître les valeurs Java définies dans les paramètres d'entrée et de définir la valeur de la variable hôte correspondante sur SQL NULL.

Si l'annotation @Required est spécifiée sur une zone utilisée comme entrée d'un paramètre SQL et que cette zone contient une valeur Java définie lorsque vous accédez à la zone, une exception est générée par pureQuery et aucune opération SQL n'est déclenchée.

L'exemple suivant exige que la valeur customerAddress contienne une valeur définie.

@Required
String customerAddress;

Annotations pour les ensembles de beans imbriqués utilisés avec des jointures de table

Pour une requête SQL contenant des jointures de table, vous pouvez créer un ensemble de beans imbriqués qui renvoient des données à partir de la requête. La hiérarchie des beans duplique la structure relationnelle des données de la base de données. Spécifiez des annotations pureQuery avec des beans imbriqués afin d'indiquer les relations entre la table et les colonnes. pureQuery Runtime renseigne les beans à l'aide des résultats de la requête. Pour plus d'informations sur les beans imbriqués utilisés avec les jointures de table, voir Beans imbriqués et requêtes SQL contenant des jointures de table.

Annotations de niveau de propriété

@Id
Lire le diagrammeSauter le diagramme
>>-@Id---------------------------------------------------------><

Cette annotation indique que la propriété annotée représente une colonne d'identité utilisée par pureQuery Runtime pour déterminer l'égalité entre des beans de la même classe. Cette annotation est utilisée sur les propriétés d'un bean. Les colonnes d'identité sont des colonnes liant des beans enfant au bean parent. Au moins une annotation @Id doit être spécifiée dans le bean de niveau supérieur pour activer la génération des beans imbriqués par pureQuery Runtime. La colonne correspondante dans la base de données n'a pas à être déclarée comme colonne de clé principale ou externe.

L'annotation @Column peut être utilisée avec l'annotation @Id pour spécifier le nom de colonne et de table qui mappe l'objet ResultSet vers la colonne de clé.

Dans les beans enfant, l'annotation @Id ou @JoinPoint peut être utilisée pour définir les colonnes d'identité liant un bean parent à un bean enfant. Si les deux sont indiquées, les informations d'annotation @JoinPoint sont utilisées et l'annotation @Id est ignorée. L'annotation @JoinPoint est spécifiée dans une référence au bean dans son bean parent et l'annotation @Id est spécifiée dans le bean même.

Si le bean dispose d'une clé composée, plusieurs annotations @Id doivent être spécifiées dans le bean enfant ou des clés doivent être spécifiées à l'aide d'une annotation @JoinPoint du bean parent. Dans l'annotation @JoinPoint, une clé doit être spécifiée par une annotation @JoinColumn à l'aide de l'élément propertyName.

Pour déterminer si des beans sont égaux lors du traitement de beans imbriqués, pureQuery Runtime vérifie les propriétés des beans à l'aide des annotations @Id. Si toutes les propriétés disposant d'annotations @Id sont égales, alors les beans sont considérés comme étant égaux. Les propriétés des beans disposant d'annotations @Id n'ont pas besoin d'être des clés primaires ou externes dans la base de données. Toutefois, elles doivent suffire pour déterminer l'égalité entre des beans de la même classe.

@JoinColumn
Lire le diagrammeSauter le diagramme
>>-@JoinColumn--(--name--=--nom_de_colonne---------------------->

>--+--------------------------+--------------------------------->
   '-table--=--nom_de_colonne-'   

>--+-----------------------------------+--)--------------------><
   '-propertyName--=--nom_de_propriété-'      

Cette annotation spécifie la colonne d'un objet ResultSet en tant que colonne d'identité d'un bean enfant lorsque le nom de propriété d'un bean parent ne correspond pas au libellé de colonne d'un objet ResultSet ou d'un nom de table. Cette annotation est spécifiée dans le bean parent en tant qu'annotation sur les beans enfant. Ces derniers correspondent à un bean unique ou une liste de beans.

Une annotation @JoinColumn peut être spécifiée uniquement dans une annotation @JoinPoint.

Si vous spécifiez une chaîne vide ("") en tant que valeur pour l'élément name, pureQuery Runtime désactive la prise en charge de la génération des beans imbriqués sur cette propriété sans générer d'avertissement selon lequel la propriété ne correspond pas. Spécifiez une chaîne vide dans une sous-classe si vous ne souhaitez pas qu'un bean enfant spécifique ou une liste de beans soit renseigné(e).

Si une annotation @JoinPoint contient une annotation @JoinColumn qui écrase une ou plusieurs annotations @Id dans un bean enfant, pureQuery Runtime ignore toutes les annotations @Id dans le bean enfant. Pour un bean enfant, l'annotation n'est pas ignorée dans le cas suivant :
  • Le bean enfant ne dispose que d'une seule annotation @Id indiquée sur une propriété.
  • L'annotation @JoinColumn du bean parent ne modifie que le libellé de colonne ResultSet et éventuellement le nom de table. Elle ne modifie pas la propriété définie avec l'annotation @Id du bean enfant.
@JoinPoint
Lire le diagrammeSauter le diagramme
>>-@JoinPoint--------------------------------------------------->

>--+----------------------------------------------------------------------------------------+-><
   '-(--+------------------------------------------------+--+--------------------------+--)-'   
        '-+------------+--groupe_annotations_@JoinColumn-'  '-columnPrefix--=--préfixe-'        
          +-joinCol--=-+                                                                        
          '-value--=---'                                                                        

Au moins une annotation @JoinPoint doit être spécifiée dans le bean de niveau supérieur, c'est-à-dire le bean correspondant à la valeur de retour de la méthode ou l'interface API intégrée. L'annotation active la génération d'un ensemble de beans imbriqués par pureQuery Runtime.

L'annotation peut être uniquement définie sur une propriété contenant un bean ou une liste de beans. Les annotations @JoinColumn facultatives définissent les colonnes de l'objet ResultSet qui sont mappées vers les colonnes d'identité d'un bean enfant. L'élément columnPrefix facultatif indique un préfixe de colonne à ajouter à chaque propriété dans le bean enfant. Lorsque le bean enfant dispose d'une clé composée, plusieurs colonnes de l'objet ResultSet doivent être spécifiées en tant que colonne de clé.

L'annotation peut uniquement être définie sur une propriété contenant une bean ou une liste de beans. Si aucun des éléments facultatifs (groupe d'annotations @JoinColumn ou élément columnPrefix) n'est spécifié, alors tous les mappages ResultSet et définitions de colonne d'identité sont issus du bean enfant.

Un groupe d'annotations @JoinColumn est facultatif et s'applique aux propriétés du bean enfant. Les groupes de plusieurs annotations @JoinColumn doivent être placés entre accolades, ({ }).

Si aucune annotation @JoinColumn n'est spécifiée, alors pureQuery Runtime utilise les annotations @Id du bean enfant référencé pour déterminer les colonnes ResultSet qui effectuent un mappage vers les colonnes d'identité du bean enfant. Si un bean enfant ne contient pas au moins une annotation @Id, un avertissement est généré et le bean enfant est ignoré.

L'élément joinCol est mutuellement exclusif avec l'élément value. L'un ou l'autre peut être spécifié, mais pas les deux. L'élément est requis lorsque l'élément columnPrefix est spécifié.

La valeur de l'élément columnPrefix spécifie une chaîne placée en préfixe de chaque propriété du bean enfant. Grâce à ce préfixe, pureQuery Runtime génère des classes et des propriétés uniques. Le préfixe permet d'utiliser une même classe de bean à différents niveaux ou à un même niveau dans la structure de beans imbriqués sans récursivité. Vérifiez que ces propriétés placées en préfixe sont uniques. Lorsqu'un préfixe est ajouté à une classe, il s'applique à tous les beans enfant et les propriétés des beans de la classe placée en préfixe. Les préfixes peuvent être ajoutés et l'imbrication peut se poursuivre à la profondeur nécessaire. La valeur de l'élément columnPrefix est uniquement appliquée au bean enfant et non pas aux libellés de colonne définis dans les annotations @JoinColumn du bean parent.

Les préfixes de colonne sont appliqués uniquement si la requête renvoie des colonnes renseignant le bean enfant.

Dans l'exemple d'annotation @JoinPoint suivant, l'objet ResultSet contient des données renvoyées par une requête SQL. Elle joint une table DEPARTMENT et une table EMPLOYEE. Le nom de colonne indiquant le numéro de service est DEPTNO et le nom de colonne du matricule est EMPNO. Pour gérer cela, le bean Department doit être codé comme suit :
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

La première annotation @JoinColumn mappe la colonne DEPTNO à partir de la table DEPARTMENT vers la propriété empDepartment du bean Employee.

Si vous choisissez d'utiliser le libellé de colonne WORKDEPT de l'objet ResultSet, vous n'aurez pas à spécifier l'élément propertyName = "empDepartment" si le libellé de colonne WORKDEPT existait déjà dans l'objet ResultSet. La propriété WORKDEPT a été créée par l'annotation @Column (name = "WORKDEPT") dans le bean Employee.

Les annotations @JoinPoint auraient pu être spécifiées avec l'élément value ou joinCol. L'exemple suivant utilise l'élément value :
@JoinPoint(value = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();
Cet exemple se réfère au bean enfant de l'exemple précédent. Supposez que, plus tard dans ce même bean parent, une autre annotation @JoinPoint soit spécifiée sur une liste de beans Project et qu'un bean Project définisse aussi une liste de beans Employee (dans ce cas une liste d'employés travaillant sur le projet). Si l'élément columnPrefix n'est pas spécifié dans l'annotation @JoinPoint de la liste de beans Employee, l'utilisation ultérieure du bean Employee dans le bean Project est ignorée et la liste des employés travaillant sur le projet n'est pas renseignée même si l'objet ResultSet contenait des données. Indiquez l'élément columnPrefix de la Liste<d'employés> dans le bean Department ou Project. L'exemple suivant spécifie l'élément columnPrefix dans l'annotation @JoinPoint du bean Department :
@JoinPoint(columnPrefix = "DE", joinCol = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

Un élément columnPrefix de DE devant représenter les employés du service est placé en préfixe de toutes les propriétés du bean Employee et la chaîne DE doit être ajoutée à toutes les colonnes d'employés dans ResultSet (par la clause AS) qui servent à la liste des services des beans Employee.

Ce préfixe est aussi appliqué à tous les beans enfant de ce bean Employee.

Par exemple, si le bean Employee contient un bean Department enfant, toutes les propriétés du bean Department figurant dans ce bean Employee doivent avoir DE comme préfixe.

L'opération de préfixage se poursuit en fonction du nombre de niveaux disponibles dans l'objet ResultSet. Le deuxième niveau de la liste des beans Employee du bean Department enfant va afficher DEDE comme préfixe.

Ce préfixe est aussi appliqué à tous les beans enfant de ce bean Employee, mais pas à tous les beans Employee de la structure de beans imbriqués. Par exemple, ce préfixe n'est pas utilisé sur les listes de beans Employee dans le bean Project.

Si vous disposez d'un bean parent contenant plusieurs fois un même bean enfant, vous pouvez utiliser l'annotation @JoinPoint avec l'élément columnPrefix pour spécifier les colonnes qui sont mappées vers le bean enfant. L'exemple suivant utilise l'élément columnPrefix :
@JoinPoint
public List<Emp> emps;
@JoinPoint(columnPrefix="m_")
public Emp manager;

En spécifiant l'élément columnPrefix="m_", les colonnes de la table EMPLOYEE affichant m_ comme préfixe sont mappées vers la zone du responsable Emp.

Exemples d'annotation

Admettons que vous souhaitiez définir un bean contenant les enregistrements renvoyés par des requêtes dans la table HRDEPT.EMPLOYEE.
CREATE TABLE HRDEPT.EMPLOYEE(
  EMPNO CHAR(6) NOT NULL,
  FIRSTNME VARCHAR(12) NOT NULL,
  MIDINIT CHAR(1),
  LASTNAME VARCHAR(15), 
  WORKDEPT CHAR(2), 
  PHONENO CHAR(4),
  HIREDATE DATE,
  PRIMARY KEY(EMPNO))
Certains noms de colonnes sont abrégés ou ne suivent pas les conventions de dénomination Java.

La définition suivante de bean Employee utilise des annotations @Column pour attribuer des noms plus adaptés aux utilisateurs d'objet de la classe com.company.Employee.

public class Employee
{
  private String employeeId;
  private String firstName;
  private String middleInitial;
  private String lastName;
  private String departmentId;
  private String extension;
  private Date hireDate;

  @Column(name = "EMPNO")
  public String getEmployeeId ()
  {
    return employeeId;
  }

  public void setEmployeeId (String employeeId)
  {
    this.employeeId = employeeId;
  }

  @Column(name = "FIRSTNME")
  public String getFirstName ()
  {
    return firstName;
  }

  public void setFirstName (String firstName)
  {
    this.firstName = firstName;
  }

  @Column(name = "MIDINIT")
  public String getMiddleInitial ()
  {
    return middleInitial;
  }

  public void setMiddleInitial (String middleInitial)
  {
    this.middleInitial = middleInitial;
  }

  public String getLastName ()
  {
    return lastName;
  }

  public void setLastName (String lastName)
  {
    this.lastName = lastName;
  }

  @Column(name = "WORKDEPT")
  public String getDepartmentId ()
  {
    return departmentId;
  }

  public void setDepartmentId (String departmentId)
  {
    this.departmentId = departmentId;
  }

  @Column(name = "PHONENO")
  public String getExtension ()
  {
    return extension;
  }

  public void setExtension (String extension)
  {
    this.extension = extension;
  }

  public Date getHireDate ()
  {
    return hireDate;
  }

  public void setHireDate (Date hireDate)
  {
    this.hireDate = hireDate;
  }

}

Si une application s'exécute sur une base de données avec un schéma légèrement différent, la table est définie comme suit :

CREATE TABLE HRDEPTNEWCO.EMPLOYEE(
  EMPNO CHAR(6) NOT NULL,
  FIRSTNME VARCHAR(12) NOT NULL,
  MIDINIT CHAR(1),
  LASTNAME VARCHAR(15), 
  WORKDEPT CHAR(2), 
  PHONE CHAR(4),
  HIREDATE DATE,
  PRIMARY KEY(EMPNO))

Vous pouvez créer une sous-classe du bean Employee pour écraser l'annotation précédente afin d'utiliser la nouvelle définition de table. Le début de la sous-classe peut se présenter ainsi :

@ColumnOverride(propertyName="extension", column="PHONE") 
 
public class EmployeeNewCo extends Employee {...

Exemple d'ensemble de beans imbriqués

Dans l'exemple suivant, la clé principale de la table EMPLOYEE est la colonne EMPNO qui contient le numéro ID de l'employé et la colonne WORKDEPT contient le numéro de service pour lequel l'employé travaille. Le bean Employee peut afficher la définition suivante :
@Id
@GeneratedKey
@Column(name = "EMPNO")
public String getEmployeeId ()
{
   return employeeId;
}

public void setEmployeeId (String employeeId)
{
   this.employeeId = employeeId;
}

@Id
@Column(name = "WORKDEPT")
public String getDepartmentId ()
{
   return departmentId;
}

public void setDepartmentId (String departmentId)
{
   this.departmentId = departmentId;
}
Dans l'objet ResultSet, le nom de colonne du numéro de service est DEPTNO et le nom de colonne du matricule est EMPNO. Pour gérer cela, le bean Department doit afficher l'annotation @JoinPoint :
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="workDept"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

Dans la première annotation @JoinColumn, la colonne DEPTNO de la table DEPARTMENT effectue un mappage vers la propriété workDept du bean Employee. Si le libellé de colonne WORKDEPT de l'objet ResultSet a été utilisé, propertyName="workDept" n'est pas nécessaire si le libellé de colonne WORKDEPT existe dans l'objet ResultSet. La propriété WORKDEPT est créée par l'annotation @Column (name = "WORKDEPT") dans le bean Employee.


Commentaires