摘要：聲明添加對樂觀鎖定的支持一些屬性關(guān)聯(lián)關(guān)系獲取方式即是否采用延時(shí)加載及時(shí)加載，是在查詢數(shù)據(jù)時(shí)，也直接一起獲取關(guān)聯(lián)對象的數(shù)據(jù)。在前面的基礎(chǔ)上增加課程類并補(bǔ)充學(xué)生類學(xué)生類負(fù)責(zé)關(guān)聯(lián)關(guān)系

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

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

即把
改為：

（2）：獲取SessionFactory方式發(fā)生了變化：

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

在屬性注解使用上，您既可以保持字段的持久性（注解寫在成員變量之上），也可以保持屬性（注解寫在getter方法之上）的持久性,但建議不要在屬性上引入注解，因?yàn)閷傩允莗rivate的，如果引入注解會破壞其封裝特性，所以建議在getter方法上加入注解

@Entity

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

@Table
在@Entity下使用，表示實(shí)體對應(yīng)數(shù)據(jù)庫中的表的信息

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

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

@Id

必須，定義了映射到數(shù)據(jù)庫表的主鍵的屬性，一個(gè)實(shí)體只能有一個(gè)屬性被映射為主鍵

@GeneratedValue

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


GenerationType.AUTO
根據(jù)底層數(shù)據(jù)庫自動選擇（默認(rèn)），若數(shù)據(jù)庫支持自動增長>類型，則為自動增長。



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


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


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

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

GenerationType.TABLE的使用

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

GenerationType.SEQUENCE的使用

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

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

@Transient

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

@Column

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

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

@Version

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

一些屬性

fetch

關(guān)聯(lián)關(guān)系獲取方式,即是否采用延時(shí)加載
Fetch.EAGER -  及時(shí)加載，是在查詢數(shù)據(jù)時(shí)，也直接一起獲取關(guān)聯(lián)對象的數(shù)據(jù)。多對一默認(rèn)是Fetch.EAGER  
Fetch.LAZY -延遲加載，查詢數(shù)據(jù)時(shí)，不一起查詢關(guān)聯(lián)對象的數(shù)據(jù)。而是當(dāng)訪問關(guān)聯(lián)對象時(shí)才觸發(fā)相應(yīng)的查詢操作，獲取關(guān)聯(lián)對象數(shù)據(jù)。一對多默認(rèn)是Fetch.LAZY

cascade

設(shè)置級聯(lián)方式
CascadeType.PERSIST 保存
CascadeType.REMOVE - 刪除
CascadeType.MERGE 修改 
CascadeType.REFRESH 刷新 
CascadeType.ALL - 全部

mappedBy

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

@OneToMany

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

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

@ManyToOne

表示一個(gè)多對一的映射，該注解標(biāo)注的屬性通常是數(shù)據(jù)庫表的外鍵。 單向多對一關(guān)聯(lián)在多方：
@ManyToOne(targetEntity=XXXX.class)   //指定關(guān)聯(lián)對象 
@JoinColumn(name="")  //指定產(chǎn)生的外鍵字段名

雙向一對多同雙向多對一

在多方 
@ManyToOne 
@JoinColumn(name="自己的數(shù)據(jù)庫外鍵列名")
在一方
@OneToMany(mappedBy="多端的關(guān)聯(lián)屬性名")

/*
 * 學(xué)生類負(fù)責(zé)關(guān)聯(lián)關(guān)系
 */
@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;
    }
}

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

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

因?yàn)槎鄬Χ嘀g會通過一張中間表來維護(hù)兩表直接的關(guān)系，所以通過JoinTable 這個(gè)注解來聲明。
 name就是指定了中間表的名字。
JoinColumns是一個(gè)@JoinColumn類型的數(shù)組，表示的是我這方在對方中的外鍵名稱，就是當(dāng)前類的主鍵。
inverseJoinColumns也是一個(gè)@JoinColumn類型的數(shù)組，表示的是對方在我這方中的外鍵名稱，也可以這樣想：上面提到mappedBy,相當(dāng)于inverse="true".所以,在@joinTable中的inverseJoinColumns中定義的字段為mappedBy所在類的主鍵。

在前面的基礎(chǔ)上增加課程類并補(bǔ)充學(xué)生類

/*
 * 學(xué)生類負(fù)責(zé)關(guān)聯(lián)關(guān)系
 */
@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;
    }
}