摘要：聲明添加對樂觀鎖定的支持一些屬性關聯關系獲取方式即是否采用延時加載及時加載，是在查詢數據時，也直接一起獲取關聯對象的數據。在前面的基礎上增加課程類并補充學生類學生類負責關聯關系

在Hibernate中通常配置對象關系映射關系有兩種，一種是基于xml的方式，另一種是基于Hibernate Annotation庫的注解方式。在Hibernate 3.2版本和Java 5 環境下開始支持使用注解配置對象關系映射，使用Hibernate注解之后，可不用定義持久化類所對應的*.hbm.xml文件，直接用注解的方式寫入持久化類中實現

兩種方法要注意的兩個不同處：
（1）：hibernate.hbm.xml 文件中把引用：xxx.hbm.xml改為引用實體類：

即把
改為：

（2）：獲取SessionFactory方式發生了變化：

即把SessionFactorysf=newConfiguration().configure().buildSessionFactory()
改為SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory()

在屬性注解使用上，您既可以保持字段的持久性（注解寫在成員變量之上），也可以保持屬性（注解寫在getter方法之上）的持久性,但建議不要在屬性上引入注解，因為屬性是private的，如果引入注解會破壞其封裝特性，所以建議在getter方法上加入注解

@Entity

將一個Javabean類聲明為一個實體的數據庫表映射類,最好實現序列化。默認情況下,所有的類屬性都為映射到數據表的持久性字段。若在類中有屬性不映射到數據庫中的,要用下面的@Transient來注解。
*屬性:*
`name` - 可選，對應數據庫中的一個表。若表名與實體類名相同，則可以省略。

@Table
在@Entity下使用，表示實體對應數據庫中的表的信息

屬性:
name - 可選，表示表的名稱，默認表名和實體名稱一致，不一致的情況下需指定表名。
catalog - 可選，表示Catalog名稱，默認為 Catalog("")
schema - 可選 , 表示 Schema 名稱 , 默認為Schema("")

@Entity()
@Table(name="Student")
public class Student implements Serializable{
}

@Id

必須，定義了映射到數據庫表的主鍵的屬性，一個實體只能有一個屬性被映射為主鍵

@GeneratedValue

定義自動增長的主鍵的生成策略.
屬性:
strategy - 表示主鍵生成策略，取值有以下


GenerationType.AUTO
根據底層數據庫自動選擇（默認），若數據庫支持自動增長>類型，則為自動增長。



GenerationType.INDENTITY
根據數據庫的Identity字段生成，支持DB2、MySQL、MS、SQL Server、SyBase與HyperanoicSQL數據庫的Identity


GenerationType.SEQUENCE
使用Sequence來決定主鍵的取值，適合Oracle、DB2等支持Sequence的數據庫，一般結合@SequenceGenerator使用。(Oracle沒有自動增長類型，只能用Sequence)


GenerationType.TABLE
使用指定表來決定主鍵取值，結合@TableGenerator使用。

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY) 
private int sid;

GenerationType.TABLE的使用

@Id  
@GeneratedValue(strategy=GenerationType.TABLE,generator="strategyName")   
@TableGenerator(
    name = "strategyName",   // 主鍵生成策略的名稱，它被引用在@GeneratedValue中設置的“generator”值中
    table="",   //表示表生成策略所持久化的表名   
    catalog="",   //表所在的目錄名
    schema="",   //數據庫名
    pkColumnName="",   //在持久化表中，該主鍵生成策略所對應鍵值的名稱
    valueColumnName="",   //表示在持久化表中，該主鍵當前所生成的值，它的值將會隨著每次創建累加  
    pkColumnValue="",   //表示在持久化表中，該生成策略所對應的主鍵  
    allocationSize=1   //表示每次主鍵值增加的大小，例如設置成1，則表示每次創建新記錄后自動加1，默認為50
)  

GenerationType.SEQUENCE的使用

@Id  
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="strategyName")   
@SequenceGenerator(
    name="strategyName", //name屬性表示該表主鍵生成策略的名稱，它被引用在@GeneratedValue中設置的“generator”值中
    sequenceName=""  //表示生成策略用到的數據庫序列名稱
) 

更多基于注解的Hibernate主鍵生成策略介紹

@Transient

將忽略這些字段和屬性,不用持久化到數據庫。

@Column

可將屬性映射到列,使用該注解來覆蓋默認值
屬性:
name- 可選，表示數據庫表中該字段的名稱，默認情形屬性名稱一致

length - 可選，表示該字段的大小，僅對 String 類型的字段有效，默認值255.
insertable - 可選，表示在ORM框架執行插入操作時，該字段是否應出現INSETRT 語句中，默認為 true
updateable - 可選，表示在ORM 框架執行更新操作時，該字段是否應該出現在 UPDATE 語句中，默認為 true. 對于一經創建就不可以更改的字段，該屬性非常有用，如對于 birthday 字段。
columnDefinition - 可選，表示該字段在數據庫中的實際類型。通常ORM 框架可以根 據屬性類型自動判斷數據庫中字段的類型，但是對于Date 類型仍無法確定數據庫中字段類型究竟是 DATE,TIME 還是 TIMESTAMP. 此外 ,String 的默認映射類型為 VARCHAR, 如果要將 String 類型映射到特定數據庫的 BLOB或 TEXT 字段類型，該屬性非常有用。

@Version

聲明添加對樂觀鎖定的支持

一些屬性

fetch

關聯關系獲取方式,即是否采用延時加載
Fetch.EAGER -  及時加載，是在查詢數據時，也直接一起獲取關聯對象的數據。多對一默認是Fetch.EAGER  
Fetch.LAZY -延遲加載，查詢數據時，不一起查詢關聯對象的數據。而是當訪問關聯對象時才觸發相應的查詢操作，獲取關聯對象數據。一對多默認是Fetch.LAZY

cascade

設置級聯方式
CascadeType.PERSIST 保存
CascadeType.REMOVE - 刪除
CascadeType.MERGE 修改 
CascadeType.REFRESH 刷新 
CascadeType.ALL - 全部

mappedBy

mappedBy指的是多方對一方的依賴的屬性，(注意：如果沒有指定由誰來維護關聯關系，則系統會給我們創建一張中間表)。
如果這個一對多的關系不是通過第三張表來維持，而是多方保存一方的id（多方外鍵引用一方），則必須要有mappedBy來指明多方中哪個變量來保存一方（外鍵），值是多方里面保存一方的屬性名字
在判斷到底是誰維護關聯關系時，可以通過查看外鍵，哪個實體類定義了外鍵，哪個類就負責維護關聯關系
 mappedBy相當于xml配置中的inverse="true"

@OneToMany

描述一個一對多的關聯，該屬性應該為集合類型 @OneToMany  默認會使用連接表做一對多關聯
如果這個一對多的關系不是通過第三張表來維持，而是多方保存一方的id（多方外鍵引用一方），則必須要有mappedBy來指明多方中哪個變量來保存一方（外鍵），值是多方里面保存一方的屬性名字

@OneToMany(cascade={CascadeType.ALL},mappedBy="grade")
    public Set getStudents() {
        return students;
    }

@ManyToOne

表示一個多對一的映射，該注解標注的屬性通常是數據庫表的外鍵。 單向多對一關聯在多方：
@ManyToOne(targetEntity=XXXX.class)   //指定關聯對象 
@JoinColumn(name="")  //指定產生的外鍵字段名

雙向一對多同雙向多對一

在多方 
@ManyToOne 
@JoinColumn(name="自己的數據庫外鍵列名")
在一方
@OneToMany(mappedBy="多端的關聯屬性名")

/*
 * 學生類負責關聯關系
 */
@Entity
@Table(name="Student")
public class Student implements Serializable{
    private int sid;
    private String sex;
    private String name;
    private Grade grade;
    public Student() {
        
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Id
    @GenericGenerator(name="generator",strategy="native")
    @GeneratedValue(generator="generator")
    public int getId() {
        return sid;
    }
    public void setId(int id) {
        this.sid = id;
    }
    @Column(name="sex")
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @ManyToOne(cascade={CascadeType.ALL})
    @JoinColumn(name="gid")
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}

/*
 * 班級類
 */
@Entity
@Table(name="Grade")
public class Grade implements Serializable{
    private int gid;
    private String name;
    private Set students=new HashSet();
    public Grade() {
    }
    @Id
    @GenericGenerator(name="generator",strategy="native")
    @GeneratedValue(generator="generator")
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToMany(cascade={CascadeType.ALL},mappedBy="grade")
    public Set getStudents() {
        return students;
    }
    public void setStudents(Set students) {
        this.students = students;
    }
}

在多對多關聯中,雙方都采用@ManyToMany. 其中被維護方mappedBy表示由另一多方維護
通過中間表由任一多方來維護關聯關系
其中主控方,不像一對多注解那樣,采用@joinColumn,而是采用@joinTable

 @JoinTable(
     name="student_course",
     joinColumns={@JoinColumn(name="")},
     inverseJoinColumns={@JoinColumn(name="")}
)

因為多對多之間會通過一張中間表來維護兩表直接的關系，所以通過JoinTable 這個注解來聲明。
 name就是指定了中間表的名字。
JoinColumns是一個@JoinColumn類型的數組，表示的是我這方在對方中的外鍵名稱，就是當前類的主鍵。
inverseJoinColumns也是一個@JoinColumn類型的數組，表示的是對方在我這方中的外鍵名稱，也可以這樣想：上面提到mappedBy,相當于inverse="true".所以,在@joinTable中的inverseJoinColumns中定義的字段為mappedBy所在類的主鍵。

在前面的基礎上增加課程類并補充學生類

/*
 * 學生類負責關聯關系
 */
@Entity
@Table(name="Student")
public class Student implements Serializable{
    private int sid;
    private String name;
    private String sex;
    private Grade grade;
    private Set courses=new HashSet();
    public Student() {
        
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Id
    @GenericGenerator(name="generator",strategy="native")
    @GeneratedValue(generator="generator")
    public int getId() {
        return sid;
    }
    public void setId(int id) {
        this.sid = id;
    }
    @Column(name="sex")
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @ManyToOne(cascade={CascadeType.ALL})
    @JoinColumn(name="gid")
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }
    @ManyToMany(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
    @JoinTable(name="student_course",joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})
    public Set getCourses() {
        return courses;
    }
    public void setCourses(Set courses) {
        this.courses = courses;
    }
}

@Entity
@Table(name="Course")
public class Course implements Serializable{

    private int cid;
    private String cName;
    private Set students=new HashSet();
    public Course() {
    }
    @Id
    @GenericGenerator(name="generator",strategy="native")
    @GeneratedValue(generator="generator")
    public int getCid() {
        return cid;
    }
    public void setStudents(Set students) {
        this.students = students;
    }
    public void setCid(int cid) {
        this.cid = cid;
    }
    public String getcName() {
        return cName;
    }
    public void setcName(String cName) {
        this.cName = cName;
    }
    @ManyToMany(cascade={CascadeType.ALL},fetch=FetchType.LAZY ,mappedBy="courses") 
    public Set getStudents() {
        return students;
    }
}