Annotationen in Beans

Sie können Annotationen in Beans verwenden, um die Standardzuordnung von Spalten zu überschreiben. Annotationen können außerdem angeben, ob eine Eigenschaft einer generierten Spalte in der entsprechenden Datenbanktabelle oder Sicht entspricht.

Annotationen auf Eigenschaftenebene

pureQuery erkennt Annotationen auf Eigenschaftenebene nur bei allgemein zugänglichen Eigenschaften und bei den allgemein zugänglichen Methoden get() oder set(). Bei privaten oder geschützten Eigenschaften 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-'   

Gibt die SQL-Spalte in einem Datenbankobjekt an, der eine Eigenschaft zugeordnet ist. Sie können diese Annotation nur bei allgemein zugänglichen Eigenschaften 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 werden bei einer von Groß-/Kleinschreibung unabhängigen Suche nicht übereinstimmen. In dieser Situation würden Sie lediglich das Attribut 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 Attribut name als auch das Attribut table der Annotation. Wenn die Kombination aus Tabellenname und Spaltenname ebenfalls doppelt vorliegt, können Sie die Annotation @Column nicht verwenden. Stattdessen müssen Sie eine Klausel AS in Ihrer Abfrage verwenden.

    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 set() für die entsprechenden Eigenschaften in den Beans, die die Abfrageergebnisse aufnehmen, benötigen die Annotationen @Column, die den Namen der Tabelle angeben, in der die beiden Spalten id auftreten:
    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
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() (für den integrierten Programmierstil) und für Methoden in @Update-Annotationen (für den Programmierstil mit Annotationsmethode).

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

Gibt eine Zuordnung zwischen einer SQL-Spalte und einer Eigenschaft der Bean an. Diese Annotation enthält den Namen einer Spalte in der Tabelle oder Sicht, die implizit oder explizit der übergeordneten Klasse zugeordnet ist, 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--")-+--}-->

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

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

Beachten Sie, dass das Array mit den @ColumnOverride-Annotationen in geschweiften Klammern innerhalb der runden Klammern für die Annotation @ColumnOverrides steht.

Beispiel

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

}

Angenommen, es wird eine Anwendung auf einer Datenbank mit leicht abweichendem Schema ausgeführt. Die Tabelle wird 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' bilden, um die vorherige Annotation zu überschreiben, damit mit der neuen Tabellendefinition gearbeitet werden kann. Der Anfang der Unterklasse könnte wie folgt aussehen:

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

Feedback