Hibernate註解使用以及Spring整合

Hibernate註解使用以及Spring整合
原文轉自：http://wanqiufeng.blog.51cto.com/409430/484739
(1)
簡介：
在過去幾年裏，Hibernate不斷髮展，幾乎成爲Java數據庫持久性的事實標準。它很是強大、靈活，並且具有了優異的性能。在本文中，咱們將瞭解如何使用Java 5 註釋來簡化Hibernate代碼，並使持久層的編碼過程變得更爲輕鬆。
傳統上，Hibernate的配置依賴於外部 XML 文件：數據庫映射被定義爲一組 XML 映射文件，而且在啓動時進行加載。
    在最近發佈的幾個Hibernate版本中，出現了一種基於 Java 5 註釋的更爲巧妙的新方法。藉助新的 Hibernate Annotation 庫，便可一次性地分配全部舊映射文件——一切都會按照您的想法來定義——註釋直接嵌入到您的Java 類中，並提供一種強大及靈活的方法來聲明持久性映射。
即利用hibernate註解後，可不用定義持久化類對應的*.hbm.xml文件，直接以註解方式寫入在持久化類中來實現。
Hibernate annotation使用了ejb JPA的註解,因此，下面安裝配置hibernate annotation環境時，須要導入ejb的包。許多網上的資料都是jpa hibernate annotation方面的資料。
(2)
安裝 Hibernate Annotation
第一步，
環境與jar包：
要使用 Hibernate Annotation，您至少須要具有 Hibernate 3.2和Java 5。能夠從 Hibernate 站點下載 Hibernate 3.2 和 Hibernate Annotation庫。除了標準的 Hibernate JAR 和依賴項以外，您還須要 Hibernate Annotations .jar 文件（hibernate-annotations.jar）、Java 持久性 API （lib/ejb3-persistence.jar）。
添加hibernate3.2.jar,hibernate-annotations- 3.3.0.jar，hibernate-commons-annotations.jar和ejb3-persistence.jar 。這樣就可使用hibernate的annotation了。

若是您正在使用 Maven，只須要向 POM 文件添加相應的依賴項便可，以下所示：
    ...
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate</artifactId>
      <version>3.2.1.ga</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.2.0.ga</version>
    </dependency>
    <dependency>
      <groupId>javax.persistence</groupId>
      <artifactId>persistence-api</artifactId>
      <version>1.0</version>
    </dependency>
第二步，
獲取 Hibernate 會話工廠。儘管無需驚天的修改，但這一工做與使用 Hibernate Annotations有所不一樣。您須要使用 AnnotationConfiguration 類來創建會話工廠：
sessionFactory = new AnnotationConfiguration().buildSessionFactory(); 
第三步，
儘管一般使用 <mapping> 元素來聲明持久性類，您仍是須要在 Hibernate 配置文件（一般是 hibernate.cfg.xml）中聲明持久性類：
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
        <hibernate-configuration>
          <session-factory>
            <mapping class="com.onjava.modelplanes.domain.PlaneType"/>
            <mapping class="com.onjava.modelplanes.domain.ModelPlane"/>
          </session-factory>
        </hibernate-configuration>
近期的許多 Java 項目都使用了輕量級的應用框架，例如 Spring。若是您正在使用 Spring 框架，可使用
AnnotationSessionFactoryBean 類輕鬆創建一個基於註釋的 Hibernate 會話工廠，以下所示：
<!-- Hibernate session factory -->
  <bean id="sessionFactory"
       class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
   <property name="dataSource">
     <ref bean="dataSource"/>
   </property>
   <property name="hibernateProperties">
     <props>
       <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
       <prop key="hibernate.hbm2ddl.auto">create</prop>
       ...
     </props>
   </property>
 
   <!--指明使用標註的實體類-->
   <property name="annotatedClasses">
     <list>
       <value>com.onjava.modelplanes.domain.PlaneType</value>
       <value>com.onjava.modelplanes.domain.ModelPlane</value>
       ...
     </list>
   </property>
 
   <!--固然也能夠不使用上面這種指定的方式，而使用包掃描的方式作爲替換，推薦這種-->
    <property name="packagesToScan">
       <list>
            <value>com.onjava.modelplanes.domain.*</value>
        </list>
      </property>
</bean>
(3)
hibernate Annotation標籤的使用:
[1]
1.帶註釋的持久性類也是普通 POJO,它們只是具有了持久性註釋的普通 POJO 。
2.事實上，您既能夠保持字段的持久性（註釋寫在成員變量之上），也能夠保持屬性（註釋寫在getter方法之上）的持久性。
3.經常使用的hibernate annotation標籤以下:
@Entity              --註釋聲明該類爲持久類。將一個Javabean類聲明爲一 個實體的數據庫表映射類,最好實現序列化.此時,默認狀況下,全部的類屬性都爲映射到數據表的持久性字段.若在類中,添加另外屬性,而非映射來數據庫的, 要用下面的Transient來註解.

@Table(name="promotion_info")      --持久性映射的表(表名="promotion_info).@Table是類一級的註解,定義在@Entity下,爲實體bean映射表,目錄和schema的名字,默認爲實體bean的類名,不帶包名.

@Id--註釋能夠代表哪一種屬性是該類中的獨特標識符(即至關於數據表的主鍵)。 
@GeneratedValue   --定義自動增加的主鍵的生成策略. 
@Transient             --將忽略這些字段和屬性,不用持久化到數據庫.適用於,在當前的持久類中,某些屬性不是用於映射到數據表,而是用於其它的業務邏輯須要,這時,須將這些屬性進行transient的註解.不然系統會因映射不到數據表相應字段而出錯. 
@Temporal(TemporalType.TIMESTAMP)--聲明時間格式 
@Enumerated         --聲明枚舉 
@Version                --聲明添加對樂觀鎖定的支持 
@OneToOne            --能夠創建實體bean之間的一對一的關聯 
@OneToMany          --能夠創建實體bean之間的一對多的關聯 
@ManyToOne          --能夠創建實體bean之間的多對一的關聯 
@ManyToMany        --能夠創建實體bean之間的多對多的關聯 
@Formula               --一個SQL表達式，這種屬性是隻讀的,不在數據庫生成屬性(可使用sum、average、max等) 
@OrderBy               --Many端某個字段排序(List)
 
1.2
Hibernate 可以出色地自動生成主鍵。Hibernate/EBJ 3 註釋也能夠爲主鍵的自動生成提供豐富的支持，容許實現各類策略。
其生成規則由@GeneratedValue設定的.這裏的@id和@GeneratedValue都是JPA的標準用法, JPA提供四種標準用法,由@GeneratedValue的源代碼能夠明顯看出. 
JPA提供的四種標準用法爲TABLE,SEQUENCE,IDENTITY,AUTO. 
TABLE：使用一個特定的數據庫表格來保存主鍵。 
SEQUENCE：根據底層數據庫的序列來生成主鍵，條件是數據庫支持序列。 
IDENTITY：主鍵由數據庫自動生成（主要是自動增加型） 
AUTO：主鍵由程序控制。
在指定主鍵時，若是不指定主鍵生成策略，默認爲AUTO。 
@Id
至關於
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
 
identity:
使用SQL Server 和 MySQL 的自增字段，這個方法不能放到 Oracle 中，Oracle 不支持自增字段，要設定sequence（MySQL 和 SQL Server 中很經常使用）。
Oracle就要採用sequence了.
 
同時,也可採用uuid,native等其它策略.(相關用法,上網查詢)
[2]
第一個持久性類 
@Entity 
@Table(name="T_MODEL_PLANE") 
public class ModelPlane    implements Serializable { 
        @Id 
        @Column(name="PLANE_ID")    
        @GeneratedValue(strategy=GenerationType.AUTO) //註解於屬性中 
/* 
對於oracle想使用各自的Sequence,設置以下:        
@GeneratedValue(strategy = GenerationType.AUTO,generator="PROMOTION_SEQ")        
@SequenceGenerator(name="PROMOTION_SEQ",sequenceName="PROMOTION_SEQ")    
 
另外:
對於自動增加後,在數據表中的相應字段,要設置字段爲auto_increment.
*/ 
        private Long id; 

        private String name;//註解寫於getter方法之上.請見下. 

     //DATE            - java.sql.Date        
     //TIME            - java.sql.Time        
     //TIMESTAMP - java.sql.Timestamp        
     @Temporal(TemporalType.TIMESTAMP)        
     @Column(name="start_time")        
     private Date startTime;     

     //顯示0 隱藏1        
     public static enum DisplayType {顯示,隱藏}        
     @Enumerated(value = EnumType.ORDINAL)//ORDINAL序數        
     private DisplayType displayType = DisplayType.顯示;    

        //1.sql語句中的字段和表名都應該和數據庫相應,而不是類中的字段,        
     //若帶有參數如la.id= id,這個=id纔是類中屬性        
     //2.操做字段必定要用別名        
     @Formula(select COUNT(la.id) from largess la)        
     private int count;    

        //註解於方法中 
        @Column(name="PLANE_ID", length=80, nullable=true) //較詳細定義 
        public String getName() { 
                return name; 
        } 
        public void setName(String name) { 
                this.name = name; 
        } 
其它的setter,getter省略...... 
}

該內容將映射到下表中： 
CREATE TABLE T_MODEL_PLANE 
( 
        PLANE_ID long, 
        PLANE_NAME varchar 
        其它字段省略... 
)    
默認狀況下，Hibernate 會將持久類以匹配的名稱映射到表和字段中。例如，下例中，若不用註解，則會映射到以下一表中：
CREATE TABLE MODELPLANE
(
    ID long,
    NAME varchar
    其它字段省略...
)
[3]
一對多註解:
1.
在一對多註解中,會用到:
"一"方：
@OneToMany --> mappedBy:"多"方的關聯屬性(被控方)
"多"方：
@ManyToOne --> @JoinColumn，"多"方定義的外鍵字段.
如數據表定義外鍵以下:
FOREIGN KEY (classid) REFERENCES classes(id)
則:
@JoinColumn(name="classid") 
2.
在雙向關聯中，有且僅有一端做爲主體（owner）端存在：主體端負責維護聯接列（即更新），對於不須要維護這種關係的從表則經過mappedNy屬性進行聲明。mappedBy的值指向另外一主體的關聯屬性。例子中，mappedBy的值爲classes。
附加說明:
mappedBy至關於過去的inverse="true".
inverse=false的side（side實際上是指inverse＝false所位於的class元素）端有責任維護關係，而inverse＝true端無須維護這些關係。
3.
cascade與fetch使用說明:
Cascade
CascadeType.PERSIST （級聯新建） 
CascadeType.REMOVE  （級聯刪除） 
CascadeType.REFRESH （級聯刷新） 
CascadeType.MERGE   （級聯更新）中選擇一個或多個。 
CascadeType.ALL
 fetch屬性：
關聯關係獲取方式,便是否採用延時加載。
 LAZY（默認值）採用延時加載，查詢數據時，不一塊兒查詢關聯對象的數據。而是當訪問關聯對象時(如：getStudnets()時)才觸發相應的查詢操做，獲取關聯對象數據。
EAGER：是在查詢數據時，也直接一塊兒獲取關聯對象的數據。
package oneToMany; 
import java.util.Set; 
import javax.persistence.*; 
/* 
注意導入時，是導入：import javax.persistence.*;    
非導入org.hibernate的相關類：import org.hibernate.annotations.Entity; 
*/ 
@Entity 
@Table(name="classes") 
public class Classes implements Serializable { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int id; 
  private String name; 
    
  @OneToMany(cascade=CascadeType.ALL,mappedBy="classes")    
  private Set<Student> students; 
//getter,setter省略 
} 


package oneToMany; 
import javax.persistence.*; 
@Entity 
@Table(name="student") 
public class Student implements Serializable  { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int sid; 
    
  private String sname; 
    
  //如有多個cascade，能夠是：{CascadeType.PERSIST,CascadeType.MERGE} 
  @ManyToOne(cascade={CascadeType.ALL})         
  @JoinColumn(name="classid")     //student類中對應外鍵的屬性：classid 
  private Classes classes; 
//getter,setter省略 
} 


public class TestOneToMany { 
/* 
CREATE TABLE    student (    --要定義外鍵!!!!!!! 
    `sid` double NOT NULL auto_increment, 
    `classid` double NULL, 
    `sname` varchar(255) NOT NULL, 
    PRIMARY KEY    (sid), 
    INDEX par_ind (classid), 
    FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE 
) ENGINE=InnoDB 
*/    
  public static void main(String[] args) throws SQLException    
  { 
    try 
    { 
      SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
      Session session=sf.openSession(); 
      Transaction tx=session.beginTransaction();         
/*
由於mappedBy是定義在classes中,即classes類不負責維護級聯關係.即維護者是student.因此,
1.要將clsses的數據,賦給student,即用student的setClasses()方法去捆定class數據;
2.在進行數據插入/更新session.save()/session.update()時,最後操做的是student.
*/
      Classes classes=new Classes(); 
      classes.setName("access"); 
        
      Student st1=new Student(); 
      st1.setSname("jason"); 
      st1.setClasses(classes); 
      session.save(st1); 
        
      Student st2=new Student(); 
      st2.setSname("hwj"); 
      st2.setClasses(classes); 
      session.save(st2); 
      tx.commit();
/* 
輸出以下:
Hibernate: insert into classes (name) values (?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
*/
/*
由於一端維護關係另外一端不維護關係的緣由，咱們必須注意避免在應用中用不維護關係的類(class)創建關係，由於這樣創建的關係是不會在數據庫中存儲的。
如上的代碼倒過來,則插入時,student的外鍵值爲空.以下:
*/
//      Student st1=new Student(); 
//      st1.setSname("jason"); 
//      session.save(st1); 
//        
//      Student st2=new Student(); 
//      st2.setSname("hwj"); 
//      session.save(st2); 
//        
//      Set<Student> students=new HashSet<Student>(); 
//      students.add(st1); 
//      students.add(st2); 
//        
//      Classes classes=new Classes(); 
//      classes.setName("access"); 
//      classes.setStudents(students); 
//      session.save(classes); 
/*
輸出以下:
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into classes (name) values (?)
*/
    } 
    catch(HibernateException e) 
    { 
      e.printStackTrace();        
    } 
  } 
}
 
 
[4]
多對多註解: 
在多對多註解中,雙方都採用@ManyToMany.
其中被控方,像一對多註解中設置同樣,也要設置mappedBy.
其中主控方,不像一對多註解那樣,採用@joinColumn,而是採用@joinTable.以下:
@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})
其中,
如上所說,mappedBy,至關於inverse="true".因此,在@joinTable中的inverseJoinColumns中定義的字段爲mappedBy所在類的主鍵.
joinColumns定義的字段,就是當前類的主鍵.
@Entity 
@Table(name="jcourse") 
public class Jcourse { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int cid; 
  private String cname; 
    
  @ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY ,mappedBy="courses") 
  private Set<Jstudent> students; 
//setter,getter省略....    
} 


@Entity 
@Table(name="jstudent") 
public class Jstudent { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int sid; 
    
  private String sname; 
    
  @ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.EAGER) 
  //inverseJoinColumns中對應的id爲如下屬性course的對應id. 
  @JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")}) 
  private Set<Jcourse> courses; 
//setter,getter省略....    
} 


public class Test { 
  public static void main(String[] args) { 
    try 
    { 
      SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
      Session session=sf.openSession(); 
      Transaction tx=session.beginTransaction(); 
        
      Jcourse course=new Jcourse(); 
      course.setCname("jason-english"); 
      session.save(course); //先各自保存. 
        
      Jcourse course2=new Jcourse(); 
      course2.setCname("herry-english"); 
      session.save(course2); 
        
      Set<Jcourse> courses=new HashSet<Jcourse>(); 
      courses.add(course); 
      courses.add(course2); 
        
      Jstudent student=new Jstudent(); 
      student.setSname("jason"); 
      student.setCourses(courses); 
        
      session.save(student);// 要用非mapby定義的類(studet)來做爲主者(會控制級聯關係),一對多,多對一也同樣道理. 
      //能夠嘗試反過來. 
      tx.commit(); 
    } 
    catch(HibernateException e) 
    { 
      e.printStackTrace();        
    } 
  } 
}