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.
@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--(--propertyName--=--"--propriété--",--column--=--"--nom--")-><
>>-@ColumnOverrides--(------------------------------------------> .-,----------------------------------------------------------------------------. V | >--{----@ColumnOverride--(--propertyName--=--"--propriété--",--column--=--"--nom--")-+--}--> >--)-----------------------------------------------------------><
Le groupe d'annotations @ColumnOverride apparaît entre accolades dans les parenthèses des annotations @ColumnOverrides.
>>-@Table--(--name--=--nom_de_table-----------------------------> >--+--------------------------------+--)----------------------->< | (1) | '-------schema--=--nom_de_schéma-'
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é.
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.
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.>>-@Column--(--name--=--nom_de_colonne--+------------------------+->< '-table--=--nom_de_table-'
L'annotation @Column peut être utilisée pour deux raisons :
@Column(name="DEPTNO")
public String deptNum;
@Column(name="EMPNO")
public String getEmpNum() {
return empNum;
}
Exemple
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;
}
}
>>-@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é.
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;
…
}
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;
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---------------------------------------------------------><
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--(--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).
>>-@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.
@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.
@JoinPoint(value = {
@JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
@JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();
@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.
@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.
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 {...
@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;
}
@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.