Annotationen in Beans

pureQuery-Annotationen fügen Metadaten zu Beans hinzu. Sie können z. B. einen Indikator für eine Eigenschaft hinzufügen, um anzugeben, dass sie einer generierten Spalte in einer Datenbanktabelle oder Sicht entspricht. Die Metadaten der Annotation können auch die Verarbeitung der Bean beeinflussen. Sie können beispielsweise die Standardzuordnung zwischen einer Eigenschaft und einer Spalte ändern.

Annotationen können auch Metadaten enthalten, die die Optionen steuern, die vom pureQuery-Dienstprogramm StaticBinder beim Durchführen einer Bindeoperation für die Schnittstelle genutzt werden.

Annotationen auf Beanebene

Annotationen auf Beanebene gelten für die gesamte Bean. Wenn Sie eine Annotation auf Beanebene verwenden, geben Sie diese an, bevor Sie mit der Definition der Bean beginnen, wie im folgenden Beispiel gezeigt:
@ColumnOverride(propertyName="extension", column="PHONE") 
 
public class EmployeeNewCo extends Employee {...

Eine Beschreibung der in den Syntaxdiagrammen verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.

@ColumnOverride
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@ColumnOverride--(--propertyName--=--"--Eigenschaft--",--column--=--"--Name--")-><

Diese Annotation gibt eine Zuordnung zwischen einer SQL-Spalte und einer Eigenschaft der Bean an. Sie enthält den Namen einer Spalte in der Tabelle oder Sicht, die implizit oder explizit der Klasse zugeordnet ist, die die Annotation @ColumnOverride enthält, sowie den Namen der Eigenschaft, die dieser Annotation zugeordnet ist. Die von dieser Annotation angegebene Zuordnung überschreibt andere Spaltenzuordnungen für diese Eigenschaft, einschließlich der Zuordnungen, die an anderer Stelle in dieser Klasse oder in einer Superklasse definiert sind.
@ColumnOverrides
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@ColumnOverrides--(------------------------------------------>

      .-,-------------------------------------------------------------------------------.      
      V                                                                                 |      
>--{----@ColumnOverride--(--propertyName--=--"--Eigenschaft--",--column--=--"--Name--")-+--}-->

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

Diese Annotation gibt ein Array von @ColumnOverride-Annotationen an. Verwenden Sie diese Annotation, wenn Sie mehrere @ColumnOverride-Annotationen angeben müssen.

Das Array mit den @ColumnOverride-Annotationen steht in geschweiften Klammern innerhalb der runden Klammern für die Annotation @ColumnOverrides.

@Table
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@Table--(--name--=--Tabellenname----------------------------->

>--+-----------------------------+--)--------------------------><
   |  (1)                        |      
   '-------schema--=--Schemaname-'      

Anmerkungen:
  1. schema wird derzeit ignoriert.

Dies ist eine auf Klassenebene angegebene optionale Annotation, die einen Standardtabellennamen für alle Eigenschaften in den Beans angibt. Die Annotation ist nicht erforderlich, wenn Sie eine Gruppe verschachtelter Beans für SQL-Anweisungen mit Joins erstellen. Die Annotation vereinfacht jedoch die Definition von Beans.

Der Standardtabellenname kann durch einen Tabellennamen überschrieben werden, der in einer @Column-Annotation angegeben wird.

Die Annotation @Table gibt keinen Standardtabellennamen für @JoinColumn-Annotationen an.

Im Gegensatz zu @ColumnOverride und @ColumnOverrides in der integrierten Darstellung wird die Annotation @Table sowohl in der DAO-Darstellung als auch in der integrierten Darstellung von Unterklassen übernommen.

Annotationen auf Eigenschaftenebene

pureQuery erkennt Annotationen auf Eigenschaftenebene nur bei öffentlichen Feldern und bei den öffentlichen Methoden get() oder set(). Bei privaten oder geschützten Feldern werden diese Annotationen nicht erkannt.

Eine Beschreibung der in diesem Syntaxdiagramm verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.

@Column
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@Column--(--name--=--Spaltenname--+------------------------+-><
                                     '-table--=--Tabellenname-'   

Diese Annotation gibt die SQL-Spalte in einem Datenbankobjekt an, dem eine Eigenschaft zugeordnet ist. Sie können diese Annotation nur bei öffentlichen Feldern und Methoden verwenden. Wird sie anderweitig verwendet, wird sie von pureQuery ignoriert.

Sie können die Annotation @Column aus den folgenden beiden Gründen verwenden:

  • Der Name einer SQL-Spalte und der Name einer Eigenschaft in einer Bean stimmen bei einer von Groß-/Kleinschreibung unabhängigen Suche nicht überein. In dieser Situation würden Sie lediglich das Element name der Annotation verwenden.
    @Column(name="DEPTNO") 
    public String deptNum;
    @Column(name="EMPNO") 
    public String getEmpNum() {
        return empNum; 	
    }
  • Ein Abfrageergebnis aus einem Join von Tabellen enthält mindestens zwei Spalten mit identischem Namen. In dieser Situation verwenden Sie sowohl das Element name als auch das Element table der Annotation. Wenn die Kombination aus Tabellenname und Spaltenname ebenfalls doppelt vorliegt, müssen Sie eine Klausel AS in Ihrer SQL-Abfrage verwenden, damit die Spaltenkennungen eindeutig sind.

    Beispiel

    Angenommen, Ihre Anwendung führt die folgende einfache Abfrage aus:
    	select a.col1, b.col1 from a, b where a.id=b.id;
    Die Methoden setA_col1 und setB_col1 für die entsprechenden Eigenschaften in den Beans, die die Abfrageergebnisse aufnehmen, benötigen @Column-Annotationen, die den Namen der Tabelle angeben, in der die beiden Spalten col1 auftreten:
    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
Diese Annotation gibt an, dass die Spalte eine automatisch generierte Spalte ist. Dies bedeutet, dass der Wert bei INSERT- und UPDATE-Operationen automatisch von der Datenbank zugeordnet wird.
Wenn eine Bean, die diese Annotation enthält, als einziger Parameter für eine INSERT- oder UPDATE-Operation mit einer mit Annotationen versehenen Methode bereitgestellt wird oder die Datenschnittstellenmethode int update(String sql, Object... parameters) definiert hat, werden die mit Annotationen versehenen Eigenschaften aktualisiert, bevor die Steuerung an Ihre Anwendung zurückgegeben wird.
Achtung: Wenn Sie mindestens zwei Beans als Eingabeparameter an eine Aktualisierungsoperation übergeben und mindestens eine Annotation @GeneratedKey in jeder Bean vorhanden ist, schlägt die Aktualisierungsoperation fehl. Diese Einschränkung gilt für die Methode update() (bei der integrierten Darstellung) und für Methoden in @Update-Annotationen (bei der DAO-Darstellung).
@Format
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@Format--(--fomatterClass--=--Formatierungsklasse------------>

>--+---------------------------------------------+--)----------><
   '-, -formattingOptions--=--Musterzeichenfolge-'      

Diese Annotation gibt die Klasse an, die das Formatierungsprogramm, das für die Ausführung erforderlicher Konvertierungen aufgerufen wird, sowie die Formatierungsoptionen enthält. Sie können diese Annotation in einem Feld in einem Bean-Objekt verwenden, das als Eingabe oder Ausgabe für eine pureQuery-Methode angegeben ist. Dies gilt sowohl für die DAO-Darstellung als auch für die integrierte Darstellung.

Wenn das Element formatterClass eine vom Benutzer bereitgestellte Konstruktormethode angibt, muss diese Klasse eine Konstruktormethode bereitstellen, die ein einziges Zeichenfolgeargument erhält. Die an diesen Konstruktor übergebene Zeichenfolge ist der formattingOptions-Zeichenfolgewert.
formattingOptions
Dieser Zeichenfolgewert informiert die Formatierungsklasse über alle Spezifikationen für die Durchführung der Formatierungs- oder Parsingoperationen. Dieser kann jedem Format vorliegen, das für die Formatierungsklasse erforderlich ist. Beispielsweise verwenden die von pureQuery bereitgestellten Musterformatierungsklassen ein Format 'Schlüssel=Wert', wobei die einzelnen Spezifikationspaare durch ein Semikolon getrennt sind.
Die vom Benutzer bereitgestellte Formatierungsklasse muss auch die folgenden beiden Methoden bereitstellen:
public String format(Object)
Die Methode wird vom generierten Code nach dem Abruf einer Zeile aufgerufen. Sie konvertiert den Ergebniswert aus der SQL-Abfrage in das korrekte Zeichenfolgeformat, das im mit Annotationen versehenen Feld im Methodenrückgabeobjekt erwartet wird.
public Object parse(String)
Die Methode wird vom generierten Code für die Festlegung der Eingabeparameter für eine SQL-Anweisung verwendet. Sie erhält den Parameter im Zeichenfolgeformat, parst ihn und gibt ein Objekt des korrekten Typs für den Zielparameter der SQL-Anweisung zurück.
Die pureQuery-API stellt die folgenden Formatierungsklassen für die Datumsformatierung bereit:
  • com.ibm.pdq.runtime.data.formatters.DateFormatter
  • com.ibm.pdq.runtime.data.formatters.TimeFormatter
  • com.ibm.pdq.runtime.data.formatters.TimestampFormatter

Diese Formatierungsklasse konvertiert Zeichenfolgefelder in die korrekten JDBC-Typen für Datum/Uhrzeit für Eingabevariablen und konvertiert und formatiert die zurückgegebenen JDBC-Typen für die Ausgabe in Zeichenfolgevariablen.

Im folgenden Beispiel wird das Feld 'startDate' formatiert:

class MyBean {
…
@Format(formatter=com.ibm.pdq.Dateformatter.class, formattingOtions=”style=LONG; 
   timezone=UTC”)
String startDate;
…
}
@Required
Wenn diese Annotation in einem Feld angegeben wird, das als Eingabe für einen SQL-Parameter verwendet wird, gibt sie an, dass das Feld einen Wert ungleich null enthalten muss. Dies gilt sowohl für die DAO-Darstellung als auch für die integrierte Darstellung.

Die Annotation gilt nicht für Java-Basiselementfelder, da Java-Basiselemente keinen Nullwert darstellen können.

Wenn die Annotation @Required nicht angegeben wird, werden Java-Nullwerte in Eingabeparametern standardmäßig erkannt und der Wert der entsprechenden Hostvariablen wird auf SQL NULL gesetzt.

Wenn die Annotation @Required in einem Feld angegeben wird, das als Eingabe für einen SQL-Parameter verwendet wird, und dieses Feld beim Zugriff auf das Feld einen Java-Nullwert enthält, wird von pureQuery eine Ausnahmebedingung ausgelöst und die SQL-Operation wird nicht versucht.

Beim folgenden Beispiel wird vorausgesetzt, dass der Wert 'customerAddress' einen Wert ungleich null enthalten muss.

@Required
String customerAddress;

Annotationen für Gruppen verschachtelter Beans, die in Verbindung mit Tabellenjoins verwendet werden

Bei einer SQL-Abfrage mit Tabellenjoins können Sie eine Gruppe verschachtelter Beans erstellen, die Daten aus der Abfrage zurückgeben. Die Hierarchie der Beans bildet die relationale Struktur der Tabellen und Daten in der Datenbank nach. Sie geben pureQuery-Annotationen mit verschachtelten Beans an, um die Tabellen- und Spaltenbeziehungen anzugeben. pureQuery Runtime füllt die Beans mit den Ergebnissen der Abfrage. Informationen zu verschachtelten Beans, die in Verbindung mit Tabellenjoins verwendet werden, finden Sie in Verschachtelte Beans und SQL-Abfragen mit Tabellenjoins.

Annotationen auf Eigenschaftenebene

@Id
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@Id---------------------------------------------------------><

Diese Annotation gibt an, dass die mit Annotationen versehene Eigenschaft eine Identitätsspalte darstellt, die von pureQuery Runtime verwendet wird, um die Gleichheit zwischen Beans derselben Klasse zu bestimmen. Diese Annotation wird für Eigenschaften einer Bean verwendet. Identitätsspalten sind Spalten, die die untergeordneten Beans mit der übergeordneten Bean verknüpfen. In der Bean der höchsten Ebene muss mindestens eine @Id-Annotation angegeben werden, um die Generierung verschachtelter Beans durch pureQuery Runtime zu ermöglichen. Die übereinstimmende Spalte in der Datenbank muss nicht als Primär- oder Fremdschlüsselspalte deklariert werden.

Die Annotation @Column kann in Verbindung mit der Annotation @Id verwendet werden, um den Spaltennamen und den Tabellennamen anzugeben, die das ResultSet-Objekt der Schlüsselspalte zuordnen.

In untergeordneten Beans kann entweder die Annotation @Id oder eine Annotation @JoinPoint verwendet werden, um Identitätsspalten zu definieren, die eine übergeordnete Bean mit einer untergeordneten Bean verknüpfen. Wenn beide angegeben sind, werden die Informationen aus der Annotation @JoinPoint verwendet und die Annotation @Id wird ignoriert. Die Annotation @JoinPoint wird in der übergeordneten Bean in einem Verweis auf die Bean angegeben. Die Annotation @Id wird dagegen in der Bean selbst angegeben.

Wenn die Bean einen Verbundschlüssel hat, müssen mehrere @Id-Annotationen in der untergeordneten Bean angegeben werden oder die Schlüssel müssen mit einer @JoinPoint-Annotation in der übergeordneten Bean angegeben werden. In der Annotation @JoinPoint muss ein Schlüssel durch eine Annotation @JoinColumn mit dem Element propertyName angegeben werden.

pureQuery Runtime prüft die Bean-Eigenschaften mit @Id-Annotationen, um bei der Verarbeitung verschachtelter Beans zu ermitteln, ob Beans gleich sind. Wenn alle Eigenschaften mit @Id-Annotationen gleich sind, werden die Beans als gleich betrachtet. Bean-Eigenschaft mit @Id-Annotationen müssen keine Primär- oder Fremdschlüssel in der Datenbank sein. Sie müssen jedoch ausreichen, um die Gleichheit zwischen Beans derselben Klasse zu bestimmen.

@JoinColumn
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@JoinColumn--(--name--=--Spaltenname------------------------->

>--+-----------------------+------------------------------------>
   '-table--=--Spaltenname-'   

>--+-----------------------------------+--)--------------------><
   '-propertyName--=--Eigenschaftsname-'      

Diese Annotation gibt eine Spalte eines ResultSet-Objekts als Identitätsspalte einer untergeordneten Bean an, wenn der Eigenschaftsname der übergeordneten Bean nicht der Spaltenkennung eines ResultSet-Objekts oder dem Tabellennamen entspricht. Diese Annotation wird in der übergeordneten Bean als Annotation für die untergeordneten Beans angegeben. Die untergeordneten Beans sind entweder eine einzelne Bean oder eine Liste von Beans.

Eine Annotation @JoinColumn kann nur in einer Annotation @JoinPoint angegeben werden.

Wenn Sie eine leere Zeichenfolge ("") als Wert für das Element name angeben, inaktiviert pureQuery Runtime die Unterstützung für die Generierung verschachtelter Beans für diese Eigenschaft, ohne eine Warnung zu generieren, dass die Eigenschaft nicht übereinstimmt. Sie können eine leere Zeichenfolge in einer Unterklasse angeben, wenn Sie nicht wollen, dass eine bestimmte untergeordnete Bean oder Liste von Beans gefüllt wird.

Wenn eine @JoinPoint-Annotation eine @JoinColumn-Annotation enthält, die mindestens eine @Id-Annotation in einer untergeordneten Bean außer Kraft setzt, ignoriert pureQuery Runtime alle @Id-Annotationen in der untergeordneten Bean. Bei einer untergeordneten Bean wird die Annotation in den folgenden Situationen nicht ignoriert:
  • Die untergeordnete Bean hat nur eine Annotation @Id, die für eine Eigenschaft angegeben ist.
  • Die Annotation @JoinColumn der übergeordneten Bean ändert nur die Spaltenkennung des ResultSet-Objekts und optional den Tabellennamen. Die Annotation ändert nicht die Eigenschaft, die mit der Annotation @Id der untergeordneten Bean definiert ist.
@JoinPoint
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@JoinPoint--------------------------------------------------->

>--+-------------------------------------------------------------------------------------------+-><
   '-(--+----------------------------------------------------+--+-------------------------+--)-'   
        '-+------------+--Array_von_@JoinColumn-Annotationen-'  '-columnPrefix--=--Präfix-'        
          +-joinCol--=-+                                                                           
          '-value--=---'                                                                           

In der Bean der höchsten Ebene, d. h. der Bean, die der Rückgabewert der Methode oder integrierten API ist, muss mindestens eine @JoinPoint-Annotation angegeben werden. Die Annotation ermöglicht die Generierung einer Gruppe verschachtelter Beans durch pureQuery Runtime.

Die Annotation kann nur für eine Eigenschaft definiert werden, die eine Bean oder eine Liste von Beans enthält. Die optionalen @JoinColumn-Annotationen definieren die Spalten des ResultSet-Objekts, die den Identitätsspalten einer untergeordneten Bean zugeordnet werden. Das optionale Element columnPrefix gibt ein Spaltenpräfix an, das jeder Eigenschaft in der untergeordneten Bean hinzugefügt werden soll. Wenn die untergeordnete Bean einen Verbundschlüssel hat, müssen mehrere Spalten des ResultSet-Objekts als Schlüsselspalte angegeben werden.

Die Annotation kann nur für eine Eigenschaft definiert werden, die eine Bean oder eine Liste von Beans enthält. Wenn keines der optionalen Elemente (ein Array von @JoinColumn-Annotationen oder ein Element columnPrefix) angegeben ist, werden alle ResultSet-Zuordnungen und Identitätsspaltendefinitionen von der untergeordneten Bean übernommen.

Ein Array von @JoinColumn-Annotationen ist optional und bezieht sich auf die Eigenschaften der untergeordneten Bean. Arrays aus mehreren @JoinColumn-Annotationen müssen in geschweifte Klammern ({ }) eingeschlossen werden.

Wenn keine @JoinColumn-Annotationen angegeben sind, verwendet pureQuery Runtime die @Id-Annotationen der referenzierten untergeordneten Bean, um zu ermitteln, welche ResultSet-Spalten den Identitätsspalten der untergeordneten Bean zugeordnet werden. Wenn eine untergeordnete Bean nicht mindestens eine @Id-Annotation enthält, wird eine Warnung generiert und die untergeordnete Bean wird ignoriert.

Das Element joinCol und das Element value schließen sich gegenseitig aus. Nur eines der beiden kann angegeben werden, nicht jedoch beide zusammen. Das Element joinCol ist erforderlich, wenn das Element columnPrefix angegeben ist.

Der Wert des Elements columnPrefix gibt eine Zeichenfolge an, die jeder Eigenschaft in der untergeordneten Bean vorangestellt werden soll. Mit dem Präfix generiert pureQuery Runtime eindeutige Klassen und Eigenschaften. Das Präfix ermöglicht es, dass dieselbe Bean-Klasse in unterschiedlichen Ebenen oder in derselben Ebene einer verschachtelten Bean-Struktur ohne Rekursion verwendet wird. Stellen Sie sicher, dass diese Eigenschaften mit Präfix eindeutig sind. Sobald ein Präfix zu einer Klasse hinzugefügt wird, wird dieses Präfix auf alle untergeordneten Beans und die Eigenschaften der Beans der mit Präfix versehenen Klasse angewendet. Präfixe sind kumulativ. Die Verschachtelung kann beliebig tief fortgesetzt werden. Der Wert des Elements columnPrefix wird nur auf die untergeordnete Bean angewendet und nicht auf die in den @JoinColumn-Annotationen der übergeordneten Bean definierten Spaltenkennungen.

Spaltenpräfixe werden nur angewendet, wenn die Abfrage Spalten zurückgibt, die die untergeordnete Bean füllen.

Im folgenden Beispiel mit der Annotation @JoinPoint enthält das ResultSet-Objekt Daten, die von einer SQL-Abfrage zurückgegeben werden. Die Abfrage verknüpft eine Tabelle DEPARTMENT mit einer Tabelle EMPLOYEE. Der Spaltenname für die Abteilungsnummer lautet DEPTNO und der Spaltenname für die Personalnummer lautet EMPNO. Die Bean 'Department' würde hierfür wie folgt codiert:
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

Die erste @JoinColumn-Annotation ordnet die Spalte DEPTNO aus der Tabelle DEPARTMENT der Eigenschaft empDepartment in der Bean 'Employee' zu.

Wenn Sie angegeben hätten, dass die Spaltenkennung WORKDEPT aus dem ResultSet-Objekt verwendet werden soll, müssten Sie das Element propertyName = "empDepartment" nicht angeben, wenn die Spaltenkennung WORKDEPT im ResultSet-Objekt vorhanden ist. Die Eigenschaft WORKDEPT wurde von der Annotation @Column (name = "WORKDEPT") in der Bean 'Employee' erstellt.

Die @JoinPoint-Annotationen könnten mit dem Element value oder joinCol angegeben worden sein. Im folgenden Beispiel wird das Element value verwendet:
@JoinPoint(value = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();
Auch in diesem Beispiel wird die untergeordnete Bean aus dem vorherigen Beispiel verwendet. Nehmen wir an, dass später in derselben übergeordneten Bean eine weitere @JoinPoint-Annotation für eine Liste von Project-Beans angegeben ist und dass die Bean 'Project' auch eine Liste von Employee-Beans definiert (in diesem Fall eine Liste von Mitarbeitern, die am Projekt mitarbeiten). Wenn das Element columnPrefix in der Annotation @JoinPoint für die Liste von Employee-Beans nicht angegeben ist, wird die spätere Verwendung der Bean 'Employee' in der Bean 'Project' ignoriert und die Liste von Mitarbeitern, die am Projekt mitarbeiten, wird nicht gefüllt, selbst wenn das ResultSet-Objekt die Daten enthält. Sie geben das Element columnPrefix für List<Employee> entweder in der Bean 'Department' oder in der Bean 'Project' an. Im folgenden Beispiel wird das Element columnPrefix in der Annotation @JoinPoint in der Bean 'Department' angegeben:
@JoinPoint(columnPrefix = "DE", joinCol = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

Ein Spaltenpräfix DE für Abteilungsmitarbeiter wird allen Eigenschaften der Bean 'Employee' vorangestellt und die Zeichenfolge DE würde (über die Klausel AS) allen Mitarbeiterspalten im ResultSet-Objekt hinzugefügt, die für die Abteilungsliste von Employee-Beans vorgesehen sind.

Das Präfix wird auch auf alle untergeordneten Beans in dieser Bean 'Employee' angewendet.

Wenn die Bean 'Employee' z. B. eine untergeordnete Bean 'Department' enthält, würde allen Eigenschaften der Bean 'Department' in dieser Bean 'Employee' die Zeichenfolge DE vorangestellt.

Das Voranstellen wird für alle im ResultSet-Objekt vorhandenen Ebenen fortgesetzt. Der zweiten Ebene der Liste von Employee-Beans in der untergeordneten Bean 'Department' würde DEDE vorangestellt.

Das Präfix wird auf alle untergeordneten Beans in dieser Bean 'Employee' angewendet, nicht jedoch auf alle Employee-Beans in der verschachtelten Bean-Struktur. Beispielsweise wird das Präfix nicht in der Liste von Employee-Beans in der Bean 'Project' verwendet.

Wenn Sie eine übergeordnete Bean haben, die mehrmals dieselbe untergeordnete Bean enthält, können Sie die Annotation @JoinPoint mit dem Element columnPrefix verwenden, um anzugeben, welche Spalten der untergeordneten Bean zugeordnet werden sollen. Im folgenden Beispiel wird das Element columnPrefix verwendet:
@JoinPoint
public List<Emp> emps;
@JoinPoint(columnPrefix="m_")
public Emp manager;

Durch Angabe des Elements columnPrefix="m_" werden die Spalten aus der Tabelle EMPLOYEE, denen m_ vorangestellt ist, dem Feld 'Emp manager' zugeordnet.

Beispiel für Annotationen

Angenommen, Sie wollen eine Bean definieren, die die Datensätze enthalten soll, die beim Abfragen der Tabelle HRDEPT.EMPLOYEE zurückgegeben werden.
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))
Einige der Spaltennamen sind abgekürzt oder entsprechen nicht den Java-Namenskonventionen.

Die folgende Definition für eine Bean 'Employee' verwendet @Column-Annotationen, um aussagekräftigere Namen für die Benutzer von Objekten der Klasse com.company.Employee bereitzustellen.

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

}

Wenn eine Anwendung für eine Datenbank mit leicht abweichendem Schema ausgeführt wird, wird die Tabelle wie folgt definiert:

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

Sie können eine Unterklasse für die Bean 'Employee' erstellen, um die vorherige Annotation zu überschreiben, damit mit der neuen Tabellendefinition gearbeitet werden kann. Der Anfang der Unterklasse könnte wie dieses Beispiel aussehen:

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

Beispiel einer Gruppe verschachtelter Beans

Im folgenden Beispiel ist der Primärschlüssel der Tabelle EMPLOYEE die Spalte EMPNO, die die Mitarbeiter-ID enthält, und die Spalte WORKDEPT enthält die Nummer der Abteilung, für die der Mitarbeiter arbeitet. Die Bean 'Employee' könnte die folgende Definition haben:
@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;
}
Im ResultSet-Objekt lautet der Spaltenname für die Abteilungsnummer DEPTNO und der Spaltenname für die Personalnummer lautet EMPNO. Die Bean 'Department' könnte hierfür die folgende Annotation @JoinPoint haben:
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="workDept"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

In der ersten Annotation @JoinColumn wird die Spalte DEPTNO aus der Tabelle DEPARTMENT der Eigenschaft 'workDept' in der Bean 'Employee' zugeordnet. Wenn die Spaltenkennung WORKDEPT aus dem ResultSet-Objekt verwendet worden wäre, wäre propertyName="workDept" nicht erforderlich, wenn die Spaltenkennung WORKDEPT im ResultSet-Objekt enthalten ist. Die Eigenschaft WORKDEPT wird von der Annotation @Column (name = "WORKDEPT") in der Bean 'Employee' erstellt.


Feedback