JPA註解持久化類很方便，需要jar包：ejb3-persistence.jar。我用以下三個類來說明用法。
sh原創 轉載請註明：http://67566894.iteye.com/blog/659829
Java程式碼  

1. @SuppressWarnings("serial")  
2. @Entity
3. @Table(name="T_X")  
4. publicclass X implements Serializable  
5. {  
6.     @Id
7.     @GeneratedValue(strategy = GenerationType.AUTO)  
8.     privateint id;  
9.     @Column(length=32)  
10.     private String name;  
11.          @Transient
    //表示此資料不在資料庫表裡建立屬性
12.          private String temp;  
13.     @Temporal(TemporalType.TIMESTAMP) //這個是帶時分秒的型別
14.     private Date date;  
15.     @OneToOne(cascade = CascadeType.ALL, mappedBy = "x")  
16.     private A a;  
17. }  
18. @SuppressWarnings("serial")  
19. @Entity
20. @Table(name="T_A")  
21. publicclass A implements Serializable  
22. {  
23.     @Id
24.     @GeneratedValue(strategy = GenerationType.AUTO)  
25.     privateint id;  
26.     @OneToMany(cascade = CascadeType.ALL, mappedBy = "a", fetch = FetchType.EAGER)  
27.     private List<B> b = new ArrayList<B>();  
28.     @OneToOne()  
29.     @JoinColumn(name = "x_Id") //加這句後就會雙方共同維護關係
30.     private X x;  
31. }  
32. @SuppressWarnings
    ("serial")  
33. @Entity
34. publicclass B implements Serializable{  
35.          @Id
36.     @GeneratedValue(strategy = GenerationType.AUTO)  
37.     protectedint id;  
38.     @ManyToOne()  
39.     @JoinColumn(name = "a_id")  
40.     protected A a;  
41. }  

要注意的是：fetch = FetchType.EAGER這句話在一個類裡面只能出現一次，出現兩次就會報錯“cannot simultaneously fetch multiple bags”，要把其他的改為fetch = FetchType.LAZY延遲載入就可以了。聽說把List集合改為Set也能解決這個錯誤。

其他要點：
1、@Table(name="T_X")這句話可以不寫，不寫就已類名作為表名

2、如果想讓兩個類的屬性生成一個數據表，在一個類裡這樣加入另一個類即可： @Embedded
private C c;

3、如果想要一個類繼承另一個類的所有屬性，則在父類裡這樣寫：
@SuppressWarnings("serial")
@Entity
@MappedSuperclass   //增加這一行
並把父類的所有屬性的private改為protected即可

4、建議在一對多關聯中在"一"方用延遲載入"多"方可以在HQL中顯式的"迫切左外連線" left join fetch 這樣做Hibernate可以少訪問資料庫,也可以用"@BatchSize(size = 5)"來減少訪問資料庫的次數


1. @Id 宣告屬性為主鍵


2. @GeneratedValue表示主鍵是自動生成策略，一般該註釋和 @Id 一起使用


3. @Entity 任何 hibernte 對映物件都要有次註釋


4. @Table(name = “tablename”) 類宣告此物件對映到哪個表


5. @Column(name = “Name”,nullable=false,length=32) 宣告資料 庫欄位和類屬性對應關係


6. @Lob 宣告欄位為 Clob 或 Blob 型別



7. @OneToMany(mappedBy=”order”,cascade = CascadeType.ALL, fetch = FetchType.LAZY)
   @OrderBy(value = “id ASC”)
   一對多宣告，和 ORM 產品宣告類似，一看就明白了。
   @ManyToOne(cascade=CascadeType.REFRESH,optional=false)
   @JoinColumn(name = “order_id”)
   宣告為雙向關聯


8. @Temporal(value=TemporalType.DATE) 做日期型別轉換。



9. @OneToOne(optional= true,cascade = CascadeType.ALL, mappedBy = “person”)
   一對一關聯宣告
   @OneToOne(optional = false, cascade = CascadeType.REFRESH)
   @JoinColumn(name = “Person_ID”, referencedColumnName = “personid”,unique = true)
   宣告為雙向關聯



10. @ManyToMany(mappedBy= “students”)
   多對多關聯宣告。
  @ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
  @JoinTable(name = “Teacher_Student”,
    joinColumns = {@JoinColumn(name = “Teacher_ID”, referencedColumnName = “teacherid”)},
    inverseJoinColumns = {@JoinColumn(name = “Student_ID”, referencedColumnName =
    “studentid”)})
   多對多關聯一般都有個關聯表，是這樣宣告的！



11. @Transiten表示此屬性與表沒有對映關係，是一個暫時的屬性



12. @Cache(usage= CacheConcurrencyStrategy.READ_WRITE)表示此物件應用快取


JPA規範
@Entity：通過@Entity註解將一個類宣告為一個實體bean

@Table：通過 @Table註解可以為實體bean對映指定表，name屬性表示實體所對應表的名稱，如果沒有定義 @Table，那麼系統自動使用預設值：實體的類名（不帶包名）

@Id：用於標記屬性的主鍵

@Column：表示持久化屬性所對映表中的欄位，如果屬性名與表中的欄位名相同，則可以省略@Column註解，另外有兩種方式標記，一是放在屬性前，另一種是放在getter方法前，例如：

@Column(name = "EMPLOYEE_NAME")

private String employee_name; 或者

@Column(name = "EMPLOYEE_NAME")

public String getEmployee_name() {

return employee_name;

} 這兩種方式都是正解的，根據個人喜好來選擇。大象偏向於第二種，並且喜歡將屬性名與欄位名設成一樣的，這樣可以省掉@Column註解，使程式碼更簡潔。



@Temporal(TemporalType.DATE)：如果屬性是時間型別，因為資料表對時間型別有更嚴格的劃分，所以必須指定具體時間型別，如④所示。在javax.persistence.TemporalType列舉中定義了3種時間型別：

通過 @Temporal 定義對映到資料庫的時間精度：
@Temporal(TemporalType.DATE)       日期
@Temporal(TemporalType.TIME)       時間
@Temporal(TemporalType.TIMESTAMP) 兩者兼具

                 

@Temporal只是起對映作為



@Transient  

@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface Transient {}

指明一個屬性或方法不能持久化





@TableGenerator：表生成器，將當前主鍵的值單獨儲存到一個數據庫表中，主鍵的值每次都是從指定的表中查詢來獲得，這種生成主鍵的方式是很常用的。這種方法生成主鍵的策略可以適用於任何資料庫，不必擔心不同資料庫不相容造成的問題。大象推薦這種方式管理主鍵，很方便，集中式管理表的主鍵，而且更換資料庫不會造成很大的問題。各屬性含義如下：

        name：表示該表主鍵生成策略的名稱，這個名字可以自定義，它被引用在@GeneratedValue中設定的"generator"值中

        table：表示表生成策略所持久化的表名，說簡單點就是一個管理其它表主鍵的表，本例中，這個表名為GENERATOR_TABLE

        pkColumnName：表生成器中的列名，用來存放其它表的主鍵鍵名，這個列名是與表中的欄位對應的

        pkColumnValue：實體表所對應到生成器表中的主鍵名，這個鍵名是可以自定義滴

        valueColumnName：表生成器中的列名，實體表主鍵的下一個值，假設EMPLOYEE表中的EMPLOYEE_ID最大為2，那麼此時，生成器表中與實體表主鍵對應的鍵名值則為3

        allocationSize：表示每次主鍵值增加的大小，例如設定成1，則表示每次建立新記錄後自動加1，預設為50

             

             

@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface OneToMany {

String targetEntity() default "";

CascadeType[] cascade() default {};

FetchType fetch() default LAZY;

String mappedBy() default "";

}


String targetEntity (Optional) The fully qualified class name of

the entity class that is the target of the association.

Optional only if the Collection property

is defined using Java generics. Must be

specified otherwise.

The parameter type of the

Collection when defined

using generics(Generics泛型),    如果使用泛型，就可省略指明targetEntity

CascadeType[] cascade (Optional) The operations that should be cascaded

to the target of the association

No operations are cascaded

FetchType fetch (Optional) Whether the association should be

lazy loaded or eagerly fetched.

FetchType.LAZY    預設為延遲載入

String mappedBy (Optional) The field that owns the relationship

指多的一方關聯的屬性名

mappedBy指定的是不需要維護關係的一端  ？？



@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface ManyToOne {

String targetEntity() default "";

CascadeType[] cascade() default {};

FetchType fetch() default EAGER;

boolean optional() default true;

}


targetEntity (Optional) The fully qualified class name of the entity class that is the target of the associationThe type of the property that stores the association

是指一方的實體型別的class  ，預設的就是這個屬性的型別。其實有些可以省略掉



CascadeType[] cascade (Optional) The operations that should be cascaded

to the target of the association No operations are cascaded

FetchType fetch (Optional) Whether the association should be

lazy loaded or eagerly fetched.      FetchType.EAGER   預設為主動載入

boolean optional (Optional) Whether the association is optional.

If set to false then a non-null relationship must  always exist.

true



@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface OneToOne {

String targetEntity() default "";

CascadeType[] cascade() default {};

FetchType fetch() default EAGER;

boolean optional() default true;

String mappedBy() default "";

boolean usePKasFK() default false;

}





The JoinColumn annotation is used to specify a mapped column for joining an entity association or a

secondary table.

@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)

public @interface JoinColumn {

String name() default "";

String referencedColumnName() default "";

boolean primaryKey() default false;

boolean unique() default false;

boolean nullable() default true;

boolean insertable() default true;

boolean updatable() default true;

String columnDefinition() default "";

String secondaryTable() default "";

}


@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface ManyToMany {

String targetEntity() default "";

CascadeType[] cascade() default {};

FetchType fetch() default LAZY;

String mappedBy() default "";

}