코드 농 소 왕-하 이 버 네 이 트 학습 3-Mapping declaration 맵 정의

실체 류 와 우리 의 관계 데이터 베이스 에 있 는 표 간 의 매 핑 관 계 는 우리 가 Hibernate 를 사용 하 는 데 가장 중요 하고 반드시 파악 해 야 할 기능 일 수 있 습 니 다.이것 은 매우 필요 합 니 다.사용 하 는 방식 은 여러 가지 가 있 습 니 다.저 는 주석 을 달 수 있 는 방식 이 더욱 간단 하 다 고 생각 합 니 다.그러나 좋 지 않 습 니 다.나머지 수정 에 불리 하고 분산 되 어 있 습 니 다.XML 방식 을 채택 하면 우리 가 수정 하 는 데 더욱 유리 하 다!
몇 가지 방식 으로 우리 관계 의 매 핑 을 실현 하 다.

Java 5 주석 사용(Java Persistence 2 주석 을 통 해)주석

using the Hibernate legacy XML files approach known as hbm.xml JPA annotations are in the javax.persistence.*package.Hibernate specific extensions are in org.hibernate.annotations.*.다음 예 를 보 겠 습 니 다.많이 썼어 요.참,주해 의 실현 원리 에 대해 나 도 한 편 쓰 고 싶 은 데,먼저 이 문 서 를 다 보고 나 서 다시 이야기 하 자

Hibernate 는 일반적으로 우 리 는 주 해 를 get 위 에 쓰 고,spring 주 해 는 set 위 에 쓴다.이것 도 기억 하고 있어 요.

package eg;

@Entity          
@Table(name="cats")         
@Inheritance(strategy=SINGLE_TABLE)    
@DiscriminatorValue("C")       （             ），          ，   ，                    ，    ，    ，         ，           ，                 Join   ，          @DiscriminatorColumn(name="subclass", discriminatorType=CHAR)
public class Cat {

   @Id     key,  
   @GeneratedValue      ， increament,native....
   public Integer getId() { return id; }
   public void setId(Integer id) { this.id = id; }
   private Integer id;

   public BigDecimal getWeight() { return weight; }
   public void setWeight(BigDecimal weight) { this.weight = weight; }
   private BigDecimal weight;

   @Temporal(DATE)              ，            
   @NotNull    
   @Column(updatable=false)     ，     
   public Date getBirthdate() { return birthdate; }
   public void setBirthdate(Date birthdate) { this.birthdate = birthdate; }
   private Date birthdate;

   @org.hibernate.annotations.Type(type="eg.types.ColorUserType")
   @NotNull 
   @Column(updatable=false)
   public ColorType getColor() { return color; }
   public void setColor(ColorType color) { this.color = color; }
   private ColorType color;

   @NotNull @Column(updatable=false)
   public String getSex() { return sex; }
   public void setSex(String sex) { this.sex = sex; }
   private String sex;

   @NotNull @Column(updatable=false)
   public Integer getLitterId() { return litterId; }
   public void setLitterId(Integer litterId) { this.litterId = litterId; }
   private Integer litterId;

   @ManyToOne    
                 ，    
   @JoinColumn(name="mother_id", updatable=false)
   public Cat getMother() { return mother; }
   public void setMother(Cat mother) { this.mother = mother; }
   private Cat mother;

   @OneToMany(mappedBy="mother")                http://blog.sina.com.cn/s/blog_697b968901016s7f.html
   @OrderBy("litterId")
   public Set<Cat> getKittens() { return kittens; }
   public void setKittens(Set<Cat> kittens) { this.kittens = kittens; }
   private Set<Cat> kittens = new HashSet<Cat>();
}

@Entity 
@DiscriminatorValue("D")
public class DomesticCat extends Cat {

   public String getName() { return name; }
   public void setName(String name) { this.name = name }
   private String name;
}

@Entity
public class Dog { ... }

위의 많은 주 해 는 기억 하지 못 해도 괜찮다.천천히 깨 달 았 으 면 좋 겠 어.당신 이 정말 프로젝트 를 할 때,아마도 쓸 때,먼저 자신 이 쓸 수 있 는 모든 속성 을 나열 하고,단독 문서 에 놓 고,필요 할 때 복사 하 세 요.하지만 전 제 는 이런 것들 이 어떤 역할 을 하 는 지 이해 할 수 있다 는 것 이다.우리 의 좋 은 방법 은 XML 과 우리 의 annotations 두 가 지 를 XML 을 비교 하 는 방식 이다.

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="eg">

        <class name="Cat" table="cats" discriminator-value="C">

                <id name="id">
                        <generator class="native"/>
                </id>

                <discriminator column="subclass" type="character"/>

                <property name="weight"/>

                <property name="birthdate" type="date" not-null="true" update="false"/>

                <property name="color" type="eg.types.ColorUserType" not-null="true" update="false"/>

                <property name="sex" not-null="true" update="false"/>

                <property name="litterId" column="litterId" update="false"/>

                <many-to-one name="mother" column="mother_id" update="false"/>

                <set name="kittens" inverse="true" order-by="litter_id">
                        <key column="mother_id"/>
                        <one-to-many class="Cat"/>
                </set>

                <subclass name="DomesticCat" discriminator-value="D">

                        <property name="name" type="string"/>

                </subclass>

        </class>

        <class name="Dog">
                <!-- mapping for Dog could go here -->
        </class>

</hibernate-mapping>

두 가지 예 를 보고 우 리 는 천천히 이 속성 들 을 이해 합 시다.

Entity An entity is a regular Java object (aka POJO) which will be persisted by Hibernate.

Table@Table lets you define the table the entity will be persisted into.If undefined,the table name is the unqualified class name of the entity.데이터베이스 에 있 는 표 이름 이 정의 되 지 않 으 면 우리 의 실체 클래스 이름 입 니 다@Immutable Some entities are not mutable.They cannot be updated by the application.This allows Hibernate to make some minor performance optimizations 일부 실 체 는 변 하지 않 습 니 다.업데이트 하지 못 하 게 할 수 있 습 니 다.-@discriminator-value 계승 에 사용 되 는(optional-defaults to the class name):a value that distinguishes individual subclasses that is used for polymorphic behavior.Acceptable values include null and not null

@dynamicInsert/dynamicUpdate 는 UPDATE,INSERT 에 사용 할 SQL 을 실행 할 때 동적 으로 생 성하 고 변 경 된 필드 만 업데이트 합 니 다.-@optional-defaults to version):determines the optimistic locking strategy.dynamic-update 를 열 었 다 면 몇 가지 낙관적 인 잠 금 전략 을 선택 할 수 있 습 니 다

Tables
Are
version
check the version/timestamp columns
all
check all columns
dirty
check the changed columns, allowing some concurrent updates
none
do not use optimistic locking
- @Id Mapped classes must declare the primary key column of the database table.
Declaring column attributes

@Entity
public class Flight implements Serializable {
...
@Column(updatable = false, name = "flight_name", nullable = false, length=50)
public String getName() { ... }

@Column(
    name="columnName";                                     (1)
    boolean unique() default false;                        (2)
    boolean nullable() default true;                       (3)
    boolean insertable() default true;                     (4)
    boolean updatable() default true;                      (5)
    String columnDefinition() default "";                  (6)
    String table() default "";                             (7)
    int length() default 255;                              (8)     
    int precision() default 0; // decimal precision (9)
    int scale() default 0; // decimal scale

. Property mapping with hbm.xml

<property
        name="propertyName"                                (1)
        column="column_name"                               (2)
        type="typename"                                    (3)
        update="true|false"                                (4)
        insert="true|false"                                (4)
        formula="arbitrary SQL expression"                 (5)
        access="field|property|ClassName"                  (6)
        lazy="true|false"                                  (7)
        unique="true|false"                                (8)
        not-null="true|false"                              (9)
        optimistic-lock="true|false"                       (10)
        generated="never|insert|always"                    (11)
        node="element-name|@attribute-name|element/@attribute|."
        index="index_name"
        unique_key="unique_key_id"
        length="L"
        precision="P"
        scale="S"
/>

Single table per class hierarchy strategy
계승 정책 저장 정책 은 세 가지 가 있 습 니 다.1.모두 한 장의 표 에 저장 하 다.하위 클래스 정책 추가:각 클래스 와 하위 클래스 는 표 마다 주어진 속성 하위 클래스 에 표 시 됩 니 다.실체의 상 태 는 그 에 상응하는 클래스 표 와 모든 클래스 에 저장 된다.부모 클래스 는 부모 클래스 에 속 하고 새로 생산 된 것 은 우리 하위 클래스 에 새 표 3 을 놓 습 니 다.표 의 각 클래스 전략:각 구체 적 인 클래스 의 하위 클래스 는 현재 와 각 표 의 지속 적 인 속성 클래스 와 그 초 클래스 입 니 다.그리고 실 체 를 저장 하 는 상 태 는 완전히 전용 표 류 에 있 습 니 다.
1。단일 테이블 정책

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
    name="planetype",
    discriminatorType=DiscriminatorType.STRING
)
@DiscriminatorValue("Plane")
The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row
public class Plane { ... }

@Entity
@DiscriminatorValue("A320")
public class A320 extends Plane { ... }  


xml
subclass
        name="ClassName"                                   (1)
        discriminator-value="discriminator_value"          (2)
        proxy="ProxyInterface"                             (3)
        lazy="true|false"                                  (4)
        dynamic-update="true|false"
        dynamic-insert="true|false"
        entity-name="EntityName"
        node="element-name"
        extends="SuperclassName">

        <property .... />
        .....
</subclass>

<hibernate-mapping>
<subclass name="DomesticCat" extends="Cat" discriminator- value="D">
<property name="name" type="string"/>
</subclass>
</hibernate-mapping
>

하위 클래스 마다 표 한 장(Table per subclass)

<class name="Payment" table="PAYMENT">
  <id name="id" type="long" column="PAYMENT_ID">
     <generator class="native"/>
   </id>
   <property name="amount" column="AMOUNT"/>
   ...
   <joined-subclass name="CreditCardPayment"       table="CREDIT_PAYMENT">
      <key column="PAYMENT_ID"/>
      <property name="creditCardType" column="CCTYPE"/>
...
   </joined-subclass>
   <joined-subclass name="CashPayment" table="CASH_PAYMENT">
   <key column="PAYMENT_ID"/>
...
   </joined-subclass>
<joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
<key column="PAYMENT_ID"/>
...
</joined-subclass>
</class
>

@JoinTable 과@JoinColumn 의 설명,잘 썼 습 니 다!http://www.cnblogs.com/mingforyou/p/4615969.html

@Entity @Table(name="CATS")
@Inheritance(strategy=InheritanceType.JOINED)
public class Cat implements Serializable { 
    @Id @GeneratedValue(generator="cat-uuid") 
    @GenericGenerator(name="cat-uuid", strategy="uuid")
    String getId() { return id; }

    ...
}

@Entity @Table(name="DOMESTIC_CATS")
@PrimaryKeyJoinColumn(name="CAT")
public class DomesticCat extends Cat { 
    public String getName() { return name; }
}            

각 구체 적 인 클래스 별 표(Table per concrete class)

<class name="Payment">
<id name="id" type="long" column="PAYMENT_ID">
<generator class="sequence"/>
</id>
<property name="amount" column="AMOUNT"/>
...
<union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">
<property name="creditCardType" column="CCTYPE"/>
...
</union-subclass>
<union-subclass name="CashPayment" table="CASH_PAYMENT">
...
</union-subclass>
<union-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
...
</union-subclass>
</class

이거 다 봤 는데 너무 복잡 하지 않 아 요?데이터 베 이 스 를 못 봤 는데 정말 어 지 러 워 요.아직도 많은 특성 이 있다.한 테이블 에서 foreign key 를 천천히 보 는 것 은 target table 의 primary key column(s)을 참조 하 는 것 입 니 다.외부 키 참조

@Entity
public class Flight implements Serializable {
    @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
    @JoinColumn(name="COMP_ID")
    public Company getCompany() {
        return company;
    }
    ...
}   

이것 은 바로 외부 키 의 인용 입 니 다.만약 에 저희 JoinColumn 의 이름 을 지정 하지 않 았 다 면 Flight 라 는 표 에 기본 이름 이 들 어 갈 것 입 니 다.예 를 들 어 copanyid