這篇blog主要是總結一下Hibernate註解的使用．主要分為三部分，第一部分宣告實體類的註解，包括宣告實體類過程中的約束條件註解的使用，第二部分主要為關聯關係之間的註解宣告，最後一部分作為其他註解．
１．為什麼要使用註解？
說實話，我覺得使用覺的使用hbm.xml對映檔案能夠是對映關係看起來更明確顯眼些，有哪些實體類，對映到資料庫中有哪些列也是比較明顯的，而且我覺的，配置檔案使專案的解耦更好一點（當然，也許你會說如果要更改對映關係，使不使用配置檔案都是需要更改原始檔的，．ｈｂｍ．ｘｍｌ檔案也是原始檔，畢竟它和ｗｅｂ．ｘｍｌ檔案還是有一些差別的，沒準不適用配置檔案還只需要更改一個檔案，額．．．想想其實也是的）．不過使用配置檔案有一個很明顯的缺點：實體類多了之後，要在不同檔案之間轉換，更麻煩．．．所以從現在開始，來學習使用註解吧．（目前為止我們還不需要更改ｐｏｍ．ｘｍｌ檔案，目前所用的所有包都已經包括進來了）
２．實體類的定義等相關注解

2.1　定義實體類

package entities;


import javax.persistence.*;
import java.util.Date;

/**
 * Created by tbxsx on 17-5-30.
 */
@Entity
@Table(name = "`provice`")
public class Provice {
    private long id;
    private String name;
    private String email;

    private Date create_date;

    public Provice
 
() {
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "`id`")
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    @Column(name = "`name`", nullable = false, length = 30)
    public String getName
 
() {
        return name;
    }

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


    @Column(name = "`email`", nullable = false, unique = true, length = 30)
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
    //注意在這裡設定了屬性　insertable = false,columnDefinition = "datetime default now()" 這些會在後面講到
    @Column(name = "`create_date`", insertable = false, columnDefinition = "datetime default now()", nullable = false
    )
    public Date getCreate_date() {
        return create_date;
    }

    public void setCreate_date(Date create_date) {
        this.create_date = create_date;
    }
}

定義如上圖，測試如下：

    @Test
    public void testAnotation(){
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        Provice provice = new Provice();
        provice.setName("hunan");
        provice.setEmail("[email protected]");
        session.save(provice);
        session.getTransaction().commit();
        System.out.println("Test!");
    }

ＳＱＬ語句：

Hibernate: 

    create table `provice` (
       `id` bigint not null auto_increment,
        `create_date` datetime default now() not null,
        `email` varchar(30) not null,
        `name` varchar(30) not null,
        primary key (`id`)
    ) engine=MyISAM
Hibernate: 

    alter table `provice` 
       add constraint UK_b1cb2vul5rqbel47yqidov4h3 unique (`email`)
    insert 
    into
        `
        provice` (
            `email`, `name`
        ) 
    values
        (?, ?)

資料庫結果：

註解從大到小：
１．Table層次
@Entity:實體類註解（必需）

public @interface Entity {

    /**
     * (Optional) The entity name. Defaults to the unqualified
     * name of the entity class. This name is used to refer to the
     * entity in queries. The name must not be a reserved literal
     * in the Java Persistence query language.
     */
    String name() default "";
}

只有一個名字屬性，名字屬性定義的是實體類名稱（預設為類名）．
＠Table：

/**
 * Specifies the primary table for the annotated entity. Additional
 * tables may be specified using {@link SecondaryTable} or {@link
 * SecondaryTables} annotation.
 * <p/>
 * If no <code>Table</code> annotation is specified for an entity
 * class, the default values apply.
 *
 * <pre>
 *    Example:
 *
 *    &#064;Entity
 *    &#064;Table(name="CUST", schema="RECORDS")
 *    public class Customer { ... }
 * </pre>
 *
 * @since Java Persistence 1.0
 */
@Target(TYPE)
@Retention(RUNTIME)
public @interface Table {
    /**
     * (Optional) The name of the table.
     * <p/>
     * Defaults to the entity name.
     */
    String name() default "";

    /**
     * (Optional) The catalog of the table.
     * <p/>
     * Defaults to the default catalog.
     */
    String catalog() default "";

    /**
     * (Optional) The schema of the table.
     * <p/>
     * Defaults to the default schema for user.
     */
    String schema() default "";

    /**
     * (Optional) Unique constraints that are to be placed on
     * the table. These are only used if table generation is in
     * effect. These constraints apply in addition to any constraints
     * specified by the <code>Column</code> and <code>JoinColumn</code>
     * annotations and constraints entailed by primary key mappings.
     * <p/>
     * Defaults to no additional constraints.
     */
    UniqueConstraint[] uniqueConstraints() default { };

    /**
     * (Optional) Indexes for the table. These are only used if table generation is in effect.  Defaults to no
     * additional indexes.
     *
     * @return The indexes
     */
    Index[] indexes() default {};
}

和Ｅｎｔｉｔｙ對應的是＠Ｔａｂｌｅ註解，詮釋與這個類對應的資料庫表的相關屬性（非必需，Ｈｉｂｅｒｎａｔｅ會產生預設名字，預設名為實體類名，即@Entity定義的名字，如果@Entity沒有定義，那麼資料庫對映表名即為類名）當實體類和資料庫中對應表名稱不同時，需要使用該註解．name屬性是在資料庫中表名稱，schema和category是資料庫名稱，unqiqueConstraints設定表約束．更多

2.屬性層次
主鍵：
@Id
宣告此屬性為主鍵。
@EmbeddedId　:　組合主鍵

@Entity
public class Login {

    @EmbeddedId
    private PK pk;

    @Embeddable
    public static class PK implements Serializable {

        private String system;

        private String username;

        ...
    }

    ...
}

@GeneratedValue
指定主鍵的生成策略。有如下四個值
TABLE：使用表儲存id值，單獨生成一個表　更多
IDENTITY：identitycolumn，通過auto_increment產生
SEQUENCR ：sequence，需要資料庫支援序列
AUTO：根據資料庫的不同使用上面三個（當我使用Mysql並不確定生成策略的時候，使用了Table策略）

一般屬性：
＠Column

 /**
 * Is used to specify the mapped column for a persistent property or field.
 * If no <code>Column</code> annotation is specified, the default values apply.
 *
 * <blockquote><pre>
 *    Example 1:
 *
 *    &#064;Column(name="DESC", nullable=false, length=512)
 *    public String getDescription() { return description; }
 *
 *    Example 2:
 *
 *    &#064;Column(name="DESC",
 *            columnDefinition="CLOB NOT NULL",
 *            table="EMP_DETAIL")
 *    &#064;Lob
 *    public String getDescription() { return description; }
 *
 *    Example 3:
 *
 *    &#064;Column(name="ORDER_COST", updatable=false, precision=12, scale=2)
 *    public BigDecimal getCost() { return cost; }
 *
 * </pre></blockquote>
 *
 *
 * @since Java Persistence 1.0
 */
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Column {

    /**
     * (Optional) The name of the column. Defaults to
     * the property or field name.
     */
    String name() default "";

    /**
     * (Optional) Whether the column is a unique key.  This is a
     * shortcut for the <code>UniqueConstraint</code> annotation at the table
     * level and is useful for when the unique key constraint
     * corresponds to only a single column. This constraint applies
     * in addition to any constraint entailed by primary key mapping and
     * to constraints specified at the table level.
     */
    boolean unique() default false;

    /**
     * (Optional) Whether the database column is nullable.
     */
    boolean nullable() default true;

    /**
     * (Optional) Whether the column is included in SQL INSERT
     * statements generated by the persistence provider.
     */
    boolean insertable() default true;

    /**
     * (Optional) Whether the column is included in SQL UPDATE
     * statements generated by the persistence provider.
     */
    boolean updatable() default true;

    /**
     * (Optional) The SQL fragment that is used when
     * generating the DDL for the column.
     * <p> Defaults to the generated SQL to create a
     * column of the inferred type.
     */
    String columnDefinition() default "";

    /**
     * (Optional) The name of the table that contains the column.
     * If absent the column is assumed to be in the primary table.
     */
    String table() default "";

    /**
     * (Optional) The column length. (Applies only if a
     * string-valued column is used.)
     */
    int length() default 255;

    /**
     * (Optional) The precision for a decimal (exact numeric)
     * column. (Applies only if a decimal column is used.)
     * Value must be set by developer if used when generating
     * the DDL for the column.
     */
    int precision() default 0;

    /**
     * (Optional) The scale for a decimal (exact numeric) column.
     * (Applies only if a decimal column is used.)
     */
    int scale() default 0;
}

可在此定義相關約束條件．
主要講一下columnDefinition 和　insertable，updatable．
比如說需要定義時間的預設值，預設值為插入資料庫的時候．那麼怎麼辦呢？通過設定　columnDefinition，這句話會在生成ＤＤＬ時候，加入ＤＤＬ中．如：

@Column(name = "`create_date`", insertable = false, columnDefinition = "datetime default now()", nullable = false
    )
    public Date getCreate_date() {
        return create_date;
    }

生成的ＤＤＬ為：

`create_date` datetime default now() not null,

直接載入｀create_date｀後面．
然後設定

 insertable = false

這樣在ｓａｖｅ的時候產生的語句為：

    insert 
    into
        `
        provice` (
            `email`, `name`
        ) 
    values
        (?, ?)

否則為：

    insert 
    into
        `
        provice` (
            `email`, `name`，｀create_date｀
        ) 
    values
        (?, ?, ?)

如果為這種情況，因為create_date是資料庫自動生成的，在實體類中，create_date為ｎｕｌｌ，所以插入的create_date將為ｎｕｌｌ．
此外，如果想將create_date設定為物件生成時候的值，可以：

private Date create_date = new Date()

更多1

3.物件關聯關係的註解
首先介紹一下註解：@JoinColumn
我們知道在兩個表之間通過外來鍵來表示關聯關係．
@JoinColumn 可以註釋本表中指向另一個表的外來鍵，相當與一個外來鍵的定義．

    public @interface JoinColumn {

    /**
     * (Optional) The name of the foreign key column.
     * The table in which it is found depends upon the
     * context.
     * <ul>
     * <li>If the join is for a OneToOne or ManyToOne
     *  mapping using a foreign key mapping strategy,
     * the foreign key column is in the table of the
     * source entity or embeddable.
     * <li> If the join is for a unidirectional OneToMany mapping
     * using a foreign key mapping strategy, the foreign key is in the
     * table of the target entity.
     * <li> If the join is for a ManyToMany mapping or for a OneToOne
     * or bidirectional ManyToOne/OneToMany mapping using a join
     * table, the foreign key is in a join table.
     * <li> If the join is for an element collection, the foreign
     * key is in a collection table.
     *</ul>
     *
     * <p> Default (only applies if a single join column is used):
     * The concatenation of the following: the name of the
     * referencing relationship property or field of the referencing
     * entity or embeddable class; "_"; the name of the referenced
     * primary key column.
     * If there is no such referencing relationship property or
     * field in the entity, or if the join is for an element collection,
     * the join column name is formed as the
     * concatenation of the following: the name of the entity; "_";
     * the name of the referenced primary key column.
     */
    String name() default "";

    /**
     * (Optional) The name of the column referenced by this foreign
     * key column.
     * <ul>
     * <li> When used with entity relationship mappings other
     * than the cases described here, the referenced column is in the
     * table of the target entity.
     * <li> When used with a unidirectional OneToMany foreign key
     * mapping, the referenced column is in the table of the source
     * entity.
     * <li> When used inside a <code>JoinTable</code> annotation,
     * the referenced key column is in the entity table of the owning
     * entity, or inverse entity if the join is part of the inverse
     * join definition.
     * <li> When used in a <code>CollectionTable</code> mapping, the
     * referenced column is in the table of the entity containing the
     * collection.
     * </ul>
     *
     * <p> Default (only applies if single join column is being
     * used): The same name as the primary key column of the
     * referenced table.
     */
    String referencedColumnName() default "";

    /**
     * (Optional) Whether the property is a unique key.  This is a
     * shortcut for the <code>UniqueConstraint</code> annotation at
     * the table level and is useful for when the unique key
     * constraint is only a single field. It is not necessary to
     * explicitly specify this for a join column that corresponds to a
     * primary key that is part of a foreign key.
     */
    boolean unique() default false;

    /** (Optional) Whether the foreign key column is nullable. */
    boolean nullable() default true;

    /**
     * (Optional) Whether the column is included in
     * SQL INSERT statements generated by the persistence
     * provider.
     */
    boolean insertable() default true;

    /**
     * (Optional) Whether the column is included in
     * SQL UPDATE statements generated by the persistence
     * provider.
     */
    boolean updatable() default true;

    /**
     * (Optional) The SQL fragment that is used when
     * generating the DDL for the column.
     * <p> Defaults to the generated SQL for the column.
     */
    String columnDefinition() default "";

    /**
     * (Optional) The name of the table that contains
     * the column. If a table is not specified, the column
     * is assumed to be in the primary table of the
     * applicable entity.
     *
     * <p> Default:
     * <ul>
     * <li> If the join is for a OneToOne or ManyToOne mapping
     * using a foreign key mapping strategy, the name of the table of
     * the source entity or embeddable.
     * <li> If the join is for a unidirectional OneToMany mapping
     * using a foreign key mapping strategy, the name of the table of
     * the target entity.
     * <li> If the join is for a ManyToMany mapping or
     * for a OneToOne or bidirectional ManyToOne/OneToMany mapping
     * using a join table, the name of the join table.
     * <li> If the join is for an element collection, the name of the collection table.
     * </ul>
     */
    String table() default "";

    /**
     * (Optional) The foreign key constraint specification for the join column. This is used only if table generation
     * is in effect.  Default is provider defined.
     *
     * @return The foreign key specification
     */
    ForeignKey foreignKey() default @ForeignKey();
}

3.1 ＠OneToOne
    配合＠JoinColumn使用
    我們現在使用Husband和Wife的一對一關係演示：

@Entity
public class Husband {
    private long id;
    private String name;
    private Wife wife;

    public Husband() {
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.PERSIST)
    @JoinColumn(name = "wife_id")
    public Wife getWife() {
        return wife;
    }

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}


@Entity
public class Wife {
    private long id;
    private String name;
    private Husband husband;

    public Wife() {
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.PERSIST)
    @JoinColumn(name = "husband_id")
    public Husband getHusband() {
        return husband;
    }

    public void setHusband(Husband husband) {
        this.husband = husband;
    }
}


    @Test
    public void testOneToOneAnotation(){
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        Husband husband = session.get(Husband.class,1l);
        session.delete(husband);

        session.getTransaction().commit();
        System.out.println("Test!");
    }

注意點：
１．@JoinColumn 和＠OneToOne中MappedBy的用法．
前者可以理解為在Wife表中建立一個代表Husband的屬性，當然這是一個外來鍵．
後者代表：Husband 在Wife實體類中有一個指向(即Wife類中有一個名字為husband的Ｈｕｓｂａｎｄ物件的引用)．即mappedBy標籤定義在被擁有方的，他指向擁有方；
mappedBy跟joinColumn/JoinTable總是處於互斥的一方，可以理解為正是由於擁有方的關聯被擁有方的欄位存在，擁有方才擁有了被擁有方。mappedBy這方定義JoinColumn/JoinTable總是失效的，不會建立對應的欄位或者表。
參考
參考
2. Cascade 的使用方法．
Cascade：
CascadeType.REFRESH：級聯重新整理，當多個使用者同時作操作一個實體，為了使用者取到的資料是實時的，在用實體中的資料之前就可以呼叫一下refresh()方法！

CascadeType.REMOVE：級聯刪除，當呼叫remove()方法刪除Ｈｕｓｂａｎｄ實體時會先級聯刪除ｗｉｆｅ的相關資料！

CascadeType.MERGE：級聯更新，當呼叫了Merge()方法，如果ｈｕｓｂａｎｄ中的資料改變了會相應的更新OＷｉｆｅ中的資料，

CascadeType.ALL：包含以上所有級聯屬性。


（注：以上幾種級聯操作，只能實在滿足資料庫的約束時才能生效）
CascadeType.PERSIST：級聯儲存，當呼叫了Persist() 方法，會級聯儲存相應的資料
比如說：舉例CascadeType.PERSIST．
如果前面的例子中，沒有Cascade屬性，使用save方法儲存Ｈｕｂｂａｎｄ的時候，將會由於它的外來鍵ｗｉｆｅ沒有儲存，導致出現錯誤（外來鍵不存在），如果使用了該屬性，那麼它會儲存兩個實體類，消除錯誤．

ERROR: HHH000346: Error during managed flush [org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance beforeQuery flushing: entities.Wife]
java.lang.IllegalStateException: org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance beforeQuery flushing: entities.Wife

參考
3. orphanRemoval 的使用方法
在這裡，如果只設置ｃａｓｃａｄｅ為ｐｅｒｓｉｓｔ，不設定該屬性的時候，刪除一個ｈｕｓｂａｎｄ，將不會刪除對應的ｗｉｆｅ，如果該屬性為ｔｒｕｅ，將會刪除兩者．
更多的該屬性用法會出現在多對多或者一對多關係中，如果有中間關係表，刪除實體的時候，該屬性會使ｈｉｂｅｒｎａｔｅ同時刪除中間表的記錄．

3.2 @ManyToOne
3.3 @OneToMany
        多方：
        @ManyToOne
        一方：
        @OneToMany(mappedBy = "person", cascade = CascadeType.ALL, orphanRemoval = true)

3.4 @ManyToMany
    主方擁有者：@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    從擁有者方：@ManyToMany(mappedBy = "addresses")
3.5 @Any
3.6 @ManyToAny

參考