JPA使用指南 javax.persistence的注解配置

JPA注解持久化類很方便，需要jar包：ejb3-persistence.jar。我用以下三個類來說明用法。 

這個包的作用是持久化的作用，具體的說就是在實體類中進行元數據標簽的作用，是ORM框架中用到的。
ORM框架可以通過這個元數據標簽，使得實體類與數據庫中的表建立映射關系。
例如javax.persistence.Column標識實體類中的這個屬性對應於數據庫中的一個字段等等。

sh原創 轉載請注明：http://67566894.iteye.com/blog/659829

@SuppressWarnings("serial")
@Entity
@Table(name="T_X")
public class X implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    @Column(length=32)
    private String name;
    
         @Transient   //表示此數據不在數據庫表里建立屬性
         private String temp;

    @Temporal(TemporalType.TIMESTAMP) //這個是帶時分秒的類型
    private Date date;

    @OneToOne(cascade = CascadeType.ALL, mappedBy = "x")
    private A a;
}
@SuppressWarnings("serial")
@Entity
@Table(name="T_A")
public class A implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "a", fetch = FetchType.EAGER)
    private List<B> b = new ArrayList<B>();

    @OneToOne()
    @JoinColumn(name = "x_Id") //加這句后就會雙方共同維護關系
    private X x;
}

@SuppressWarnings("serial")
@Entity
public class B implements Serializable{
         @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    protected int id;

    @ManyToOne()
    @JoinColumn(name = "a_id")
    protected A a;
}

要注意的是：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 ""; 

}