hibernate初步4，hibernate

hibernate初步4，hibernate

JPA

1.JPA概述
JPA(Java Persistence API)是Sun官方提出的Java持久化規范。它為Java開發人員提供了一種對象/關系映射工具來管理Java應用中的關系數據。，而Hibernate是它的一種實現。除了Hibernate，還有EclipseLink(曾經的toplink)，OpenJPA等可供選擇，所以使用Jpa的一個好處是，可以更換實現而不必改動太多代碼。
Hibernate作為JPA的一種實現,jpa的注解已經是hibernate的核心，hibernate只提供了一些補充，而不是兩套注解。hibernate對jpa的支持夠足量，在使用hibernate注解建議使用jpa。

2.JPA編程步驟
1)引用相應的jar包
2)在src下新建 META-INF,在META-INF目錄下編寫persistence.xml

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence"

 version="1.0">
    <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.username" value="root" />
            <property name="hibernate.connection.password" value="root" />
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/hibernate_db" />
            <property name="hibernate.max_fetch_depth" value="3" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
        </properties>
    </persistence-unit>
</persistence>

3)編寫實體類

@Entity
@Table(name="admin")
public class Admin {
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;
    @Column(name="name")
    private String name;
    private String password;
    public Admin() {
        
    }
    public Admin(int id, String name, String password) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
    }
    public Admin(String name, String password) {
        super();
        this.name = name;
        this.password = password;
    }
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() { return name;}
    public void setName(String name) {this.name = name;}
    public String getPassword() { return password;}
    public void setPassword(String password) {this.password = password;}
    @Override
    public String toString() {
        return "Admin [id=" + id + ", name=" + name + ", password=" + password
                + "]";
    }   
}

 
4)使用JPA中的API來操作數據庫

//獲得EntityManagerFactory對象
EntityManagerFactory emf = Persistence.createEntityManagerFactory("mysqlJPA");
//獲得EntityManager對象
EntityManager em = emf.createEntityManager();
//開始事務
em.getTransaction().begin();
Admin admin = new Admin("stone","123");
//persist保存數據，相當於session中的save方法
em.persist(admin);
//事務提交
em.getTransaction().commit();
em.close();

EntityManager中常用的方法
em.persist(arg0) 　　//相當於session中的save方法
em.remove(arg0)
em.merge(arg0)
em.find(arg0, arg1)
em.createQuery(arg0)



3.JPA常用注解
1.@Entity(name="EntityName")    必須,name為可選,對應數據庫中一的個表

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

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

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

 
3.@id    必須,@id定義了映射到數據庫表的主鍵的屬性,一個實體只能有一個屬性被映射為主鍵.

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

 
4.@GeneratedValue(strategy=...,generator="")
可選，strategy:表示主鍵生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4種,分別表示讓ORM框架自動選擇,根據數據庫的Identity字段生成,根據數據庫表的Sequence字段生成,以有根據一個額外的表生成主鍵,默認為AUTO
generator:表示主鍵生成器的名稱,這個屬性通常和ORM框架相關,例如,Hibernate可以指定uuid等主鍵生成方式.

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     

//通過一個表來實現主鍵id的自增，這種方式不依賴於具體的數據庫，可以解決數據遷移的問題 
@GeneratedValue(strategy=GenerationType.TABLE)   
@Column(name = "user_code", nullable = false)     
private String userCode;     
public class Users implements Serializable {     
@Id     

//通過Sequence來實現表主鍵自增，這種方式依賴於數據庫是否有SEQUENCE，如果沒有就不能用    
@GeneratedValue(strategy=GenerationType.SEQUENCE)
@SequenceGenerator(name="seq_user")     
@Column(name = "user_id", nullable = false)     
private int userId;    

 
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 = "user_code", nullable = false, length=32)//設置屬性userCode對應的字段為
user_code，長度為32，非空     
private String userCode;  

//設置屬性wages對應的字段為user_wages，12位數字可保留兩位小數，可以為空     
@Column(name = "user_wages", nullable = true, precision=12, scale=2)   
private double wages;     
@Temporal(TemporalType.DATE)//設置為時間類型     
private Date joinDate; 

 
7.@Transient  可選
@Transient表示該屬性並非一個到數據庫表的字段的映射,ORM框架將忽略該屬性.
如果一個屬性並非數據庫表的字段映射,就務必將其標示為@Transient,否則,ORM框架默認其注解為@Basic

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

8.@ManyToOne(fetch=FetchType,cascade=CascadeType)   可選
@ManyToOne表示一個多對一的映射,該注解標注的屬性通常是數據庫表的外鍵
optional:是否允許該字段為null,該屬性應該根據數據庫表的外鍵約束來確定,默認為true
fetch:表示抓取策略,默認為FetchType.EAGER
cascade:表示默認的級聯操作策略,可以指定為ALL,PERSIST,MERGE,REFRESH和REMOVE中的若干組合,默認為無級聯操作
targetEntity:表示該屬性關聯的實體類型.該屬性通常不必指定,ORM框架根據屬性類型自動判斷targetEntity.

9.@OneToMany(fetch=FetchType,cascade=CascadeType)   可選
@OneToMany描述一個一對多的關聯,該屬性應該為集體類型,在數據庫中並沒有實際字段.
fetch:表示抓取策略,默認為FetchType.LAZY,因為關聯的多個對象通常不必從數據庫預先讀取到內存
cascade:表示級聯操作策略,對於OneToMany類型的關聯非常重要,通常該實體更新或刪除時,其關聯的實體也應當被更新或刪除
例如:實體User和Order是OneToMany的關系,則實體User被刪除時,其關聯的實體Order也應該被全部刪除有T_One和T_Many兩個表，他們是一對多的關系，注解范例如下
主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, 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;     
   
@JoinColumn(name = "ONE_ID", referencedColumnName = "ONE_ID")//設置對應數據表的列名和引用的數據表的列名     
@ManyToOne//設置在“一方”pojo的外鍵字段上     
private One oneId;   

10.@JoinColumn   可選
@JoinColumn和@Column類似,介量描述的不是一個簡單字段,而一一個關聯字段,例如.描述一個@ManyToOne的字段.
name:該字段的名稱.由於@JoinColumn描述的是一個關聯字段,如ManyToOne,則默認的名稱由其關聯的實
體決定.
例如,實體Order有一個user屬性來關聯實體User,則Order的user屬性為一個外鍵,
其默認的名稱為實體User的名稱+下劃線+實體User的主鍵名稱
示例: 見@ManyToOne
 
11.@OneToOne(fetch=FetchType,cascade=CascadeType)  可選
@OneToOne描述一個一對一的關聯
fetch:表示抓取策略,默認為FetchType.LAZY
cascade:表示級聯操作策略
主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;     
@Column(name = "DESCRIPTION")     
private String description;     
@OneToOne(cascade = CascadeType.ALL, mappedBy = "oneA")
//主Pojo設置比較簡單，只要設置好級聯和映射到從Pojo的外鍵就可以了。     
private OneB oneB;    

從Pojo

@Entity     
@Table(name = "T_ONEB")     
public class OneB implements Serializable {     
private static final long serialVersionUID = 1L;     
@Id     
@Column(name = "ONEA_ID", nullable = false)     
private String oneaId;     
@Column(name = "DESCRIPTION")     
private String description;     
@JoinColumn(name = "ONEA_ID", referencedColumnName = "ONEA_ID", insertable = false,
updatable = false)//設置從方指向主方的關聯外鍵，這個ONEA_ID其實是表T_ONEA的主鍵     
@OneToOne     
private OneA oneA;  

12.@ManyToMany   可選
@ManyToMany 描述一個多對多的關聯.多對多關聯上是兩個一對多關聯,但是在ManyToMany描述中,中間表
是由ORM框架自動處理
targetEntity:表示多對多關聯的另一個實體類的全名,例如:package.Book.class
mappedBy:表示多對多關聯的另一個實體類的對應集合屬性名稱
第一個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     
@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(mappedBy = "manybIdCollection")     
private Collection<ManyA> manyaIdCollection;    

兩個實體間相互關聯的屬性必須標記為@ManyToMany,並相互指定targetEntity屬性,
需要注意的是,有且只有一個實體的@ManyToMany注解需要指定mappedBy屬性,指向targetEntity的集合屬性名稱
利用ORM工具自動生成的表除了T_MANYA和T_MANYB表外,還自動生成了一個TMANY1_TMANY2表,用於實現多對多關聯

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() { 
           .......... 
       }
    } 

15.@OrderBy   在加載數據的時候可以為其指定順序，使用@OrderBy注解實現

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

 
16.@Lob   大字段

@Lob //對應Blob字段類型     
@Column(name = "PHOTO")     
private Serializable photo;     
@Lob //對應Clob字段類型     
@Column(name = "DESCRIPTION")     
private String description; 

 
17.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屬性，用於在驗證失敗後向用戶返回的消息，還可以三個屬性上使用多個注解