1、配置對映關係的xml方式

我們知道，Hibernate是一個典型的ORM框架，用以解決物件和關係的不匹配。其思想就是將關係資料庫中表的記錄對映成為物件，以物件形式展現，這樣一來，就可以把對資料庫的操作轉化為對物件的操作。 而ORM一般是採用xml的格式儲存物件與關係資料表的對映，我們也可以從下面示例中看到hibernate中的一個對映配置表的表現形式：

1. <?xml version="1.0" encoding="utf-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping>
5. <classname="com.zker.model.job.SysJob"table="SYS_JOB"lazy="true">
6. <idname="jobId"column="JOB_ID">
7. <generatorclass="sequence">
8. <paramname="sequence">SEQ_SYS_JOB</param>
9. </generator>
10. </id>
11. <propertyname="jobName"type="string"column="JOB_NAME"/>
12. <propertyname="jobDesc"type="string"column="JOB_DESC"/>
13. <propertyname="lastModity"type="timestamp"column="LAST_MODIFY"/>
14. <!--與使用者關聯-->
15. <setname="sysUsers"table="SYS_USER">
16. <keycolumn="JOB_ID"/>
17. <one-to-many
    class="com.zker.model.user.SysUser"/>
18. </set>
19. </class>
20. </hibernate-mapping>

其中對應的實體類和資料庫表結構如下：

1. publicclassSysJob{
2. /**職位的主鍵ID*/
3. privateint jobId;
4. /**職位的名稱*/
5. privateString jobName;
6. /**職位的描述*/
7. privateString jobDesc;
8. /**職位的修改時間*/
9. privateTimestamp lastModity;
10. /**職位所對應的使用者*/
11. privateSet<SysUser> sysUsers =newHashSet<SysUser>();
12. publicint getJobId(){
13. return jobId;
14. }
15. publicvoid setJobId(int jobId){
16. this.jobId = jobId;
17. }
18. publicString getJobName(){
19. return jobName;
20. }
21. publicvoid setJobName(String jobName){
22. this.jobName = jobName;
23. }
24. publicString getJobDesc(){
25. return jobDesc;
26. }
27. publicvoid setJobDesc(String jobDesc){
28. this.jobDesc = jobDesc;
29. }
30. publicTimestamp getLastModity(){
31. return lastModity;
32. }
33. publicvoid setLastModity(Timestamp lastModity){
34. this.lastModity = lastModity;
35. }
36. publicSet<SysUser> getSysUsers(){
37. return sysUsers;
38. }
39. publicvoid setSysUsers(Set<SysUser> sysUsers){
40. this.sysUsers = sysUsers;
41. }
42. }

2、註解的優點

而完成這個ORM對映關係配置的方式，還有一種，就是使用註解。

• 充分利用 Java 的反射機制獲取類結構資訊，這些資訊可以有效減少配置的工作
• 註釋和 Java 程式碼位於一個檔案中，有助於增強程式的內聚性，便於程式設計師開發
  

我們可以看如下的一個示例來感受這種形式：

1. @Entity
2. @Table(name ="t_student")
3. @Domain(name ="學生")
4. @Generated
5. @DataIdentify(identifies ="number")
6. publicclassStudentextendsBaseDomain<Student>implementsAddable,Modifiable<Student>,Deletable{
7. privateString name;
8. privateString number;
9. privateSex sex;
10. @Basic
11. @NotSemanticNull(groups ={Groups.Add.class,Groups.Update.class})
12. @Property(name ="姓名")
13. publicString getName(){
14. return name;
15. }
16. publicvoid setName(String name){
17. this.name = name;
18. }
19. ...
20. }

3、常用註解的使用方法

3.1 類級別的註解

• @Entity     對映實體類
  
• @Table      對映數句庫表
  

@Entity(name = "tableName") - 必須，註解將一個類宣告為一個實體bean，即指出該Java 類為實體類，將對映到指定的資料庫表

• 屬性：
  
• name - 可選，對應資料庫中的一個表。若表名與實體類名相同，則可以省略
  

@Table(name = "", catalog = "", schema = "")  - 可選，通常和@Entity 配合使用，只能標註在實體的 class 定義處，表示實體對應的資料庫表的資訊

• 屬性：
  
• name - 可選，表示表的名稱，預設的表名和實體名稱一致，只有在不一致的情況下才需要指定表名
  
• catalog - 可選，表示Catalog 名稱，預設為 Catalog("")
  
• schema - 可選 , 表示 Schema 名稱 , 預設為Schema("")
  

3.2 屬性級別的註解

• @Id                                 對映生成主鍵
  
• @GeneratedValue         定義主鍵生成策略
  
• @SequenceGenerator  聲明瞭一個數據庫序列
  
• @Version                       定義樂觀鎖
  
• @Basic                           宣告屬性的存取策略
  
• @Column                       對映表的列
  
• @Transient                    定義暫態屬性
  

屬性級別的註解，都是放在其對應的getter前。

3.2.1 與主鍵相關注解

@Id - 必須，定義了對映到資料庫表的主鍵的屬性，一個實體只能有一個屬性被對映為主鍵，置於 getXxx() 前
@GeneratedValue(strategy = GenerationType , generator="") - 可選，用於定義主鍵生成策略

• 屬性：
  
• 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使用
• generator - 表示主鍵生成器的名稱，這個屬性通常和ORM框架相關 , 例如：Hibernate 可以指定 uuid 等主鍵生成方式
  

@SequenceGenerator — 註解聲明瞭一個數據庫序列

• 屬性：
  
• name - 表示該表主鍵生成策略名稱，它被引用在@GeneratedValue中設定的“gernerator”值中
  
• sequenceName - 表示生成策略用到的資料庫序列名稱
  
• initialValue - 表示主鍵初始值，預設為0
  
• allocationSize - 每次主鍵值增加的大小，例如設定成1，則表示每次建立新記錄後自動加1，預設為50
  

3.2.2 與非主鍵相關注解

@Version - 可以在實體bean中使用@Version註解，通過這種方式可新增對樂觀鎖定的支援（見參考連結）
@Basic - 用於宣告屬性的存取策略：

• @Basic(fetch=FetchType.EAGER)   即時獲取（預設的存取策略）
  
• @Basic(fetch=FetchType.LAZY)       延遲獲取
  

@Column - 可將屬性對映到列，使用該註解來覆蓋預設值，@Column描述了資料庫表中該欄位的詳細定義

• 屬性：
  
• name - 可選，表示資料庫表中該欄位的名稱，預設情形屬性名稱一致
  
• nullable - 可選，表示該欄位是否允許為 null，預設為 true
  
• unique - 可選，表示該欄位是否是唯一標識，預設為 false
  
• length - 可選，表示該欄位的大小，僅對 String 型別的欄位有效，預設值255
  
• insertable - 可選，表示在ORM框架執行插入操作時，該欄位是否應出現INSETRT語句中，預設為 true
  
• updateable - 可選，表示在ORM 框架執行更新操作時，該欄位是否應該出現在UPDATE 語句中，預設為 true。對於一經建立就不可以更改的欄位，該屬性非常有用，如對於 birthday 欄位
  
• columnDefinition - 可選，表示該欄位在資料庫中的實際型別。通常ORM 框架可以根據屬性型別自動判斷資料庫中欄位的型別，但是對於Date 型別仍無法確定資料庫中欄位型別究竟是 DATE,TIME 還是 TIMESTAMP. 此外 ,String 的預設對映型別為 VARCHAR, 如果要將 String 型別對映到特定資料庫的 BLOB或 TEXT 欄位型別，該屬性非常有用
  

@Transient - 可選，表示該屬性並非一個到資料庫表的欄位的對映，ORM框架將忽略該屬性，如果一個屬性並非資料庫表的欄位對映，就務必將其標示為@Transient，否則ORM框架預設其註解為 @Basic

3.3 對映實體類的關聯關係

單向一對多：一方有集合屬性，包含多個多方，而多方沒有一方的引用。使用者--->電子郵件 單向多對一：多方有一方的引用，一方沒有多方的引用。論文類別---> 類別 雙向一對多：兩邊都有多方的引用，方便查詢。班級---> 學生 雙向多對一：兩邊都有多方的引用，方便查詢。 單向多對多：需要一箇中間表來維護兩個實體表。論壇--->文章 單向一對一：資料唯一，資料庫資料也是一對一。艦船---> 水手 主鍵相同的一對一：使用同一個主鍵，省掉外來鍵關聯。客戶---> 地址

3.3.1 關聯對映的一些共有屬性

@JoinColumn - 可選，用於描述一個關聯的欄位。@JoinColumn和@Column類似，介量描述的不是一個簡單欄位，而是一個關聯欄位，例如描述一個 @ManyToOne 的欄位。（即用來定義外來鍵在我們這個表中的屬性名，例如實體Order有一個User user屬性來關聯實體User，則Order的user屬性為一個外來鍵）

• 屬性：
  
• name - 該欄位的名稱，由於@JoinColumn描述的是一個關聯欄位，如ManyToOne, 則預設的名稱由其關聯的實體決定
  

@OneToOne、@OneToMany、@ManyToOne、ManyToMany 的共有屬性：

• fetch - 配置載入方式。取值有：
  
  • Fetch.EAGER -  及時載入，多對一預設是Fetch.EAGER 
  • Fetch.LAZY - 延遲載入，一對多預設是Fetch.LAZY
• cascade - 設定級聯方式，取值有：
  
  • CascadeType.PERSIST - 儲存
  • CascadeType.REMOVE - 刪除
  • CascadeType.MERGE - 修改
  • CascadeType.REFRESH - 重新整理
  • CascadeType.ALL - 全部
• targetEntity - 配置集合屬性型別，如：@OneToMany(targetEntity=Book.class)
  

@OneToOne – 表示一個一對一的對映

1. 主表類A與從表類B的主鍵值相對應
2. 主表：
3. @OneToOne(cascade =CascadeType.ALL)
4. @PrimaryKeyJoinColumn
5. public B getB(){
6. return b;
7. }
8. 從表：無

1. 主表A中有一個從表屬性是B型別的b
2. 主表：
3. @OneToOne(cascade =CascadeType.ALL)
4. @JoinColumn(name="主表外來鍵")//這裡指定的是資料庫中的外來鍵欄位。
5. public B getB(){
6. return b;
7. }
8. 從表：無

1. 主表A中有一個從表屬性是B型別的b，同時，從表B中有一個主表屬性是A型別的a
2. 主表：
3. @OneToOne(cascade =CascadeType.ALL)
4. @JoinColumn(name="主表外來鍵")//這裡指定的是資料庫中的外來鍵欄位。
5. public B getB(){
6. return b;
7. }
8. 從表：
9. @OneToOne(mappedBy ="主表類中的從表屬性")
10. public主表類 get主表類(){
11. return主表物件
12. }

@ManyToOne - 表示一個多對一的對映，該註解標註的屬性通常是資料庫表的外來鍵

1. 單向多對一：多方有一方的引用，一方沒有多方的引用
2. 在多方
3. @ManyToOne(targetEntity=XXXX.class)//指定關聯物件
4. @JoinColumn(name="")//指定產生的外來鍵欄位名

1. 雙向多對一：配置方式同雙向一對多

1. // 示例
2. // 訂單 Order 和使用者 User 是一個 ManyToOne 的關係
3. // 在 Order 類中定義
4. @ManyToOne()
5. @JoinColumn(name="USER")
6. publicUser getUser(){
7. return user;
8. }

@OneToMany - 描述一個一對多的關聯，該屬性應該為集合型別，在資料庫中並沒有實際欄位

1. 單向一對多：一方有集合屬性，包含多個多方，而多方沒有一方的引用
2. @OneToMany預設會使用連線表做一對多關聯
3. 新增@JoinColumn(name="xxx_id")後，就會使用外來鍵關聯，而不使用連線表了

1. 雙向一對多：
2. 1）在多方
3. @ManyToOne
4. @JoinColumn(name="自己的資料庫外來鍵列名")
5. 2）在一方
6. @OneToMany(mappedBy="多端的關聯屬性名")
7. @JoinColumn(name="對方的資料庫外來鍵列名")

@ManyToMany - 可選，描述一個多對多的關聯

• 屬性：
  
• targetEntity - 表示多對多關聯的另一個實體類的全名，例如：package.Book.class
  
• mappedBy - 用在雙向關聯中，把關係的維護權翻轉。
  

1. 單向多對多關聯：
2. 在主控方加入@ManyToMany註解即可。

1. 雙向多對多關聯：
2. 兩個實體間互相關聯的屬性必須標記為@ManyToMany，並相互指定targetEntity屬性。
3. 有且只有一個實體的@ManyToMany註解需要指定mappedBy屬性，指向targetEntity的集合屬性名稱。

3.3.2 關聯對映的其他補充

@JoinTable其實同時也是配合@ManyToMany使用的，@ManyToMany註釋表示該物件是多對多關係的一端，然後利用@JoinTable來定義關聯關係（利用中間表來建立聯絡，原因戳這裡），其中name屬性指定中間表名稱，joinColumns定義中間表與該表的外來鍵關係，inverseJoinColumns屬性定義了中間表與另外一端的外來鍵關係。 @JoinTable - 定義關聯表， 該關聯表包含了指回實體表的外來鍵(通過@JoinTable.joinColumns) 以及指向目標實體表的外來鍵(通過@JoinTable.inverseJoinColumns)

1. e.g.
2. 如下表示：該屬性對應欄位為"resource_type"，該欄位實際在另外一張名"r_role_x_resource_type"表中，與該表（"p_role"）通過"role_id"進行外來鍵連結
3. （class Role --> table "p_role"）
4. @ElementCollection
5. @JoinTable(name ="r_role_x_resource_type", joinColumns =@JoinColumn(name ="role_id"))
6. @Column(name ="resource_type")
7. @JSONField(serialize =false)
8. @Cache(usage =CacheConcurrencyStrategy.NONE)
9. publicList<Class<?extendsResourceable>> getResourceTypeList(){
10. return resourceTypeList;
11. }

1. e.g.
2. 如下表示：關聯的表為“r_role_x_permission"，其中關聯外來鍵為"role_id"，該表又通過"permission_id"連結第三張表，即目標實體表
3. （class Role --> table "p_role"）
4. @ManyToMany
5. @JoinTable(name ="r_role_x_permission", joinColumns =@JoinColumn(name ="role_id"),
6. inverseJoinColumns =@JoinColumn(name ="permission_id"))
7. publicList<Permission> getPermissionList(){
8. return permissionList;
9. }

4、其他註解

@DiscriminatorValue - 一張表對應一整棵類繼承樹時，該類別對應的“表part”
首先參考這篇文章，很重要：hibernate對映繼承關係(一)：一張表對應一整棵類繼承樹，從文中可以知道，用一個表來儲存對應的整個類別的資料，比如有Cat和Animal，Cat是Animal的子類，我僅用Animal一個表來儲存Animal和Cat的欄位和資料，而不是分成兩個表。那麼當我進行對映關係的時候，假如我要Cat類對映到Animal中Cat的部分，如何處理？在Animal中定義一個欄位用來區分不同的表，比如Animal表中我額外增加欄位名為Type，那麼在Animal這一張表中，我們本屬於Animal表內容的，該欄位我們設定為animal，本屬於Cat表的，該欄位我們設定為cat。你可以理解為，新增加欄位來用以在同一個表中區分不同類別的內容。 所以對應在註解上的使用的一個對映關係表示，就是這樣的：對於”父類“，即準備用來囊括所有內容的那個表，我們需要定義這個對應的類為 @DiscriminatorColumn(name = "xxx", discriminatorType = DiscriminatorType.xxx) ，這裡的name就是指定表中用來區別各類內容的欄位，而對於”子類“，我們需要註解標明@DiscriminatorValue(xxx)，這裡的xxx即對應了父類中的 “區別用欄位” 裡的標識。 舉例來說，就是假如我們希望將Animal和Cat的內容都只儲存在Animal這張表裡，那麼為了區分內容，我們對於Animal這個表新增某欄位如 type；Animal的類，註解為@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING) ，同時設定@DiscriminatorValue("animal")；Cat extends Animal，Cat的類，註解為@DiscriminatorValue(“cat")；那麼Animal這個表中，欄位type中，為animal的元組對映Animal類，為cat的元組對映Cat類。 而這種方式，多用於資料庫字典概念。