目錄

結合網上的一些知識，與實際應用情況，對JPA註解做了一些總結：

1.設定Pojo為實體

@Entity //標識這個pojo是一個jpa實體    
public class Users implements Serializable {    
}

2.設定表名

@Entity    
@Table(name = "users") //指定表名為users    
public class Users implements Serializable {    
} 

3.設定主鍵

public class Users implements Serializable {    
    @Id    
    private String userCode;
 

4. 設定欄位型別

通過@Column註解設定，包含的設定如下

name：表示資料庫表中該欄位的名稱,預設情形屬性名稱一致

unique：表示該欄位是否是唯一標識,預設為false

nullable：表示該欄位是否允許為null,預設為true

length: 表示該欄位的大小,僅對String型別的欄位有效

inserttable：表示在ORM框架執行插入操作時,該欄位是否應出現INSETRT語句中,預設為true

updateable：表示在ORM框架執行更新操作時,該欄位是否應該出現在UPDATE語句中,預設為true.對於一經建立就不可以更改的欄位,該屬性非常有用,如對於birthday欄位

columnDefinition: 表示該欄位在資料庫中的實際型別.通常ORM框架可以根據屬性型別自動判斷資料庫中欄位的型別,但是對於Date型別仍無法確定資料庫中欄位型別究竟是DATE,TIME還是TIMESTAMP.此外,String的預設對映型別為VARCHAR,如果要將String型別對映到特定資料庫的BLOB或TEXT欄位型別,該屬性非常有用

secondaryTable: 從表名。如果此列不建在主表上（預設建在主表），該屬性定義該列所在從表的名字。
 

//設定屬性userCode對應的欄位為user_code，長度為32，非空    
@Column(name = "user_code", nullable = false, length=32)
private String userCode;    

//設定屬性wages對應的欄位為user_wages，12位數字可保留兩位小數，可以為空
@Column(name = "user_wages", nullable = true, precision=12, scale=2)    
private double wages;    

//設定為時間型別，TemporalType有3種類型：TIMESTAMP,DATE,TIME
@Temporal(TemporalType.DATE)
private Date joinDate;
 

5.欄位排序

在載入資料的時候可以為其指定順序，使用@OrderBy註解實現

@Table(name = "USERS")    
public class User {    
    @OrderBy(name = "group_name ASC, name DESC")    
    private List books = new ArrayList();    
} 

Set集合為無序，不能使用@OrderBy.

6.主鍵生成策略

public class Users implements Serializable {    
    @Id    
    @GeneratedValue(strategy=GenerationType.IDENTITY)//主鍵自增，注意，這種方式依賴於具體的資料庫，如果資料庫不支援自增主鍵，那麼這個型別是沒法用的    
    @Column(name = "user_id", nullable = false)    
    private int userId;   
  
  
public class Users implements Serializable {    
    @Id    
    @GeneratedValue(strategy=GenerationType.TABLE)//通過一個表來實現主鍵id的自增，這種方式不依賴於具體的資料庫，可以解決資料遷移的問題    
    @Column(name = "user_code", nullable = false)    
    private String userCode;    
  
  
public class Users implements Serializable {    
    @Id    
    @GeneratedValue(strategy=GenerationType.SEQUENCE)//通過Sequence來實現表主鍵自增，這種方式依賴於資料庫是否有SEQUENCE，如果沒有就不能用    
    @SequenceGenerator(name="seq_user")    
    @Column(name = "user_id", nullable = false)    
    private int userId;

7.一對多對映關係

有T_One和T_Many兩個表，他們是一對多的關係，註解範例如下

(1) 雙向一對多關聯

主Pojo

@Entity    
@Table(name = "T_ONE")    
public class One implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "ONE_ID", nullable = false)    
    private String oneId;    
    @Column(name = "DESCRIPTION")    
    private String description;    

    @OneToMany(cascade = CascadeType.ALL, fetch=FetchType.LAZY, mappedBy = "oneId")//級聯，指向多的那方的pojo的關聯外來鍵欄位    
    private Collection<Many> manyCollection;

子Pojo

@Entity    
@Table(name = "T_MANY")    
public class Many implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "MANY_ID", nullable = false)    
    private String manyId;    
    @Column(name = "DESCRIPTION")    
    private String description;    
  
    //設定在“一方”pojo的外來鍵欄位上
    @ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH}, fetch = FetchType.LAZY) //cascade可不寫
    @JoinColumn(name = "ONE_ID", referencedColumnName = "ONE_ID")//設定對應資料表的列名和引用的資料表的列名，referencedColumnName可不寫 
    private One oneId;    

(2) 實體自關聯

示例一

@Entity
@Table(name = "ZCPLT_APP_APPMENUGRP")
public class AppMenuGroup extends BaseAuditEntity{
    private static final long serialVersionUID = 5910574382097344580L;
    @Column(name = "SN")
    private int serialNumber; //序號，選單分組排序
    	
    //optional:表示該屬性是否允許為null,預設為true
    @ManyToOne(optional = true)
    @JoinColumn(name = "PARENT_ID")
    private AppMenuGroup parent;
	
    @OneToMany(cascade = CascadeType.REMOVE, fetch = FetchType.LAZY, mappedBy = "parent")
    private Set<AppMenuGroup> children = new HashSet<AppMenuGroup>();

 示例二

@Entity
@Table(name = "ZCPLT_ROUTINEWORK_STAGE")
public class WorkStage extends BaseEntity {
	// 自關聯一對多
	@ManyToOne(cascade = {CascadeType.MERGE, CascadeType.REFRESH}, fetch = FetchType.LAZY, optional = true)
	@JoinColumn(name = "PARENT_ID")
	private WorkStage parent;
	
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "parent")
	private Set<WorkStage> workStages = new HashSet<>();
}

(3) 單向一對多關聯

新建表存關聯，而不在多的一方存外來鍵欄位。

@Entity
@Table(name = "ZCPLT_ROUTINEWORK")
public class RoutineWork extends BaseAuditEntity {
	/**
	 * 依據檔案列表。與Document一對多，新建表存關聯
	 */
	@OneToMany(cascade = CascadeType.ALL,fetch = FetchType.LAZY)
	@JoinTable(name = "ZCPLT_ROUTINEWORK_DOC")
	private Set<Document> documents = new HashSet<Document>();
}

(4) 單向多對一關聯

一方

@Entity      
@Table(name = "T_ONE")      
public class One implements Serializable {      
    private static final long serialVersionUID = 1L;      

    @Id      
    @Column(name = "ID", updatable = false, nullable = false, length = 36)      
    private String Id;

 }

多方

@Entity      
@Table(name = "T_MANY")      
public class Many implements Serializable {      
    private static final long serialVersionUID = 1L;      

    @Id      
    @Column(name = "ID", updatable = false, nullable = false, length = 36)   
    private String Id;

    //設定在“一方”pojo的外來鍵欄位上（cascade不寫）
    @ManyToOne
    //設定對應資料表的列名和引用的資料表的列名，referencedColumnName可不寫
    @JoinColumn(name = "ONE_ID", referencedColumnName = "ID")
    private One oneId;

8.多對多對映關係

多對多關係可以轉換成兩個一對多的關聯關係。多對多關係可以不需要設定級聯。

第一個Pojo

@Entity    
@Table(name = "T_MANYA")    
public class ManyA implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "MANYA_ID", nullable = false)    
    private String manyaId;    
    @Column(name = "DESCRIPTION")    
    private String description;    

    @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.REFRESH}, fetch = FetchType.LAZY) // 只需設定MERGE、REFRESH級聯即可，或者不設定   
    @JoinTable(name = "TMANY1_TMANY2", joinColumns = {@JoinColumn(name = "MANYA_ID", referencedColumnName = "MANYA_ID")}, inverseJoinColumns = {@JoinColumn(name = "MANYB_ID", referencedColumnName = "MANYB_ID")})    
    private Collection<ManyB> manybIdCollection;

   
第二個Pojo

@Entity    
@Table(name = "T_MANYB")    
public class ManyB implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "MANYB_ID", nullable = false)    
    private String manybId;    
    @Column(name = "DESCRIPTION")    
    private String description;    
    
    @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.REFRESH}, fetch = FetchType.LAZY, mappedBy = "manybIdCollection") 
    private Collection<ManyA> manyaIdCollection; 

解除關聯關係時，一般從主控方一端進行操作（有mappedby的一方為被控端）。

9.一對一對映關係

(1) 單向一對一

我們只需要通過一個實體得到其對應的實體，而且並不需要反向執行這個操作的時候。我們就需要使用單向一對一關係。舉例：人（man） 和 寵物（pet）。前提（一人只養一個寵物）
 

@Entity
@Table(name = "people")
public class People (){
     
     @Id  //JPA註釋： 主鍵 
     @GeneratedValue(strategy = GenerationType.AUTO)  //設定 id 為自增長
     private Long id;

     private String name;

     //由於，people 是這個一對一的關係的主控方，所以，在people表中添加了一個 pet 的外來鍵。
     //通過這個外來鍵來維護 people和pet的一對一關係，而不是用第三張碼錶。這個是通過@JoinColumn註釋實現的。
     @OneToOne //JPA註釋： 一對一 關係
     @JoinColumn(name="pet_fk" )// 在pepole中，新增一個外來鍵 "pet_fk"
     private Pet pet;

     //省略 get / set  方法...
}

@Entity
@Table(name = "pet")
public class Pet (){
     
     @Id  
     @GeneratedValue(strategy = GenerationType.AUTO)  
     private Long id;

     private String name;

     //省略 get / set  方法...
     //因為這是一個單向的一對一關係，並且，是從 people 到 pet 的一對一關係。
     //所以，在 pet 中沒有與 people 管理的 屬性。也就是說，無法通過 pet 找到 people 
}

(2) 雙向一對一

主Pojo

@Entity    
@Table(name = "T_ONEA")    
public class OneA implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "ONEA_ID", nullable = false)    
    private String oneaId;    

    @OneToOne(cascade = CascadeType.ALL) //級聯
    @JoinColumn(name = "ONEB_ID") //在表T_ONEA中，新增一個外來鍵"ONEB_ID"
    private OneB oneB; 

從Pojo

@Entity    
@Table(name = "T_ONEB")    
public class OneB implements Serializable {    
    private static final long serialVersionUID = 1L;    
    @Id    
    @Column(name = "ONEB_ID", nullable = false)    
    private String onebId;   

    //注意：由於是雙向的一對一關係。作為關係的被維護端。需要在OneB實體中新增和 OneA 關聯的屬性
    //mappedBy 註釋:指定了，這個實體是被關係維護端的那個屬性所維護。
    @OneToOne(mappedBy = "oneB")
    private OneA oneA;   

10.大欄位

Clob (Character Large Objects) 型別是長字串型別，具體的java.sql.Clob, Character[], char[] 和 java.lang.String 將被持久化為 Clob 型別；
Blob (Binary Large Objects) 型別是位元組型別，具體的java.sql.Blob, byte[] 和serializable type將被持久化為 Blob 型別。
注：mysql中沒有clob

//對應Clob欄位型別
@Lob    
@Column(name = "DESCRIPTION")    
private String description;

//對應Blob欄位型別
@Lob
@Column(name = "PHOTO")    
private Serializable photo;    

@Lob
@Basic(fetch = FetchType.LAZY)
@Column(name = "LOGO")
private byte[] logo;

11.瞬時欄位

不需要與資料庫對映的欄位，在儲存的時候不需要儲存到資料庫

@Transient    
private int tempValue;    
  
public int getTempValue(){    
get tempValue;    
}    
  
public void setTempValue(int value){    
this.tempValue = value;    
}

12.延遲載入

@Basc(fetch=FetchType.LAZY), 只有當使用屬性的get方法時才從資料中獲取！

13.@MappedSuperclass將超類的JPA註解傳遞給子類

可選，@MappedSuperclass可以將超類的JPA註解傳遞給子類,使子類能夠繼承超類的JPA註解

@MappedSuperclass 
public class Employee() { 
    .... 
}  

@Entity
public class Engineer extends Employee { 
    ..... 
} 

@Entity 
public class Manager extends Employee { 
   ..... 
}