Bean의 어노테이션

pureQuery 어노테이션이 메타데이터를 Bean에 추가합니다. 예를 들어, 특성에 표시기를 추가하여 표시기가 데이터베이스 테이블 또는 뷰의 생성 열에 해당함을 표시할 수 있습니다. 어노테이션 메타데이터는 또한 특성 및 열 간의 기본 맵핑 변경과 같은 Bean의 처리에 영향을 미칠 수 있습니다.

어노테이션은 또한 pureQuery StaticBinder가 인터페이스에서 바인드 조작을 수행할 때 사용하는 옵션을 제어하는 메타데이터를 포함할 수도 있습니다.

Bean 레벨 어노테이션

Bean 레벨 어노테이션은 전체 Bean에 적용됩니다. Bean 레벨 어노테이션을 사용할 때 다음 예와 같이 Bean의 정의를 시작하기 전에 이 어노테이션을 지정해야 합니다.
@ColumnOverride(propertyName="extension", column="PHONE") 
 
public class EmployeeNewCo extends Employee {...

구문 다이어그램에서 사용되는 규칙을 이해하려면 구문 다이어그램 읽는 방법을 참조하십시오.

@ColumnOverride
구문 도표 읽기시각적 구문 도표 생략
>>-@ColumnOverride--(--propertyName--=--"--property--",--column--=--"--name--")-><

이 어노테이션은 Bean의 SQL 열과 특성 간의 연관을 지정합니다. 이는 포함 클래스와 내재적 또는 명시적으로 연관된 테이블 또는 보기의 열 이름과, 이 어노테이션이 맵핑하는 특성의 이름을 포함합니다. 이 어노테이션으로 표시된 맵핑은 이 클래스의 다른 위치 또는 수퍼클래스에 정의된 맵핑을 포함하여 이 특성에 대한 다른 컬럼 맵핑보다 우선합니다.
@ColumnOverrides
구문 도표 읽기시각적 구문 도표 생략
>>-@ColumnOverrides--(------------------------------------------>

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

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

이 어노테이션은 @ColumnOverride 어노테이션의 배열을 지정합니다. 두 개 이상의 @ColumnOverride 어노테이션을 지정해야 하는 경우 이 어노테이션을 사용하십시오.

@ColumnOverride 어노테이션의 배열이 @ColumnOverrides 어노테이션의 괄호 안의 중괄호 안에 표시됩니다.

@Table
구문 도표 읽기시각적 구문 도표 생략
>>-@Table--(--name--=--name_of_table---------------------------->

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

주:
  1. schema는 현재 무시됩니다.

Bean의 모든 특성에 대해 기본 테이블 이름을 지정하는 클래스 레벨로 지정된 선택적 어노테이션입니다. 어노테이션은 결합을 포함하는 SQL문의 중첩된 Bean을 작성할 때 필요하지 않습니다. 그러나 어노테이션은 Bean 정의를 단순화합니다.

@Column 어노테이션에서 지정된 테이블 이름으로 기본 테이블 이름을 겹쳐쓸 수 있습니다.

@Table 어노테이션은 @JoinColumn 어노테이션의 기본 테이블 이름을 지정하지 않습니다.

인라인 스타일의 @ColumnOverride 및 @ColumnOverrides와 달리 @Table 어노테이션은 데이터 액세스 오브젝트(DAO) 스타일 및 인라인 스타일 모두에서 서브클래스에 의해 상속됩니다.

특성 레벨 어노테이션

pureQuery는 공용 필드 및 공용 get() 또는 set() 메소드에서만 특성 레벨 어노테이션을 인식합니다. 이는 개인용 또는 보호 필드에서 해당 어노테이션을 인식하지 않습니다.

구문 다이어그램에서 사용되는 규칙을 이해하려면 구문 다이어그램 읽는 방법을 참조하십시오.

@Column
구문 도표 읽기시각적 구문 도표 생략
>>-@Column--(--name--=--name_of_column--+-------------------------+-><
                                        '-table--=--name_of_table-'   

이 어노테이션은 특성이 맵핑되는 데이터베이스 오브젝트의 SQL 열을 지정합니다. 이 어노테이션은 공용 필드 및 공용 메소드에서만 사용할 수 있습니다. 다른 위치에 사용하는 경우 pureQuery는 이를 무시합니다.

다음 두 가지 이유 중 하나로 @Column 어노테이션을 사용할 수 있습니다.

  • 대소문자를 구분하지 않은 검색에서는 Bean의 특성 이름과 SQL 컬럼 이름이 일치하지 않습니다. 이 상황에서는 어노테이션의 name 요소만 사용할 수 있습니다.
    @Column(name="DEPTNO") 
    public String deptNum;
    @Column(name="EMPNO") 
    public String getEmpNum() { 		
    return empNum; 	
    }
  • 테이블 조인의 쿼리 결과에 동일한 이름을 갖는 두 개 이상의 컬럼이 있습니다. 이 상황에서는 어노테이션의 nametable 요소를 모두 사용합니다. 테이블 이름과 열 이름의 조합도 중복되는 경우 열 레이블이 고유하도록 SQL 쿼리에서 AS 절을 사용해야 합니다.

    예제

    예를 들어, 애플리케이션이 다음의 단순 쿼리를 실행한다고 합시다.
    	select a.col1, b.col1 from a, b where a.id=b.id;
    쿼리 결과를 보유하는 Bean에 있는 해당 특성의 setA_col1setB_col1 메소드에는 두 col1 열이 표시되는 테이블의 이름을 제공하는 @Column 어노테이션이 필요합니다.
    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
이 어노테이션은 SQL 열이 자동 생성된 열임을 표시합니다. 즉, 값이 INSERT 또는 UPDATE 조작 중에 데이터베이스에 의해 자동으로 지정됩니다.
이 어노테이션을 포함하는 Bean이 어노테이션이 있는 메소드 또는 int update(String sql, Object... parameters)에 정의된 Data 인터페이스 메소드를 사용하는 INSERT 또는 UPDATE 조작에 대한 유일한 매개변수로 제공되는 경우, 제어가 애플리케이션에 리턴되기 전에 어노테이션이 있는 특성이 업데이트됩니다.
주의: 둘 이상의 Bean을 입력 매개변수로 업데이트 조작에 전달하고 각각의 Bean에 하나 이상의 @GeneratedKey 어노테이션이 있는 경우, 업데이트 조작은 성공하지 못합니다. 이 제한은 update() 메소드(인라인 메소드 스타일의 경우) 및 @Update 어노테이션의 메소드(DAO 스타일의 경우)에 적용됩니다.
@Format
구문 도표 읽기시각적 구문 도표 생략
>>-@Format--(--fomatterClass--=--formatter_class---------------->

>--+-----------------------------------------+--)--------------><
   '-, -formattingOptions--=--pattern-string-'      

이 어노테이션은 필요한 변환을 수행하기 위해 호출되는 포맷터를 포함하는 클래스 및 포맷 옵션을 지정합니다. pureQuery 메소드에서 입력 또는 출력으로 지정되는 Bean 오브젝트의 필드에서 이 어노테이션을 사용할 수 있습니다. 이는 DAO 스타일 및 인라인 스타일 모두에 적용됩니다.

formatterClass 요소가 사용자 제공 포맷터 클래스를 지정하는 경우 해당 클래스는 단일 문자열 인수를 취하는 생성자 메소드를 제공해야 합니다. 이 생성자에 전달된 문자열은 formattingOptions 문자열 값입니다.
formattingOptions
문자열 값은 포맷터 클래스에 형식화 수행 또는 구문 분석 조작에 대한 특정 항목을 알립니다. 이는 포맷터 클래스가 필요로 하는 모든 양식이 될 수 있습니다. 예를 들어, pureQuery가 제공하는 샘플 포맷터 클래스는 세미콜론으로 구분된 개별 쌍 스펙이 있는 key=value 형식을 사용합니다.
사용자 제공 포맷터 클래스는 또한 다음 두 메소드를 제공해야 합니다.
public 문자열 형식(오브젝트)
메소드는 행이 검색된 후에 생성된 코드로 호출됩니다. 이는 SQL 쿼리의 결과 값을 메소드 리턴 오브젝트의 어노테이션이 있는 필드에서 예상되는 적절한 문자열 형식으로 변환합니다.
public 오브젝트 구문 분석(문자열)
메소드는 SQL문에서 입력 매개변수 설정을 위해 생성된 코드로 호출됩니다. 이는 문자열 형식의 매개변수를 취하고 이를 구문 분석하여 대상 SQL문 매개변수에 대해 적절한 유형의 오브젝트를 리턴합니다.
pureQuery API는 날짜를 형식화하기 위해 다음 포맷터 클래스를 제공합니다.
  • com.ibm.pdq.runtime.data.formatters.DateFormatter
  • com.ibm.pdq.runtime.data.formatters.TimeFormatter
  • com.ibm.pdq.runtime.data.formatters.TimestampFormatter

이 포맷터 클래스는 문자열 필드를 입력 변수에 적절한 JDBC DateTime 유형으로 변환하며 리턴된 JDBC 유형을 출력에 대한 문자열 변수로 변환 및 형식화합니다.

다음 예는 시작 날짜 필드를 형식화합니다.

class MyBean {
…
@Format(formatter=com.ibm.pdq.Dateformatter.class, formattingOtions=”style=LONG; 
   timezone=UTC”)
String startDate;
…
}
@Required
SQL 매개변수에 대한 입력으로 사용되는 필드에 지정한 경우 어노테이션은 필드가 널(NULL)이 아닌 값을 포함해야 함을 표시합니다. 이는 데이터 액세스 오브젝트 및 인라인 스타일 메소드 모두에 적용됩니다.

Java 기본은 널(NULL) 값을 나타낼 수 없으므로 어노테이션은 Java 기본 필드에 적용되지 않습니다.

@Required 어노테이션이 지정되지 않는 경우 기본 동작은 입력 매개변수의 Java 널(NULL)을 인식하고 해당 호스트 변수 값을 SQL 널(NULL)로 설정하는 것입니다.

@Required 어노테이션이 SQL 매개변수에 대한 입력으로 사용되는 필드에 지정되고 필드가 액세스될 때 해당 필드가 Java 널(NULL) 값을 포함하는 경우 pureQuery가 예외를 처리하며 SQL 조작이 시도되지 않습니다.

다음 예에서는 customerAddress 값에 널(NULL)이 아닌 값이 포함되어야 합니다.

@Required
String customerAddress;

테이블 조인에 사용되는 중첩된 Bean 세트의 어노테이션

테이블 조인을 포함하는 SQL 쿼리의 경우 쿼리에서 데이터를 리턴하는 중첩된 Bean 세트를 작성할 수 있습니다. Bean의 계층 구조는 데이터베이스에서 데이터의 관계형 구조를 복제합니다. 중첩된 Bean이 있는 pureQuery 어노테이션을 지정하여 테이블 및 열 관계를 지정합니다. pureQuery Runtime은 Bean을 쿼리의 결과로 채웁니다. 테이블 조인에 사용되는 중첩된 Bean에 대한 정보는 테이블 조인을 포함하는 중첩된 Bean 및 SQL 쿼리의 내용을 참조하십시오.

특성 레벨 어노테이션

@Id
구문 도표 읽기시각적 구문 도표 생략
>>-@Id---------------------------------------------------------><

이 어노테이션은 어노테이션이 있는 특성이 동일한 클래스의 Bean 간 등식을 판별하기 위해 pureQuery Runtime이 사용하는 ID 컬럼을 나타냄을 표시합니다. 이 어노테이션은 Bean의 특성에 사용됩니다. ID 컬럼은 상위 Bean에 하위 Bean을 링크하는 열입니다. pureQuery Runtime이 중첩된 Bean을 생성할 수 있게 하려면 최소 하나의 @Id 어노테이션을 상위 레벨 Bean에 지정해야 합니다. 데이터베이스의 일치하는 열은 기본 또는 외부 키 열로 선언할 필요가 없습니다.

@Column 어노테이션을 @Id 어노테이션과 함께 사용하여 키 열에 ResultSet 오브젝트를 맵핑하는 열 이름 및 테이블 이름을 지정할 수 있습니다.

하위 Bean에서 @Id 어노테이션 또는 @JoinPoint 어노테이션을 사용하여 하위 Bean에 상위 Bean을 링크하는 ID 컬럼을 정의할 수 있습니다. 두 어노테이션이 모두 지정되면 @JoinPoint 어노테이션 정보가 사용되고 @Id 어노테이션은 무시됩니다. @JoinPoint 어노테이션은 해당 상위 Bean의 Bean에 대한 참조에 지정되고 @Id 어노테이션은 Bean 자체에 지정됩니다.

Bean에 복합 키가 있는 경우 다중 @Id 어노테이션이 하위 Bean에 지정되어야 하거나 키가 상위 Bean의 @JoinPoint 어노테이션과 함께 지정되어야 합니다. @JoinPoint 어노테이션에서 키는 propertyName 요소가 있는 @JoinColumn 어노테이션으로 지정되어야 합니다.

Bean이 중첩된 Bean을 처리할 때 Bean이 같은지 여부를 판별하기 위해 pureQuery Runtime은 @Id 어노테이션이 있는 Bean 특성을 검사합니다. @Id 어노테이션이 있는 모든 특성이 같은 경우 Bean이 같다고 간주됩니다. @Id 어노테이션이 있는 Bean 특성은 데이터베이스에서 기본 또는 키일 필요가 없으나 동일한 클래스의 Bean 간 등식을 판별하기에 충분해야 합니다.

@JoinColumn
구문 도표 읽기시각적 구문 도표 생략
>>-@JoinColumn--(--name--=--name_of_column---------------------->

>--+--------------------------+--------------------------------->
   '-table--=--name_of_column-'   

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

이 어노테이션은 상위 Bean 특성 이름이 테이블 이름 또는 ResultSet 오브젝트의 열 레이블과 일치하지 않을 때 하위 Bean의 ID 컬럼으로 ResultSet 오브젝트의 열을 지정합니다. 이 어노테이션은 하위 Bean의 어노테이션으로 상위 Bean에 지정됩니다. 하위 Bean은 단일 Bean 또는 Bean의 목록입니다.

@JoinColumn 어노테이션은 @JoinPoint 어노테이션에만 지정될 수 있습니다.

비어 있는 문자열("")을 name 요소의 값으로 지정하는 경우 pureQuery Runtime은 특성이 일치하지 않는 경고를 생성하지 않고 이 특성에서 중첩된 Bean 지원을 사용할 수 없습니다. 특정 하위 Bean 또는 Bean의 목록을 채우지 않으려는 경우 서브클래스에 비어 있는 문자열을 지정하십시오.

@JoinPoint 어노테이션이 하위 Bean에 있는 하나 이상의 @Id 어노테이션을 겹쳐쓰는 @JoinColumn 어노테이션을 포함하는 경우 pureQuery Runtime은 하위 Bean의 모든 @Id 어노테이션을 무시합니다. 하위 Bean의 경우 다음 상황에서 어노테이션이 무시됩니다.
  • 하위 Bean에는 특성에 지정된 하나의 @Id 어노테이션만 있습니다.
  • 상위 Bean @JoinColumn 어노테이션은 ResultSet 열 레이블만 수정하며 선택적으로 테이블 이름을 수정합니다. 어노테이션은 하위 Bean의 @ID 어노테이션으로 정의된 특성을 변경하지 않습니다.
@JoinPoint
구문 도표 읽기시각적 구문 도표 생략
>>-@JoinPoint--------------------------------------------------->

>--+-----------------------------------------------------------------------------------------+-><
   '-(--+--------------------------------------------------+--+-------------------------+--)-'   
        '-+------------+--array_of_@JoinColumn_annotations-'  '-columnPrefix--=--prefix-'        
          +-joinCol--=-+                                                                         
          '-value--=---'                                                                         

최소한 하나의 @JoinPoint 어노테이션이 최상위 레벨 Bean, 즉 메소드 또는 인라인 API의 리턴 값인 Bean에 지정되어야 합니다. 어노테이션은 pureQuery Runtime에 의한 중첩된 Bean 세트의 생성을 사용 가능하게 합니다.

어노테이션은 Bean 또는 Bean 목록을 포함하는 특성에만 정의될 수 있습니다. 선택적 @JoinColumn 어노테이션은 하위 Bean의 ID 컬럼에 맵핑되는 ResultSet 오브젝트 열을 정의합니다. 선택적 columnPrefix 요소는 하위 Bean의 각 특성에 추가될 열 접두부를 지정합니다. 하위 Bean에 복합 키가 있는 경우 둘 이상의 ResultSet 오브젝트 열을 키 컬럼으로 지정해야 합니다.

어노테이션은 Bean 또는 Bean 목록을 포함하는 특성에만 정의될 수 있습니다. 선택적 요소(@JoinColumn 어노테이션 배열 또는 columnPrefix 요소)가 하나도 지정되지 않은 경우, 모든 ResultSet 맵핑 및 ID 컬럼 정의를 하위 Bean에서 가져옵니다.

@JoinColumn 어노테이션의 배열은 선택사항이며 하위 Bean 특성에 적용됩니다. 둘 이상의 @JoinColumn 어노테이션 배열은 중괄호({})로 묶어야 합니다.

@JoinColumn 어노테이션이 지정되지 않으면 pureQuery Runtime은 참조된 하위 Bean @Id 어노테이션을 사용하여 하위 Bean ID 컬럼에 맵핑되는 ResultSet 열을 판별합니다. 하위 Bean에 하나 이상의 @Id 어노테이션이 포함되어 있지 않은 경우 경고가 생성되며 하위 Bean이 무시됩니다.

joinCol 요소는 value 요소와 서로 독점입니다. 각 하나를 지정할 수 있지만 모두 지정할 수는 없습니다. 요소는 columnPrefix 요소가 지정될 때 필요합니다.

columnPrefix 요소의 값은 하위 Bean의 각 특성에 접두사로 추가되는 문자열을 지정합니다. 접두부를 사용하여 pureQuery Runtime이 고유 클래스 및 특성을 생성합니다. 접두부는 동일한 Bean 클래스를 재귀 없이 중첩된 Bean 구조의 동일한 레벨 또는 다른 레벨에서 사용하도록 허용합니다. 이러한 접두부가 있는 특성이 고유한지 확인하십시오. 접두부가 클래스에 추가되고 나면 접두부는 모든 Bean 및 접두부가 있는 클래스의 Bean 특성에 적용됩니다. 접두부는 부가적이며 필요한 만큼 중첩할 수 있습니다. columnPrefix 요소의 값은 상위 Bean @JoinColumn 어노테이션에 정의된 열 레이블이 아닌 하위 Bean에만 적용됩니다.

열 접두부는 쿼리가 하위 Bean을 채우는 열을 리턴하는 경우에만 적용됩니다.

다음 예 @JoinPoint 어노테이션에서 ResultSet 오브젝트는 SQL 쿼리가 리턴한 데이터를 포함합니다. 쿼리는 DEPARTMENT 테이블과 EMPLOYEE 테이블을 결합합니다. 부서 번호의 컬럼 이름은 DEPTNO이고 직원 번호의 컬럼 이름은 EMPNO입니다. 이를 처리하기 위해 부서 bean을 다음과 같이 코드화할 수 있습니다.
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

첫 번째 @JoinColumn 어노테이션은 DEPTNO 열을 DEPARTMENT 테이블에서 직원 Bean의 특성 empDepartment로 맵핑합니다.

ResultSet 오브젝트에서 열 레이블 WORKDEPT를 사용하려고 선택한 경우 ResultSet 오브젝트에 열 레이블 WORKDEPT가 있으면 propertyName = "empDepartment" 요소를 지정할 필요가 없습니다. 특성 WORKDEPT는 직원 Bean의 어노테이션 @Column (name = "WORKDEPT")에 의해 작성되었습니다.

@JoinPoint 어노테이션은 value 또는 joinCol 요소와 함께 지정될 수 있었습니다. 다음 예는 value 요소를 사용합니다.
@JoinPoint(value = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();
이 예는 이전 예의 하위 Bean을 참조합니다. 나중에 동일한 상위 Bean에서 다른 @JoinPoint 어노테이션이 프로젝트 Bean의 목록에 지정되고 프로젝트 Bean도 직원 Bean의 목록(이 경우 해당 프로젝트에 대해 작업하는 직원의 목록)을 정의한다고 가정하십시오. 요소 columnPrefix가 직원 Bean 목록의 @JoinPoint 어노테이션에 지정되지 않는 경우 이후에 프로젝트 Bean 내의 직원 Bean 사용이 무시되고 ResultSet 오브젝트에 데이터가 포함되어 있어도 해당 프로젝트에 대해 작업 중인 직원의 목록이 채워지지 않습니다. columnPrefix 요소를 부서 Bean 또는 프로젝트 Bean의 List<Employee>에 대해 지정합니다. 다음 예는 부서 Bean에 있는 @JoinPoint 어노테이션의 columnPrefix 요소를 지정합니다.
@JoinPoint(columnPrefix = "DE", joinCol = {
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

부서 직원을 나타낼 DE의 columnPrefix는 직원 Bean의 모든 특성 앞에 접두부로 추가되며 문자열 DE는 직원 Bean의 부서 목록을 의미하는 ResultSet (AS절 기준)의 모든 직원 열에 추가됩니다.

접두부는 또한 해당 직원 Bean의 모든 하위 Bean에 적용됩니다.

예를 들어 직원 Bean에 하위 부서 Bean이 포함되면 직원 Bean에 있는 부서 Bean의 모든 특성 앞에 DE가 접두부로 추가됩니다.

접두부 추가는 ResultSet 오브젝트에 있는 레벨만큼 계속됩니다. 하위 부서 Bean에 있는 직원 Bean 목록의 두 번째 레벨에는 DEDE가 접두부로 추가됩니다.

접두부는 또한 중첩된 Bean 구조의 모든 직원 Bean이 아닌 해당 직원 Bean의 모든 하위 Bean에 적용됩니다. 예를 들어, 접두부는 프로젝트 Bean의 직원 Bean 목록에 사용되지 않습니다.

동일한 하위 Bean을 여러 번 포함하는 상위 Bean이 있는 경우 @JoinPoint 어노테이션을 columnPrefix 요소와 함께 사용하여 하위 Bean에 맵핑되는 열을 지정할 수 있습니다. 다음 예는 columnPrefix 요소를 사용합니다.
@JoinPoint
public List<Emp> emps;
@JoinPoint(columnPrefix="m_")
public Emp manager;

columnPrefix="m_" 요소를 지정하여 m_이 접두부로 추가된 직원 테이블의 열을 Emp 관리자 필드에 맵핑할 수 있습니다.

어노테이션 예

HRDEPT.EMPLOYEE 테이블에 대한 쿼리에 의해 리턴되는 레코드를 보유하도록 Bean을 정의하려는 경우를 가정하십시오.
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))
컬럼 이름 중 일부는 생략되거나 Java 이름 지정 규칙을 따르지 않습니다.

직원 Bean에 대한 다음 정의는 @Column 어노테이션을 사용하여 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;
  }

}

애플리케이션이 데이터베이스에 대해 조금 다른 스키마로 실행되는 경우, 테이블은 다음과 같이 정의됩니다.

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

직원 Bean의 서브클래스를 작성하여 새 테이블 정의를 사용하여 작업할 수 있도록 이전 어노테이션을 겹쳐쓸 수 있습니다. 서브클래스의 시작은 다음 예와 비슷할 수 있습니다.

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

중첩된 Bean 세트에 대한 예

다음 예에서 EMPLOYEE 테이블의 기본 키는 직원 ID 번호를 포함하는 EMPNO 열이며 WORKDEPT 열은 직원이 일하는 부서 번호를 포함합니다. 직원 Bean은 다음 정의를 가질 수 있습니다.
@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;
}
ResultSet 오브젝트에서 부서 번호의 열 이름은 DEPTNO이며 직원 번호의 열 이름은 EMPNO입니다. 이를 처리하기 위해 부서 Bean은 다음 @JoinPoint 어노테이션을 가질 수 있습니다.
@JoinPoint({
  @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="workDept"),
  @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId")
})
public List<Employee> getListofDeptEmployees ();

첫 번째 @JoinColumn 어노테이션에서 DEPARTMENT 테이블의 DEPTNO 열은 직원 Bean의 workDept 특성에 맵핑됩니다. ResultSet의 열 레이블 WORKDEPT가 사용된 경우 열 레이블 WORKDEPT가 ResultSet에 있으면 propertyName="workDept"가 필요하지 않습니다. WORKDEPT 특성은 직원 Bean의 @Column(이름 = "WORKDEPT") 어노테이션에 의해 작성됩니다.


피드백