Hibernate注解使用以及Spring整合 .

jopen 12年前發布 | 49K 次閱讀 Hibernate JEE框架

簡介：
在過去幾年里，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 會話工廠，如下所示：

<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]
一對多注解:

在一對多注解中,會用到:

"一"方：
@OneToMany --> mappedBy:"多"方的關聯屬性(被控方)
"多"方：
@ManyToOne --> @JoinColumn，"多"方定義的外鍵字段.

如數據表定義外鍵如下:

FOREIGN KEY (classid) REFERENCES classes(id)

則:

@JoinColumn(name="classid")

在雙向關聯中，有且僅有一端作為主體（owner）端存在：主體端負責維護聯接列（即更新），對于不需要維護這種關系的從表則通過mappedNy屬性進行聲明。mappedBy的值指向另一主體的關聯屬性。例子中，mappedBy的值為classes。

附加說明:

mappedBy相當于過去的inverse="true".
inverse=false的side（side其實是指inverse＝false所位于的class元素）端有責任維護關系，而inverse＝true端無須維護這些關系。

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();
    }
  }
}

本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1363230734578.html

Hibernate JEE框架

Hibernate注解使用以及Spring整合 .

相關經驗

相關資訊

相關文檔

目錄