@Entity(name="EntityName") 

必須,name為可選,對應資料庫中一的個表 

2、@Table(name="",catalog="",schema="") 
可選,通常和@Entity配合使用,只能標註在實體的class定義處,表示實體對應的資料庫表的資訊 
name:可選,表示表的名稱.預設地,表名和實體名稱一致,只有在不一致的情況下才需要指定表名 
catalog:可選,表示Catalog名稱,預設為Catalog(""). 
schema:可選,表示Schema名稱,預設為Schema(""). 

3、@id 
必須 
@id定義了對映到資料庫表的主鍵的屬性,一個實體只能有一個屬性被對映為主鍵.置於getXxxx()前. 

4、@GeneratedValue(strategy=GenerationType,generator="") 
可選 
strategy:表示主鍵生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4種,分別表示讓ORM框架自動選擇, 
根據資料庫的Identity欄位生成,根據資料庫表的Sequence欄位生成,以有根據一個額外的表生成主鍵,預設為AUTO 
generator:表示主鍵生成器的名稱,這個屬性通常和ORM框架相關,例如,Hibernate可以指定uuid等主鍵生成方式. 
示例: 
@Id 
@GeneratedValues(strategy=StrategyType.SEQUENCE) 
public int getPk() { 
return pk; 
} 

5、@Basic(fetch=FetchType,optional=true) 
可選 
@Basic表示一個簡單的屬性到資料庫表的欄位的對映,對於沒有任何標註的getXxxx()方法,預設即為@Basic 
fetch: 表示該屬性的讀取策略,有EAGER和LAZY兩種,分別表示主支抓取和延遲載入,預設為EAGER. 
optional:表示該屬性是否允許為null,預設為true 
示例: 
@Basic(optional=false) 
public String getAddress() { 
return address; 
} 

6、@Column 
可選 
@Column描述了資料庫表中該欄位的詳細定義,這對於根據JPA註解生成資料庫表結構的工具非常有作用. 
name:表示資料庫表中該欄位的名稱,預設情形屬性名稱一致 
nullable:表示該欄位是否允許為null,預設為true 
unique:表示該欄位是否是唯一標識,預設為false 
length:表示該欄位的大小,僅對String型別的欄位有效 
insertable:表示在ORM框架執行插入操作時,該欄位是否應出現INSETRT語句中,預設為true 
updateable:表示在ORM框架執行更新操作時,該欄位是否應該出現在UPDATE語句中,預設為true.對於一經建立就不可以更改的欄位,該屬性非常有用,如對於birthday欄位. 
columnDefinition: 表示該欄位在資料庫中的實際型別.通常ORM框架可以根據屬性型別自動判斷資料庫中欄位的型別,但是對於Date型別仍無法確定資料庫中欄位型別究竟是 DATE,TIME還是TIMESTAMP.此外,String的預設對映型別為VARCHAR,如果要將String型別對映到特定資料庫的BLOB或 TEXT欄位型別,該屬性非常有用. 
示例: 
@Column(name="BIRTH",nullable="false",columnDefinition="DATE") 
public String getBithday() { 
return birthday; 
} 

7、@Transient 
可選 
@Transient表示該屬性並非一個到資料庫表的欄位的對映,ORM框架將忽略該屬性. 
如果一個屬性並非資料庫表的欄位對映,就務必將其標示為@Transient,否則,ORM框架預設其註解為@Basic 
示例: 
//根據birth計算出age屬性 
@Transient 
public int getAge() { 
return getYear(new Date()) - getYear(birth); 
} 

8、@ManyToOne(fetch=FetchType,cascade=CascadeType) 
可選 
@ManyToOne表示一個多對一的對映,該註解標註的屬性通常是資料庫表的外來鍵 
optional:是否允許該欄位為null,該屬性應該根據資料庫表的外來鍵約束來確定,預設為true 
fetch:表示抓取策略,預設為FetchType.EAGER 
cascade:表示預設的級聯操作策略,可以指定為ALL,PERSIST,MERGE,REFRESH和REMOVE中的若干組合,預設為無級聯操作 
targetEntity:表示該屬性關聯的實體型別.該屬性通常不必指定,ORM框架根據屬性型別自動判斷targetEntity. 
示例: 
//訂單Order和使用者User是一個ManyToOne的關係 
//在Order類中定義 
@ManyToOne() 
@JoinColumn(name="USER") 
public User getUser() { 
return user; 
} 

9、@JoinColumn 
可選 
@JoinColumn和@Column類似,介量描述的不是一個簡單欄位,而一一個關聯欄位,例如.描述一個@ManyToOne的欄位. 
name:該欄位的名稱.由於@JoinColumn描述的是一個關聯欄位,如ManyToOne,則預設的名稱由其關聯的實體決定. 
例如,實體Order有一個user屬性來關聯實體User,則Order的user屬性為一個外來鍵, 
其預設的名稱為實體User的名稱+下劃線+實體User的主鍵名稱 
示例: 
見@ManyToOne 

10、@OneToMany(fetch=FetchType,cascade=CascadeType) 
可選 
@OneToMany描述一個一對多的關聯,該屬性應該為集體型別,在資料庫中並沒有實際欄位. 
fetch:表示抓取策略,預設為FetchType.LAZY,因為關聯的多個物件通常不必從資料庫預先讀取到記憶體 
cascade:表示級聯操作策略,對於OneToMany型別的關聯非常重要,通常該實體更新或刪除時,其關聯的實體也應當被更新或刪除 
例如:實體User和Order是OneToMany的關係,則實體User被刪除時,其關聯的實體Order也應該被全部刪除 
示例: 
@OneToMany(cascade=ALL) 
public List getOrders() { 
return orders; 
} 

11、@OneToOne(fetch=FetchType,cascade=CascadeType) 
可選 
@OneToOne描述一個一對一的關聯 
fetch:表示抓取策略,預設為FetchType.LAZY 
cascade:表示級聯操作策略 
示例: 
@OneToOne(fetch=FetchType.LAZY) 
public Blog getBlog() { 
return blog; 
} 

12、@ManyToMany 
可選 
@ManyToMany 描述一個多對多的關聯.多對多關聯上是兩個一對多關聯,但是在ManyToMany描述中,中間表是由ORM框架自動處理 
targetEntity:表示多對多關聯的另一個實體類的全名,例如:package.Book.class 
mappedBy:表示多對多關聯的另一個實體類的對應集合屬性名稱 
示例: 
User實體表示使用者,Book實體表示書籍,為了描述使用者收藏的書籍,可以在User和Book之間建立ManyToMany關聯 
@Entity 
public class User { 
private List books; 
@ManyToMany(targetEntity=package.Book.class) 
public List getBooks() { 
return books; 
} 
public void setBooks(List books) { 
this.books=books; 
} 
} 

@Entity 
public class Book { 
private List users; 
@ManyToMany(targetEntity=package.Users.class, mappedBy="books") 
public List getUsers() { 
return users; 
} 
public void setUsers(List users) { 
this.users=users; 
} 
} 
兩個實體間相互關聯的屬性必須標記為@ManyToMany,並相互指定targetEntity屬性, 
需要注意的是,有且只有一個實體的@ManyToMany註解需要指定mappedBy屬性,指向targetEntity的集合屬性名稱 
利用ORM工具自動生成的表除了User和Book表外,還自動生成了一個User_Book表,用於實現多對多關聯 

13、@MappedSuperclass 
可選 
@MappedSuperclass可以將超類的JPA註解傳遞給子類,使子類能夠繼承超類的JPA註解 
示例: 
@MappedSuperclass 
public class Employee() { 
.... 
} 

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

14、@Embedded 
可選 
@Embedded將幾個欄位組合成一個類,並作為整個Entity的一個屬性. 
例如User包括id,name,city,street,zip屬性. 
我們希望city,street,zip屬性對映為Address物件.這樣,User物件將具有id,name和address這三個屬性. 
Address物件必須定義為@Embededable 
示例: 
@Embeddable 
public class Address {city,street,zip} 
@Entity 
public class User { 
@Embedded 
public Address getAddress() { 
.......... 
} 
} 

Hibernate驗證註解 
註解 
適用型別 
說明 
示例 
@Pattern 
String 
通過正則表示式來驗證字串 
@attern(regex="[a-z]{6}") 
@Length 
String 
驗證字串的長度 
@length(min=3,max=20) 
@Email 
String 
驗證一個Email地址是否有效 
@email 
@Range 
Long 
驗證一個整型是否在有效的範圍內 
@Range(min=0,max=100) 
@Min 
Long 
驗證一個整型必須不小於指定值 
@Min(value=10) 
@Max 
Long 
驗證一個整型必須不大於指定值 
@Max(value=20) 
@Size 
集合或陣列 
集合或陣列的大小是否在指定範圍內 
@Size(min=1,max=255) 
以上每個註解都可能性有一個message屬性，用於在驗證失敗後向使用者返回的訊息，還可以三個屬性上使用多個註解 <!--v:3.2-->

****************************************************************************************************

[email protected] 
通過註釋@Entity或者（@Entity()）表示被標示的類對應資料庫中的一張表。 
} 
@Entity 
public class TravelProfile { 
... 
} 
上面的例子告訴O/R對映引擎，類TravelProfile是可以持久化的，同時它對應資料庫中的一張表。但是它沒有指明對應哪個資料庫中的哪張表。 
2.元資料對映標記 
2.1 @Table 
@Table()標記為實體初始化一張表，定義如下： 
@Target({TYPE}) @Retention(RUNTIME) 
public @interface Table { 
String name() default ""; 
String catalog() default ""; 
String schema() default ""; 
UniqueConstraint[] uniqueConstraints() default {}; 
} 
Name:指明表的名字。（可選） 
Catalog:表示表的catalog.（可選） 
Schema:表示表的schema.（可選） 
uniqueConstraints:制定表的唯一約束。（可選） 
因為所有的屬性都是可選的，也就是說@Table可以在進行對映的時候可以不標明。當不標明的情況下表的名字就是實體的類名。表屬於的schema就是所屬實體單元集的schema（就是當前連線資料庫的使用者）。 
下面給出的例子中，指明表為CUST,所屬的schema為RECORDS： 
@Entity 
@Table(name="CUST", schema="RECORDS") 
public class Customer { ... } 

2.2 @UniqueConstraint標記 
@UniqueConstraint用來指定表字段的唯一約束，定義如下： 
@Target({}) @Retention(RUNTIME) 
public @interface UniqueConstraint { 
String[] columnNames(); 
} 
columnNames：制定唯一約束的欄位。 

@Entity 
@Table( 
name="EMPLOYEE", 
uniqueConstraints= 
@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"}) 
) 
public class Employee { ... } 
上面的例子，唯一約束標記指定欄位EMP_ID和欄位EMP_NAME在表中EMPLOYEE中是唯一的。 

[email protected]標記 
@Column標記把實體的屬性或域對映到表的欄位，當沒有在實體的屬性或域中使用該標記那資料庫的對應表的欄位名就是實體的屬性名或域名。其定義為： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Column { 
String name() default ""; 
boolean unique() default false; 
boolean nullable() default true; 
boolean insertable() default true; 
boolean updatable() default true; 
String columnDefinition() default ""; 
String table() default ""; 
int length() default 255; 
int precision() default 0; // decimal precision 
int scale() default 0; // decimal scale 
} 
Name:指定欄位名。 
Unique：指明該欄位是否唯一，預設為false。 
Nullable：指明是否可以為空，預設是true。 
Insertable：指明該欄位在產生SQL INSERT語句中是否產生該欄位。 
Updatable：指明該欄位在產生SQL INSERT語句中是否產生該欄位。 
columnDefinition：指定產生表的時候，使用它指定該欄位一些屬性。 
Table：當一個實體對應多個表的時候，指定該欄位屬於哪個表。 
Length：制定該欄位的長度（只有在欄位為字元型別的才有用），預設是255。 
Precision: 指明欄位的精度（在欄位為decimal型別的時候使用），預設是0 
Scale：為欄位為number型指定標量，預設為0。 
下面給出例子： 
@Column(name="DESC", nullable=false, length=512) 
public String getDescription() { return description; } 

@Column(name="DESC", 
columnDefinition="CLOB NOT NULL", 
table="EMP_DETAIL") 
@Lob 
public String getDescription() { return description; } 

@Column(name="ORDER_COST", updatable=false, precision=12, scale=2) 
public BigDecimal getCost() { return cost; } 

[email protected]標記 
@JoinColumn標記用來對映實體之間的關聯關係，定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface JoinColumn { 
String name() default ""; 
String referencedColumnName() default ""; 
boolean unique() default false; 
boolean nullable() default true; 
boolean insertable() default true; 
boolean updatable() default true; 
String columnDefinition() default ""; 
String table() default ""; 
} 
Name:指定外來鍵欄位名，預設的名字是被引用實體在引用實體內部的屬性標量名或域名加上下劃線"_"，再加上被引用實體的主鍵欄位名構成。 
ReferencedColumnName：被引用表的欄位，如果沒有那預設的就是該表的主鍵。 
Unique：指明該欄位是否唯一，預設為false。 
Nullable：外來鍵是否可以為空，預設是true。 
Insertable：指明該欄位在產生SQL INSERT語句中是否產生該欄位。 
Updatable：指明該欄位在產生SQL INSERT語句中是否產生該欄位。 
columnDefinition：指定產生表的時候，使用它指定該欄位一些屬性。 
Table：當一個實體對應多個表的時候，指定該欄位屬於哪個表。 
下面例子的多對一關係中，指明瞭被引用實體在本實體的外來鍵為ADDR_ID。 
@ManyToOne 
@JoinColumn(name="ADDR_ID") 
public Address getAddress() { return address; } 

[email protected]標記 
@JoinColumns標記用在符合外來鍵的時候，這個時候屬性name和referencedColumnName必須在@JoinColumn中進行初始化。例如： 
@ManyToOne 
@JoinColumns({ 
@JoinColumn(name="ADDR_ID", referencedColumnName="ID"), 
@JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP") 
}) 
public Address getAddress() { return address; } 

[email protected]標記 
@Id標記把實體屬性或域對映到表的主鍵。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Id {} 
下面例子通過標記@Id初始化實體的主鍵為id，也可以通過加上標記@Column(name="PrimaryKey")自定義表的主鍵。 
@Id 
public Long getId() { return id; } 

[email protected]標記 
提供產生主鍵的策略，這就意味著它只能在出現標記@Id的情況下使用。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface GeneratedValue { 
GenerationType strategy() default AUTO; 
String generator() default ""; 
} 

public enum GenerationType { TABLE, SEQUENCE, IDENTITY, AUTO }; 
策略型別為列舉型別，共有四種類型分別為：TABLE, SEQUENCE, IDENTITY, AUTO。 
TABLE：提示持久化引擎實現者，使用資料庫的表來產生和維護主鍵。 
SEQUENCE和IDENTITY：分別指定使用當前資料庫的序列號和標識欄位來產生唯一表識。 
AUTO：制定持久化引擎實現者，為不同的資料庫選擇合適的策略產生唯一標識。 

Generator：制定主鍵產生器，預設有持久化實現者提供。例如： 
@Id 
@GeneratedValue(strategy=SEQUENCE, generator="CUST_SEQ") 
@Column(name="CUST_ID") 
public Long getId() { return id; } 

@Id 
@GeneratedValue(strategy=TABLE, generator="CUST_GEN") 
@Column(name="CUST_ID") 
Long id; 

2.[email protected]標記 
這個標記用來指定一個實體類作為一個另外一個實體的主鍵。這個時候要求實體的複合主鍵的每個屬性或域必須和複合主鍵類對應的屬性或域是一樣的。其定義如下： 
@Target({TYPE}) @Retention(RUNTIME) 
public @interface IdClass { 
Class value(); 
} 
下面例子中，複合主鍵類為EmployeePK，包含域empName和birthday型別分別為String,Date。 
@IdClass(com.jl.hr.EmployeePK.class) 
@Entity 
public class Employee { 
@Id String empName; 
@Id Date birthDay; 

[email protected]標記 
標記指示實體的屬性或域是非持久化的。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Transient {} 

下面的例子說明實體 Employee的域currentUser是非持久化的。 
@Entity 
public class Employee { 
@Id int id; 
@Transient User currentUser; 
... 
} 

[email protected]標記 
初始化實體的樂觀鎖的值，這個標記在大量併發訪問的實體中非常有用。如果要對實體使用這個標記那最好的策略是一個實體使用一個@Version標記，同時這個標記對應欄位的型別一般為：int,Integer,short,Short,long,Long,Timestamp中的一種。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Version {} 

給出相關的例子如下： 
@Version 
@Column(name="OPTLOCK") 
protected int getVersionNum() { return versionNum; } 

[email protected]標記 
此標記初始化實體的屬性或域對映成資料庫支援的大物件型別。大物件可以是字元也可以是二進位制型別。除了字串和字元型別的預設對映成Blob型別，其它的型別根據實體屬性或域的型別來決定資料庫大物件的型別。例如： 
@Lob 
@Column(name="REPORT") 
protected String report; 

@Lob @Basic(fetch=LAZY) 
@Column(name="EMP_PIC", columnDefinition="BLOB NOT NULL") 
protected byte[] pic; 

[email protected]標記 
用來指定實體持久化屬性的為列舉型別，其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Enumerated { 
EnumType value() default ORDINAL; 
} 

public enum EnumType { 
ORDINAL, 
STRING 
} 
如果標記沒有顯性給出或者EnumType沒有指定，那列舉型別預設為ORDINAL數字標識。例如： 
public enum EmployeeStatus {FULL_TIME, PART_TIME, CONTRACT} 
public enum SalaryRate {JUNIOR, SENIOR, MANAGER, EXECUTIVE} 
@Entity public class Employee { 
... 
public EmployeeStatus getStatus() {...} 
@Enumerated(STRING) 
public SalaryRate getPayScale() {...} 
... 
} 
上面例子中，定義了兩個列舉型別EmployeeStatus和SalaryRate。在實體兩個屬性status型別為EmployeeStatus，而payScale為SalaryRate型別。其中一個顯性給出了標記@Enumerated(STRING)來說明列舉型別的值當成字串使用，而預設的是從1開始的數字來標識的。也可以通過標記@Enumerated(ORDINAL)指示列舉裡面型別的值是數字型別的。例如在EmployeeStatus 
中的FULL_TIME, PART_TIME, CONTRACT分別代表的數字是1，2，3，4而SalaryRate 
中的JUNIOR, SENIOR, MANAGER, EXECUTIVE代表的分別是字串"JUNIOR", "SENIOR", "MANAGER", "EXECUTIVE"。 

[email protected]標記 
當實體之間的關係是多對一的時候，該標記定義一個單值的欄位與其它實體相關聯。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface ManyToOne { 
Class targetEntity() default void.class; 
CascadeType[] cascade() default {}; 
FetchType fetch() default EAGER; 
boolean optional() default true; 
} 

public enum CascadeType { ALL, PERSIST, MERGE, REMOVE, REFRESH}; 

targetEntity：表示相關聯的實體類。 
Cascade：級聯操作選項，PERSIST, MERGE, REMOVE, REFRESH分別對應增加，更新，刪除和查詢的聯級設定選項。如果選擇ALL就使得前面這些聯級都生效，也就是cascade=ALL 等同於cascade={PERSIST, MERGE, REMOVE,REFRESH} 
Fetch：制定關聯實體的載入方式，包括EAGER和LAZY兩種方式。當為EAGER選選項的時候，當查詢實體的時候會把它相關聯的實體例項也載入。當為LAZY的時候載入實體例項的時候與之相關聯的實體例項不會載入,預設為EAGER。 
Optional：指定關聯實體關係是否可以為空，預設是為true。當為false的時候，那當有實體例項的存在總會有與之相關實體例項的存在。 
例如： 
@ManyToOne(optional=flase) 
@JoinColumn(name="CUST_ID", nullable=false, updatable=false) 
public Customer getCustomer() { return customer; } 

[email protected]標記 
標記定義實體一對一關係的聯絡，通過一個欄位來進行關聯。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface OneToOne { 
Class targetEntity() default void.class; 
CascadeType[] cascade() default {}; 
FetchType fetch() default EAGER; 
boolean optional() default true; 
String mappedBy() default ""; 
} 
前面四個選項和8.2.13中的意義是一樣的。 
mappedBy：代表這個屬性或域是關係的擁有者，也就是說mappedBy選擇應該是在非關係擁有者方才會出現。所謂關係的擁有者就是在表中包含了關係欄位的那張表。 
現在假設有實體Customer和實體CustomerRecoder它們之間是一對一的關係，同時實體Customer是關係的擁有者。這個時候通過標記@OneToOne來完成關聯，在實體Customer相關程式碼如下： 
@OneToOne(optional=false) 
@JoinColumn( 
name="CUSTREC_ID", unique=true, nullable=false, updatable=false) 
public CustomerRecord getCustomerRecord() { return customerRecord; } 
在實體CustomerRecord相關程式碼如下： 
@OneToOne(optional=false, mappedBy="customerRecord") 
public Customer getCustomer() { return customer; } 
因為CustomerRecord是關係的非擁有者所有mappedBy只能在這邊出現。 


[email protected]標記 
用來標記實體之間的一對多的關係，其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface OneToMany { 
Class targetEntity() default void.class; 
CascadeType[] cascade() default {}; 
FetchType fetch() default LAZY; 
String mappedBy() default ""; 
} 
值得注意的是表示關聯實體的集合要使用範形來制定集合內部的關聯實體，否則必須要指定targetEntity的實體型別。Fetch型別預設為LAZY而@OneToOne和ManyToOne則預設的為EAGER。 
假設現在有實體Customer和Order它們之間的關係是一對多的關係，同時Order是關係的擁有者。 
在實體Customer中的程式碼為： 

@OneToMany(cascade=ALL, mappedBy="customer") 
public Set<Order> getOrders() { return orders; } 

在實體Order中的程式碼為： 

@ManyToOne 
@JoinColumn(name="CUST_ID", nullable=false) 
public Customer getCustomer() { return customer; } 

[email protected]標記 
用來對映多對多和單項的一對多關係，當不是用該標記的時候會根據預設的對映原則產生關係連線表。其定義如下： 
public @interface JoinTable { 
String name() default ""; 
String catalog() default ""; 
String schema() default ""; 
JoinColumn[] joinColumns() default {}; 
JoinColumn[] inverseJoinColumns() default {}; 
UniqueConstraint[] uniqueConstraints() default {}; 
} 
Name：指定連線表的名字。 
Catalog：指定表所屬的catalog。 
Schema：指定表所屬的schema。 
joinColumns：指定關係擁有方作為外來鍵的主鍵。 
inverseJoinColumns：指定關係非擁有方作為外來鍵的主鍵。 
uniqueConstraints：指定表中的唯一約束。 
例如： 
@JoinTable( 
name="CUST_PHONE", 
joinColumns= 
@JoinColumn(name="CUST_ID", referencedColumnName="ID"), 
inverseJoinColumns= 
@JoinColumn(name="PHONE_ID", referencedColumnName="ID") 
) 
上面例子，連線表的名字為CUST_PHONE裡面有兩個外來鍵，一個來自關係擁有方的主鍵ID對應外來鍵為CUST_ID；另一個是來自於關係的非擁有方的主鍵ID對應外來鍵為PHONE_ID。 
[email protected]標記 
標記實體之間的多對多的關係，如果不通過範形來制定集合中的關聯實體型別那必須指定相應的關聯實體型別。其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface ManyToMany { 
Class targetEntity() default void.class; 
CascadeType[] cascade() default {}; 
FetchType fetch() default LAZY; 
String mappedBy() default ""; 
} 
各個屬性的意義和標記@OneToMany是一樣的，請參照8.2.1.15。 
如果關聯是雙向的兩邊都可以是關係的擁有方，可以通過標記@JoinTable來制定關係擁有方，請參照2.16。 
設有實體Customer和PhoneNumber，則它們的關係對映程式碼如下： 
在實體Customer中為： 
@ManyToMany 
@JoinTable(name="CUST_PHONES") 
public Set<PhoneNumber> getPhones() { return phones; } 
在實體PhoneNumber中為： 
@ManyToMany(mappedBy="phones") 
public Set<Customer> getCustomers() { return customers; } 
在實際開發中，對於多對多關係我們經常使用標記@JoinTable來制定關係的擁有方，則對於上面的對映為： 
@ManyToMany 
@JoinTable( 
name="CUST_PHONE", 
joinColumns= 
@JoinColumn(name="CUST_ID", referencedColumnName="ID"), 
inverseJoinColumns= 
@JoinColumn(name="PHONE_ID", referencedColumnName="ID") 
) 
public Set<PhoneNumber> getPhones() { return phones; } 

@ManyToMany(mappedBy="phones") 
public Set<Customer> getCustomers() { return customers; } 

[email protected]標記 
指定批量查詢例項例項的時候指定排序的屬性或域，其定義如下： 
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface OrderBy { 
String value() default ""; 
} 
對於使用該標記對應的欄位必須是可以比較的，預設的使用的是ASC也可以根據需求改變成DESC。當沒有指定value的時候，那預設的就是對實體的主鍵進行排序，例如： 
@Entity public class Course { 
... 
@ManyToMany 
@OrderBy("lastname ASC") 
public List<Student> getStudents() {...}; 
... 
} 
@Entity public class Student { 
... 
@ManyToMany(mappedBy="students") 
@OrderBy // PK is assumed 
public List<Course> getCourses() {...}; 
... 
}