Annotations dans les beans

Vous pouvez utiliser des annotations dans les beans pour remplacer les mappages vers les colonnes par défaut. Les annotations peuvent également indiquer si une propriété correspond à une colonne générée dans la table de base de données ou la vue correspondante.

Annotations de niveau de propriété

pureQuery reconnaît les annotations de niveau de propriété uniquement pour les propriétés publiques et les méthodes publiques get() ou set(). Il ne reconnaît pas ces annotations sur des propriétés 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--(--nom--=--nom_de_colonne--+------------------------+-><
                                       '-table--=--nom_de_table-'   

Indique la colonne SQL dans un objet de base de données mappé par une propriété. Cette annotation est utilisable uniquement pour les propriétés et 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'attribut 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 attributs name et table de l'annotation. Si l'association du nom de table et de colonne existent également en double, vous ne pouvez pas utiliser l'annotation @Column. Vous devez alors utiliser une clause AS pour votre requête.

    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 set() pour les propriétés correspondantes dans les beans contenant les résultats de requête doivent inclure des annotations @Column indiquant le nom de la table dans laquelle apparaissent les deux colonnes id :
    public class JoinExample{
    
      private int a_id;
      private int b_id;
    
      @Column (name="id", table="a")
      public void setA_id (int a_id)
      {
        this.a_id = a_id;
      }
      public int getA_id ()
      {
        return a_id;
      }
    
      @Column (name="id", table="b")
      public void setB_id (int b_id)
      {
        this.b_id = b_id;
      }
      public int getB_id ()
      {
        return b_id;
      }
    }
@GeneratedKey
Indique que la colonne SQL est une colonne auto-générée. 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 de mise à jour() (pour le style de programmation intégrée) et aux méthodes dans les annotations @Update (pour le style de programmation méthode annotée).

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--")-><

Indique qu'une colonne SQL et une propriété du bean sont associées. Cette annotation contient le nom de la colonne dans la table ou la vue, qui est associé implicitement ou explicitement à sa classe, et 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--")-+--}-->

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

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

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

Exemple

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;
  }

}

Maintenant, admettons qu'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 sous-classer le bean Employee pour qu'il remplace l'annotation précédente, pour vous permettre de travailler avec 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 {...

Commentaires