package com.wjt276.hibernate;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.cfg.Configuration;

import org.hibernate.tool.hbm2ddl.SchemaExport;

/**

* Hibernate工具<br/>

* 將物件模型生成關係模型(將物件生成資料庫中的表)

* 把hbm對映檔案(或Annotation註解)轉換成DDL

* 生成資料表之前要求已經存在資料庫

* 注：這個工具類建立好後，以後就不用建立了。以後直接Copy來用。

* @author wjt276

* @version 1.0 2009/10/16

*/

public classExportDB {

    public static voidmain(String[] args){

        /*org.hibernate.cfg.Configuration類的作用：

         *讀取hibernate配置檔案(hibernate.cfg.xml或hiberante.properties)的.

         *new Configuration()預設是讀取hibernate.properties

         *所以使用newConfiguration().configure();來讀取hibernate.cfg.xml配置檔案

         */

        Configuration cfg = new AnnotationConfiguration().configure();

        /*org.hibernate.tool.hbm2ddl.SchemaExport工具類：

         *需要傳入Configuration引數

         *此工具類可以將類匯出生成資料庫表

         */

        SchemaExport export = newSchemaExport(cfg);

        /** 開始匯出

         *第一個引數：script是否列印DDL資訊

         *第二個引數：export是否匯出到資料庫中生成表

         */

        export.create(true, true);

    }}

<id

       name="propertyName"                                          (1)

       type="typename"                                              (2)

       column="column_name"                                         (3)

       unsaved-value="null|any|none|undefined|id_value"             (4)

       access="field|property|ClassName"                            (5)

       node="element-name|@attribute-name|element/@attribute|.">

        <generatorclass="generatorClass"/>

</id>

<id name="id"type="long" column="cat_id">

       <generator class="org.hibernate.id.TableHiLoGenerator">

               <param name="table">uid_table</param>

               <param name="column">next_hi_value_column</param>

       </generator>

</id>

@Id

    @GeneratedValue

    public int getId() {

        return id;

}

或

@Id

@GeneratedValue(strategy=GenerationType.AUTO)

public int getId() {

return id;

}

@Id

    @GeneratedValue(strategy=GenerationType.IDENTITY)

    public int getId() {

        return id;

}

    @Id

    @GeneratedValue(strategy=GenerationType.SEQUENCE)

    public int getId() {

        return id;

    }

@Entity

@SequenceGenerator(name="teacherSEQ",sequenceName="teacherSEQ_DB")

public class Teacher {

……

}

@Entity

@SequenceGenerator(name="teacherSEQ",sequenceName="teacherSEQ_DB")

public class Teacher {

    private int id;

    @Id

    @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="teacherSEQ")

    public int getId() {

        return id;

}}

@javax.persistence.TableGenerator(

        name="Teacher_GEN",              //生成策略的名稱

        table="GENERATOR_TABLE",     //在資料庫生成表的名稱

        pkColumnName = "pk_key",     //表中第一個欄位的欄位名 型別為varchar,key

        valueColumnName = "pk_value",    //表中第二個欄位的欄位名 int ,value

        pkColumnValue="teacher",     //這個策略中使用該記錄的第一個欄位的值(key值)

        initialValue = 1,                //這個策略中使用該記錄的第二個欄位的值(value值)初始化值

        allocationSize=1                  //每次使用資料後累加的數值

)

create tableGENERATOR_TABLE (pk_key varchar(255),pk_value integer )

@Entity

@javax.persistence.TableGenerator(

        name="Teacher_GEN",              //生成策略的名稱

        table="GENERATOR_TABLE",     //在資料庫生成表的名稱

        pkColumnName = "pk_key",     //表中第一個欄位的欄位名 型別為varchar,key

        valueColumnName = "pk_value",    //表中第二個欄位的欄位名 int ,value

        pkColumnValue="teacher",     //這個策略中使用該記錄的第一個欄位的值(key值)

        initialValue = 1,                //這個策略中使用該記錄的第二個欄位的值(value值)初始化值

        allocationSize=1                 //每次使用資料後累加的數值

)

public class Teacher {

    private int id;

    @Id

    @GeneratedValue(strategy=GenerationType.TABLE,generator="Teacher_GEN")

    public int getId() {

        return id;}}

// 核算期間

public class FiscalYearPeriod {   

    private int fiscalYear; //核算年

    private int fiscalPeriod; //核算月  

    private Date beginDate; //開始日期  

    private Date endDate; //結束日期

    private String periodSts; //狀態

    public int getFiscalYear() {

        return fiscalYear;

    }

    public void setFiscalYear(int fiscalYear) {

        this.fiscalYear = fiscalYear;

    }

    public int getFiscalPeriod(){  return fiscalPeriod;}

    public void setFiscalPeriod(int fiscalPeriod) {

        this.fiscalPeriod =fiscalPeriod;

    }

    public DategetBeginDate() {return beginDate;}

    public void setBeginDate(DatebeginDate) {  this.beginDate = beginDate; }

    public Date getEndDate(){return endDate;}

    public void setEndDate(DateendDate) {  this.endDate = endDate; }

    public StringgetPeriodSts() {  return periodSts;}

    public voidsetPeriodSts(String periodSts) {this.periodSts = periodSts;}

}

public class FiscalYearPeriodPKimplements java.io.Serializable {

  private int fiscalYear;//核算年 

  private int fiscalPeriod;//核算月

  public int getFiscalYear() {

      return fiscalYear;

  }

  public void setFiscalYear(int fiscalYear) {

      this.fiscalYear = fiscalYear;

  }

  public int getFiscalPeriod(){

      return fiscalPeriod;

  }

  public void setFiscalPeriod(int fiscalPeriod) {

      this.fiscalPeriod =fiscalPeriod;

  }  

  @Override

  public int hashCode() {

      final int prime = 31;

      int result = 1;

      result = prime* result + fiscalPeriod;

      result = prime* result + fiscalYear;

      return result;

  }

  @Override

  public boolean equals(Object obj){

      if (this == obj)

          return true;

      if (obj == null)

          return false;

      if (getClass() !=obj.getClass())

          return false;

      FiscalYearPeriodPKother = (FiscalYearPeriodPK) obj;

      if (fiscalPeriod != other.fiscalPeriod)

          return false;

      if (fiscalYear != other.fiscalYear)

          return false;

      return true;

  }}

public class FiscalYearPeriod{

    private FiscalYearPeriodPK fiscalYearPeriodPK;//引用 複合主鍵類 

    private Date beginDate;//開始日期   

    private Date endDate;//結束日期 

    private String periodSts;//狀態 

    public FiscalYearPeriodPK getFiscalYearPeriodPK() {

        return fiscalYearPeriodPK;

    }

    public void setFiscalYearPeriodPK(FiscalYearPeriodPKfiscalYearPeriodPK) {

        this.fiscalYearPeriodPK = fiscalYearPeriodPK;

    }

………………

<hibernate-mapping>

    <class name="com.bjsxt.hibernate.FiscalYearPeriod"table="t_fiscal_year_period">

        <composite-id name="fiscalYearPeriodPK">

            <key-property name="fiscalYear"/>

            <key-property name="fiscalPeriod"/>

        </composite-id>

        <property name="beginDate"/>

        <property name="endDate"/>

        <property name="periodSts"/>

    </class>

</hibernate-mapping>

create table t_fiscalYearPeriod (fiscalYear integer not null, fiscalPeriodinteger not null, beginDate datetime, endDate datetime, periodSts varchar(255),primary key (fiscalYear, fiscalPeriod))//實體對映到資料就是兩個欄位構成複合主鍵

    session =HibernateUtils.getSession();

    tx =session.beginTransaction();

    FiscalYearPeriod fiscalYearPeriod = new FiscalYearPeriod();

    //構造複合主鍵

    FiscalYearPeriodPK pk = new FiscalYearPeriodPK();

    pk.setFiscalYear(2009);

    pk.setFiscalPeriod(11);

    fiscalYearPeriod.setFiscalYearPeriodPK(pk);//為物件設定複合主鍵

    fiscalYearPeriod.setEndDate(new Date());

    fiscalYearPeriod.setBeginDate(new Date());

    fiscalYearPeriod.setPeriodSts("Y");

    session.save(fiscalYearPeriod);        

Hibernate: insert into t_fiscalYearPeriod (beginDate, endDate, periodSts,fiscalYear, fiscalPeriod) values (?, ?, ?, ?, ?)

@Embeddable

public class TeacherPK implementsjava.io.Serializable{

    private int id;

    private String name;

    public int getId() {return id;  }

    public void setId(int id) {this.id = id;}

    public String getName() {   return name;}

    public void setName(Stringname) {  this.name = name;}

    @Override

    public boolean equals(Object o) {       ……}

    @Override

    public int hashCode() { return this.name.hashCode();    }

}

@Entity

public class Teacher {

  private TeacherPK pk;

  private String title;

  @Id

  public TeacherPK getPk(){

      return pk;

}}

@Entity

public class Teacher {

   private TeacherPK pk;

   private String title;  

   @EmbeddedId

   public TeacherPK getPk(){

       return pk;

   }}

@Entity

@IdClass(TeacherPK.class)

public class Teacher {

  //private TeacherPK pk;//不再需要

  private int id;

  private String name;   

  @Id

  public int getId() {return id;  }

  public void setId(int id) { this.id = id;   }

  @Id

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;

  }}

sessionFactory = newAnnotationConfiguration().configure().buildSessionFactory();

sessionFactory=newnnotationConfiguration().configure("hibernate.xml").buildSessionFactory();

Session session = sessionFactory.getCurrentSession();

<property name="current_session_context_class">thread</property>

session.save(Object)

session.delete(Object)

    try {

        session =sf.openSession();

        session.beginTransaction();

         User user =(User)session.load(User.class,1);

        //只有在使用物件時，它才發出查詢SQL語句，載入物件。

        System.out.println("user.name=" + user.getName());

        //因為此的user為persistent狀態，所以資料庫進行同步為龍哥。

        user.setName("發哥");

        session.getTransaction().commit();

    } catch (HibernateExceptione) {

        e.printStackTrace();

        session.getTransaction().rollback();

    } finally{

            if (session != null){

                if(session.isOpen()){

                    session.close();

                }

            }

    }

try {

          session =sf.openSession();

          session.beginTransaction();

           * 此方法返回型別為Object，也就是物件，然後我們再強行轉換為需要載入的物件就可以了。

              如果資料不存在，則返回null

           * 執行此方法時立即發出查詢SQL語句。載入User物件。

           */

          User user = (User)session.get(User.class, 1);

          //資料載入完後的狀態為persistent狀態。資料將與資料庫同步。

          System.out.println("user.name=" + user.getName());

          //因為此的user為persistent狀態，所以資料庫進行同步為龍哥。

          user.setName("龍哥");

          session.getTransaction().commit();

      } catch(HibernateException e) {

          e.printStackTrace();

          session.getTransaction().rollback();

      } finally{

          if (session != null){

              if(session.isOpen()){

                  session.close();

              }

          }

<property name="name" update="false"/>

    @Column(updatable=false)

    public String getTitle(){return title;}

<class name="com.bjsxt.Student" dynamic-update="true">

@Test

  public void testUpdate5() {    

      Sessionsession = sessionFactory.getCurrentSession();

      session.beginTransaction();

      Student s =(Student)session.get(Student.class, 1);

      s.setName("zhangsan5");

      //提交時，會只更新name欄位，因為此時的s為persistent狀態

      session.getTransaction().commit();

      s.setName("z4");

      Sessionsession2 = sessionFactory.getCurrentSession();

      session2.beginTransaction();

      //更新時，會更新所有的欄位，因為此時的s不是persistent狀態

      session2.update(s);

      session2.getTransaction().commit(); }

@Test

  public void testUpdate6() {    

      Sessionsession = sessionFactory.getCurrentSession();

      session.beginTransaction();

      Student s =(Student)session.get(Student.class, 1);

      s.setName("zhangsan6");

      session.getTransaction().commit();

      s.setName("z4");

      Sessionsession2 = sessionFactory.getCurrentSession();

      session2.beginTransaction();

      session2.merge(s);

      session2.getTransaction().commit()}

  @Test

  public void testUpdate7() {    

      Sessionsession = sessionFactory.getCurrentSession();

      session.beginTransaction();

      Query q =session.createQuery(

"update Student s sets.name='z5' where s.id = 1");

      q.executeUpdate();

      session.getTransaction().commit();     

  }  

    Session session= sessionFactory.getCurrentSession();

    session.beginTransaction();

    Teacher t =(Teacher)session.load(Teacher.class, 1);

    System.out.println(t.getName());       

    session.clear();       

    Teacher t2 =(Teacher)session.load(Teacher.class, 1);

    System.out.println(t2.getName());

    session.getTransaction().commit();

  session.setFlushMode(FlushMode);

但是與commit同時使用，會丟擲異常

session = HibernateUtils.getSession();

tx = session.beginTransaction();

User1 user = new User1();

user.setName("李四");

user.setPassword("123");

user.setCreateTime(new Date());

user.setExpireTime(new Date());

//利用Hibernate將實體類物件儲存到資料庫中，因為user主鍵生成策略採用的是uuid，所以呼叫完成save後，只是將user納入session的管理，不會發出insert語句，但是id已經生成，session中的existsInDatabase狀態為false

session.save(user);

session.evict(user);//從session快取(EntityEntries屬性)中逐出該物件

//無法成功提交，因為hibernate在清理快取時，在session的臨時集合(insertions)中取出user物件進行insert操作後需要更新entityEntries屬性中的existsInDatabase為true,而我們採用evict已經將user從session中逐出了，所以找不到相關資料,無法更新，丟擲異常。

tx.commit();

session.save(user);

//flush後hibernate會清理快取，會將user物件儲存到資料庫中，將session中的insertions中的user物件清除，並且會設定session中的existsInDatabase狀態為false

session.flush();

session.evict(user);//從session快取(EntityEntries屬性)中逐出該物件

//可以成功提交，因為hibernate在清理快取時，在Session的insertions中集合中無法找到user物件所以不會發出insert語句，也不會更新session中existsInDatabase的狀態。

tx.commit();

/** 人－實體類 */

public class Person {

    private int id;

    private String name;

    public int getId() {return id;  }

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {this.name = name;}

}

/**身份證-實體類*/

public class IdCard {

    private int id;

    private String cardNo;

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getCardNo(){ return cardNo;}

    public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

         /** 人－實體類 */

public class Person {

    private int id;

    private String name;

private IdCard idCard;//引用IdCard物件

    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 IdCard getIdCard() { return idCard;}

    public void setIdCard(IdCardidCard) {this.idCard = idCard;}

}

<hibernate-mapping>

  <class name="com.wjt276.hibernate.IdCard" table="t_idcard">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="cardNo"/>

  </class>

</hibernate-mapping>

<hibernate-mapping>

  <class name="com.wjt276.hibernate.Person" table="t_person">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name"/> 

<!-- <many-to-one>:在多的一端(當前Person一端)，加入一個外來鍵(當前為idCard)指向一的一端(當前IdCard),但多對一 關聯對映欄位是可以重複的，所以需要加入一個唯一條件unique="true",這樣就可以此欄位唯一了。-->

      <many-to-one name="idCard" unique="true"/>

  </class>

</hibernate-mapping>

注意IdCard是被引用物件，除正常註解，無需要其它註解

/**身份證*/

@Entity

public class IdCard {

  private int id;

  private String cardNo;

  @Id

  @GeneratedValue

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getCardNo(){return cardNo;}

  public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

/** 人－實體類 */

@Entity

public class Person {

  private int id;

  private IdCard idCard;//引用IdCard物件  

  private String name;   

  @Id

  @GeneratedValue

  public int getId() {return id;}

  @OneToOne//表示一對一的關係

  @JoinColumn(name="idCard")//為資料中的外來鍵指定個名稱

  public IdCard getIdCard(){ return idCard;}

  public String getName() {return name;}

  public void setId(int id) {this.id = id;}

  public void setIdCard(IdCardidCard) {this.idCard = idCard;}

  public void setName(Stringname) {this.name = name;}  

}

    create tableIdCard (

        id integernot null auto_increment,

        cardNo varchar(255),

        primary key(id)

    )

    create tablePerson (

        id integernot null auto_increment,

        namevarchar(255),

        idCardinteger,//新新增的外來鍵

        primary key(id)

    )

    alter tablePerson

        add indexFK8E488775BE010483 (idCard),

        addconstraint FK8E488775BE010483

        foreign key(idCard) //外來鍵

        referencesIdCard (id)//引用IdCard的id欄位

Session session = sf.getCurrentSession();      

IdCard idCard = new IdCard();

idCard.setCardNo("88888888888888888888888");       

session.beginTransaction();

// 如果先不儲存idCard，則出丟擲Transient異常，因為idCard不是持久化狀態。

session.save(idCard);      

Person person = new Person();

person.setName("菜10");

person.setIdCard(idCard);

session.save(person);

session.getTransaction().commit();

    <class name="com.wjt276.hibernate.IdCard" table="idcard">

        <id name="id" column="id">

            <generator class="native"/></id>

        <property name="cardNo"/>

        <!--<one-to-one>標籤：告訴hibernate如何載入其關聯物件

            property-ref屬性：是根據哪個欄位進行比較載入資料 -->

        <one-to-one name="person" property-ref="idCard"/>

    </class>

    <!--<one-to-one>標籤：告訴hibernate如何載入其關聯物件

            property-ref屬性：是根據哪個欄位進行比較載入資料 -->

        <one-to-one name="person" property-ref="idCard"/>

@Entity

public class IdCard {

  private int id;

  private String cardNo;

  private Person person; 

  //mappedBy：在指定當前物件在被Person物件的idCard做了對映了

  //此值：當前物件持有引用物件中引用當前物件的成員屬性名稱(getXXX後的名稱)

  //因為Person物件的持有IdCard物件的方法是getIdCard()因為需要小寫,所以為idCard

  @OneToOne(mappedBy="idCard")

  public Person getPerson(){return person;}

  public void setPerson(Person person){this.person = person;}

  @Id

  @GeneratedValue

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getCardNo(){return cardNo;}

  public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

IdCard對映檔案，先生成ID

    <class name="com.wjt276.hibernate.IdCard" table="t_idcard">

        <id name="id"column="id">

            <generator class="native"/>

        </id>

        <property name="cardNo"/>

    </class>

Person實體類對映檔案，ID是根據IdCard主鍵值   

<class name="com.wjt276.hibernate.Person"table="t_person">

        <id name="id"column="id">

<!--因為主鍵不是自己生成的，而是作為一個外來鍵(來源於其它值)，所以使用foreign生成策略

foreign:使用另外一個相關聯的物件的識別符號，通常和<one-to-one>聯合起來使用。再使用元素<param>的屬性值指定相關聯物件(這裡Person相關聯的物件為idCard,則識別符號為idCard的id)為了能夠在載入person資料同時載入IdCard資料，所以需要使用一個標籤<one-to-one>來設定這個功能。  -->

            <generator class="foreign">

                <!-- 元素<param>屬性name的值是固定為property -->

                <param name="property">idCard</param>

            </generator>

        </id>

        <property name="name"/>

        <!-- <one-to-one>標籤

        表示如何載入它的引用物件(這裡引用物件就指idCard這裡的name值是idCard)，同時也說是一對一的關係。 預設方式是根據主鍵載入(把person中的主鍵取出再到IdCard中來取相關IdCard資料。) 我們也說過此主鍵也作為一個外來鍵引用 了IdCard，所以需要加一個資料庫限制(外來鍵約束)constrained="true"     -->

        <one-to-one name="idCard"constrained="true"/>

@Entity

public class Person {

    private int id;

    private IdCard idCard;//引用IdCard物件  

    private String name;   

    @Id

    public int getId() {return id;}

    @OneToOne//表示一對一的關係

    @PrimaryKeyJoinColumn//註解主鍵關聯對映

    public IdCard getIdCard(){ return idCard;}

    public String getName() {return name;}

    public void setId(int id) {this.id = id;}

    public void setIdCard(IdCard idCard){this.idCard = idCard;}

    public void setName(Stringname) {this.name = name;}  

}

    create tableIdCard (

        id integernot null auto_increment,

        cardNovarchar(255),

        primary key (id)

    )

    create tablePerson (

        id integernot null,

        namevarchar(255),

        primary key(id)

  )

alter table person

add index FK785BED805248EF3 (id),

add constraint FK785BED805248EF3

foreign key (id) references idcard (id)

session = HibernateUtils.getSession();

tx = session.beginTransaction();

IdCard idCard = new IdCard();

idCard.setCardNo("88888888888888888888888");

Person person = new Person();

person.setName("菜10");

person.setIdCard(idCard);

//不會出現TransientObjectException異常

//因為一對一主鍵關鍵對映中，預設了cascade屬性。

session.save(person);

tx.commit();

<id name="id"column="id">

      <!—person的主鍵來源idcard，也就是共享idCard的主鍵-->

          <generator class="foreign">

              <param name="property">idCard</param>

          </generator>

      </id>

      <property name="name"/>

<!—one-to-one標籤的含義：指示hibernate怎麼載入它的關聯物件，預設根據主鍵載入

  constrained="true"，表面當前主鍵上存在一個約束：person的主鍵作為外來鍵參照了idCard-->

      <one-to-one name="idCard" constrained="true"/>

<class name="com.wjt276.hibernate.IdCard" table="t_idcard">

        <id name="id" column="id">

            <generator class="native"/> </id>

        <property name="cardNo"/>

<!—one-to-one標籤的含義：指示hibernate怎麼載入它的關聯物件(這裡的關聯物件為person)，預設根據主鍵載入-->

        <one-to-one name="person"/>

    </class>

@Entity

public class IdCard {

    private int id;

    private String cardNo;

    private Person person; 

    @OneToOne(mappedBy="idCard")

    public Person getPerson(){

        return person;

    }}

    @OneToOne

    @JoinColumns(

        {

            @JoinColumn(name="wifeId", referencedColumnName="id"),

            @JoinColumn(name="wifeName", referencedColumnName="name")

        }

    )

    public WifegetWife() {

        return wife;

    }

public class User {

private int id;

  private String name;   

  private Contact contact;//值物件的引用   

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getName() {   return name;}

  public void setName(Stringname) {  this.name = name;}

  public ContactgetContact() {   return contact;}

  public void setContact(Contactcontact) {   this.contact = contact;}   

}

public class Contact {

  private String email;  

  private String address;

  private String zipCode;

  private String contactTel;

  public String getEmail(){  return email;}

  public void setEmail(Stringemail) {    this.email = email; }

  public StringgetAddress() {return address;}

  public void setAddress(Stringaddress) {this.address = address;}

  public StringgetZipCode() {return zipCode;}

  public void setZipCode(StringzipCode) {this.zipCode = zipCode;}

  public StringgetContactTel() { return contactTel;}

  public voidsetContactTel(String contactTel){this.contactTel = contactTel;}

}

<hibernate-mapping>

  <class name="com.wjt276.hibernate.User" table="t_user">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name" column="name"/>

      <!-- <component>標籤用於對映Component(元件)關係

          其內部屬性正常對映。

       -->

      <component name="contact">

          <property name="email"/>

          <property name="address"/>

          <property name="zipCode"/>

          <property name="contactTel"/>          

      </component>

  </class>

</hibernate-mapping>

@Entity

public class User {

    private int id;

    private String name;   

    private Contact contact;//值物件的引用   

    @Id

    @GeneratedValue

    public int getId() {    return id;}

    @Embedded//用於註解元件對映，表示嵌入物件的對映

    public ContactgetContact() {return contact;}

    public void setContact(Contactcontact) {this.contact = contact;} 

    create table User (

        id integer not null auto_increment,

        address varchar(255),

        contactTel varchar(255),

        email varchar(255),

        zipCode varchar(255),

        name varchar(255),

        primary key (id)

)

           session =HibernateUtils.getSession();

           tx =session.beginTransaction();

           User user= new User();

           user.setName("10");

           Contactcontact = new Contact();

           contact.setEmail("wjt276");

           contact.setAddress("aksdfj");

           contact.setZipCode("230051");

           contact.setContactTel("3464661");

           user.setContact(contact);

           session.save(user);

           tx.commit();

public class User {

  private int id;

  private String name;

  private Group group;

  public Group getGroup() {return group;  }

public void setGroup(Group group) {this.group = group;}

  public int getId() {return id;  }

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {  this.name = name;}}

public class Group {

  private int id;

  private String name;

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;}

}

<hibernate-mapping>

  <class name="com.wjt276.hibernate.Group" table="t_group">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name"/>

  </class>

</hibernate-mapping>

<hibernate-mapping>

  <class name="com.wjt276.hibernate.User" table="t_user">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name"/>

      <!--<many-to-one> 關聯對映 多對一的關係

  name:是維護的屬性(User.group),這樣表示在多的一端表裡加入一個欄位名稱為group,

但group與SQL中的關鍵字重複，所以需要重新命名欄位(column="groupid").這樣這個欄位(groupid)會作為外來鍵參照資料庫中group表(t_group也叫一的一端)，也就是就在多的一 端加入一個外來鍵指向一的一端。 -->

      <many-to-one name="group" column="groupid"/>

  </class>

</hibernate-mapping>

例如：<many-to-one name="group" column="groupid"/>

alter table t_user drop foreign keyFKCB63CCB695B3B5AC

drop table if exists t_group

drop table if exists t_user

create table t_group (id integer not nullauto_increment, name varchar(255), primary key (id))

create table t_user (id integer not nullauto_increment, name varchar(255), groupid integer,primary key (id))

alter table t_user add index FKCB63CCB695B3B5AC (groupid), add constraint FKCB63CCB695B3B5AC foreign key (groupid) referencest_group (id)

@Entity

public class User {

  private int id;

  private String name;

  private Group group;

  @ManyToOne

  @JoinColumn(name="groupId")

  public Group getGroup() {

      return group;

  }

session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            Groupgroup = new Group();

            group.setName("wjt276");

            session.save(group); //儲存Group物件。

            Useruser1 = new User();

            user1.setName("菜10");

            user1.setGroup(group);//設定使用者所屬的組

            Useruser2 = new User();

            user2.setName("容祖兒");

            user2.setGroup(group);//設定使用者所屬的組

            //開始儲存

            session.save(user1);//儲存使用者

            session.save(user2);

            tx.commit();//提交事務

Hibernate: insert into t_group (name) values (?)

Hibernate: insert into t_user (name, groupid) values (?, ?)

Hibernate: insert into t_user (name, groupid) values (?, ?)

        例如：<many-to-one name="group"column="groupid" cascade="save-update"/>

session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            Useruser = (User)session.load(User.class, 3);

            System.out.println("user.name=" + user.getName());

            System.out.println("user.group.name=" + user.getGroup().getName());

            //提交事務

            tx.commit();

Hibernate: select user0_.id as id0_0_,user0_.name as name0_0_, user0_.groupid as groupid0_0_ from t_user user0_ whereuser0_.id=?

Hibernate: select group0_.id as id1_0_,group0_.name as name1_0_ from t_group group0_ where group0_.id=?

public class Classes {

  private int id;

  private String name;

  //一對多通常使用Set來對映，Set是不可重複內容。

//注意使用Set這個介面，不要使用HashSet,因為hibernate有延遲載入，

  private Set<Student>students = new HashSet<Student>();

  public int getId() {return id;  }

  public void setId(int id) {this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;}

}

public class Student {

  private int id;

  private String name;

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {  this.name = name;}

}

<hibernate-mapping>

    <class name="com.wjt276.hibernate.Student" table="t_student">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

        <property name="name" column="name"/>

    </class>

</hibernate-mapping>

<hibernate-mapping>

    <class name="com.wjt276.hibernate.Classes" table="t_classess">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

        <property name="name" column="name"/>     

        <!--<set>標籤 對映一對多(對映set集合),name="屬性集合名稱"，然後在用<key>標籤，在多的一端加入一個外來鍵(column屬性指定列名稱)指向一的一端，再採用<one-to-many>標籤說明一對多，還指定<set>標籤中name="students"這個集合中的型別要使用完整的類路徑(例如：class="com.wjt276.hibernate.Student") -->

        <set name="students">

            <key column="classesid"/>

            <one-to-many class="com.wjt276.hibernate.Student"/>

        </set>

    </class>

</hibernate-mapping>

@Entity

public class Classes {

    private int id;

    private String name;

    // 一對多通常使用Set來對映，Set是不可重複內容。

    // 注意使用Set這個介面，不要使用HashSet,因為hibernate有延遲載入，

    private Set<Student>students = new HashSet<Student>();

    @OneToMany//進行註解為一對多的關係

    @JoinColumn(name="classesId")//在多的一端註解一個欄位(名為classessid)

    public Set<Student>getStudents() {

        return students;

}

create table t_classes (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_student (id integer not null auto_increment, namevarchar(255), classesid integer, primary key (id))

alter table t_student add index FK4B90757070CFE27A (classesid), add constraint FK4B90757070CFE27A foreign key (classesid) referencest_classes (id)

             session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            Studentstudent1 = new Student();

            student1.setName("10");

            session.save(student1);//必需先儲存，否則在儲存classess時出錯.

            Studentstudent2 = new Student();

            student2.setName("祖兒");

            session.save(student2);//必需先儲存，否則在儲存classess時出錯.

            Set<Student>students = new HashSet<Student>();

            students.add(student1);

            students.add(student2);

            Classesclasses = new Classes();

            classes.setName("wjt276");

            classes.setStudents(students);

            session.save(classes);

            tx.commit();

Hibernate: insert into t_student (name) values (?)

Hibernate: insert into t_student (name) values (?)

Hibernate: insert into t_classes (name) values (?)

Hibernate: update t_student set classesid=? where id=?

Hibernate: update t_student set classesid=? where id=?

session = HibernateUtils.getSession();

          tx =session.beginTransaction();

          Classesclasses = (Classes)session.load(Classes.class, 2);

          System.out.println("classes.name=" + classes.getName());

          Set<Student> students = classes.getStudents();

          for(Iterator<Student> iter = students.iterator();iter.hasNext();){

              Studentstudent = iter.next();

              System.out.println(student.getName());

          }

          tx.commit();

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ fromt_classes classes0_ where classes0_.id=?

Hibernate: select students0_.classesid as classesid1_, students0_.id asid1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_studentstudents0_ where students0_.classesid=?

  <class name="com.wjt276.hibernate.Student" table="t_student">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name" column="name"/>

<!--使用多對一標籤對映 一對多雙向，下列的column值必需與多的一端的key欄位值一樣。-->

      <many-to-one name="classes" column="classesid"/>

  </class>

  <class name="com.wjt276.hibernate.Classes" table="t_classes">

      <id name="id"column="id">

          <generator class="native"/>

      </id>

      <property name="name"column="name"/>

      <!--

          <set>標籤 對映一對多(對映set集合),name="屬性集合名稱"

          然後在用<key>標籤，在多的一端加入一個外來鍵(column屬性指定列名稱)指向一的一端

          再採用<one-to-many>標籤說明一對多，還指定<set>標籤中name="students"這個集合中的型別

          要使用完整的類路徑(例如：class="com.wjt276.hibernate.Student")

inverse="false":一的一端維護關係失效(反轉) ：false：可以從一的一端維護關係(預設)；true：從一的一端維護關係失效，這樣如果在一的一端維護關係則不會發出Update語句。 -->

      <set name="students"inverse="true">

      <key column="classesid"/>

          <one-to-many class="com.wjt276.hibernate.Student"/>

      </set>

  </class>

@Entity

public class Student {

    private int id;

    private String name;

    private Classes classes;

    @ManyToOne

    @JoinColumn(name="classesId")

    public ClassesgetClasses() {

        return classes;

    }

@Entity

public class Classes {

    private int id;

    private String name;

    // 一對多通常使用Set來對映，Set是不可重複內容。

    // 注意使用Set這個介面，不要使用HashSet,因為hibernate有延遲載入，

    private Set<Student>students = new HashSet<Student>();

    @OneToMany(mappedBy="classes")//進行註解為一對多的關係

    public Set<Student>getStudents() {

        return students;}

session = HibernateUtils.getSession();

          tx =session.beginTransaction();

          Classesclasses = new Classes();

          classes.setName("wjt168");

          session.save(classes);

          Studentstudent1 = new Student();

          student1.setName("10");

          student1.setClasses(classes);

          session.save(student1);

          Studentstudent2 = new Student();

          student2.setName("祖兒");

          student2.setClasses(classes);

          session.save(student2);

          //提交事務

          tx.commit();

public class Role {

    private int id;

    private String name;

    public int getId() return id;}

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {  this.name = name;}}

public class User {

    private int id;

    private String name;   

    private Set<User> roles = newHashSet<User>();// Role物件的集合

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {this.name = name;}

    public Set<User>getRoles() {return roles;}

    public voidsetRoles(Set<User> roles) {this.roles = roles;  }

<class name="com.wjt276.hibernate.Role" table="t_role">

        <id name="id">

            <generator class="native"/>

        </id>

        <property name="name" column="name"/>

    </class>

    <class name="com.wjt276.hibernate.User" table="t_user">

        <id name="id"column="id">

            <generator class="native"/>

        </id>

        <property name="name"/>

<!--使用<set>標籤對映集合(set)，標籤中的name值為物件屬性名(集合roles)，而使用table屬性是用於生成第三方表名稱，例：table="t_user_role"，但是第三方面中的欄位是自動加入的，作為外來鍵分別指向其它表。

所以表<key>標籤設定，例：<key column="userid"/>，意思是：在第三方表(t_user_role)中加入一個外來鍵並且指向當前的對映實體類所對應的表(t_user).使用<many-to-many>來指定此對映集合所物件的類(例項類)，並且使用column屬性加入一個外來鍵指向Role實體類所對應的表(t_role) -->

        <setname="roles" table="t_user_role">

            <key column="userid"/>

            <many-to-many class="com.wjt276.hibernate.Role" column="roleid"/>

        </set>

    </class>

@Entity

public class User {

  private int id;

  private String name;

  private Set<User> roles = new HashSet<User>();// Role物件的集合  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToMany

  @JoinTable(name="u_r",//使用@JoinTable標籤的name屬性註解第三方表名稱

          joinColumns={@JoinColumn(name="userId")},

//使用joinColumns屬性來註解當前實體類在第三方表中的欄位名稱並指向該物件

          inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns屬性來註解當前實體類持有引用物件在第三方表中的欄位名稱並指向被引用物件表

  )

  public Set<User> getRoles() {return roles;}

create table t_role (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user_role (userid integer not null, roleid integer notnull, primary key (userid, roleid))

alter table t_user_role add index FK331DEE5F1FB4B2D4 (roleid), add constraint FK331DEE5F1FB4B2D4 foreign key (roleid) referencest_role (id)

alter table t_user_role add index FK331DEE5F250A083E(userid), add constraint FK331DEE5F250A083E foreign key (userid) referencest_user (id)

session = HibernateUtils.getSession();

          tx =session.beginTransaction();

          Role r1 = new Role();

          r1.setName("資料錄入人員");

          session.save(r1);

          Role r2 = new Role();

          r2.setName("商務主管");

          session.save(r2);

          Role r3 = new Role();

          r3.setName("大區經理");

          session.save(r3);

          User u1 = new User();

          u1.setName("10");

          Set<Role>u1Roles = new HashSet<Role>();

          u1Roles.add(r1);

          u1Roles.add(r2);

          u1.setRoles(u1Roles);

          User u2 = new User();

          u2.setName("祖兒");

          Set<Role>u2Roles = new HashSet<Role>();

          u2Roles.add(r2);

          u2Roles.add(r3);

          u2.setRoles(u2Roles);

          User u3 = new User();

          u3.setName("成龍");

          Set<Role>u3Roles = new HashSet<Role>();

          u3Roles.add(r1);

          u3Roles.add(r2);

          u3Roles.add(r3);

          u3.setRoles(u3Roles);

          session.save(u1);

          session.save(u2);

          session.save(u3);

          tx.commit();

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

         session =HibernateUtils.getSession();

         tx =session.beginTransaction();

         User user =(User)session.load(User.class, 1);

         System.out.println("user.name=" + user.getName());

         for(Iterator<Role> iter = user.getRoles().iterator();iter.hasNext();){

             Rolerole = (Role) iter.next();

             System.out.println(role.getName());

         }

         tx.commit();

Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_useruser0_ where user0_.id=?

user.name=10

Hibernate: select roles0_.userid as userid1_, roles0_.roleid as roleid1_,role1_.id as id2_0_, role1_.name as name2_0_ from t_user_role roles0_ leftouter join t_role role1_ on roles0_.roleid=role1_.id where roles0_.userid=?

商務主管

資料錄入人員

    <class name="com.wjt276.hibernate.Role" table="t_role">

        <id name="id">

            <generator class="native"/>

        </id>

        <property name="name" column="name"/>

        <!—order-by 屬性是第三方表哪個欄位進行排序-->

        <set name="users" table="t_user_role"order-by="userid">

            <key column="roleid"/>

            <many-to-many class="com.wjt276.hibernate.User" column="userid"/>

        </set>  </class>

<!— order-by 屬性是第三方表哪個欄位進行排序-->

      <set name="users" table="t_user_role"order-by="userid">

          <key column="roleid"/>

          <many-to-many class="com.wjt276.hibernate.User" column="userid"/>

      </set>

@Entity

public class User {

  private int id;

  private Set<User> roles = new HashSet<User>();// Role物件的集合  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToMany

  @JoinTable(name="u_r",//使用@JoinTable標籤的name屬性註解第三方表名稱

          joinColumns={@JoinColumn(name="userId")},//使用joinColumns屬性來註解當前實體類在第三方表中的欄位名稱並指向該物件

          inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns屬性來註解當前實體類持有引用物件在第三方表中的欄位名稱並指向被引用物件表

  )

  public Set<User> getRoles() {return roles;}

@Entity

public class Role {

  private int id;

  private String name;

  private Set<User> users = newHashSet<User>();

  @Id

  @GeneratedValue

  public int getId() {return id;  }

  @ManyToMany(mappedBy="roles")

  public Set<User>getUsers() {return users;}

  public voidsetUsers(Set<User> users) {this.users = users;  }

           session =HibernateUtils.getSession();

           tx =session.beginTransaction();

           Role role= (Role)session.load(Role.class, 1);

           System.out.println("role.name=" + role.getName());

           for(Iterator<User> iter = role.getUsers().iterator();iter.hasNext();){

               Useruser = iter.next();

               System.out.println("user.name=" + user.getName());

           }

           tx.commit();

Hibernate: select role0_.id as id2_0_, role0_.name as name2_0_ from t_rolerole0_ where role0_.id=?

role.name=資料錄入人員

Hibernate: select users0_.roleid as roleid1_, users0_.userid as userid1_,user1_.id as id0_0_, user1_.name as name0_0_ from t_user_role users0_ leftouter join t_user user1_ on users0_.userid=user1_.id where users0_.roleid=?order by users0_.userid

user.name=10

user.name=成龍

  private List<User>users = new ArrayList<User>();

  @OneToMany(mappedBy="group",

          cascade={CascadeType.ALL}

          )

  @OrderBy("name ASC")//使用@OrderBy註解List中使用哪個欄位進行排序，可以組合排序，中間使用逗號分開

  public List<User>getUsers() {  return users;}

  public voidsetUsers(List<User> users) {this.users = users;}

private Map<Integer,User> users = new HashMap<Integer, User>();

@OneToMany(mappedBy="group", cascade=CascadeType.ALL)

@MapKey(name="id")//註解使用哪個欄位為key

public Map<Integer,User> getUsers() {  return users;}

public voidsetUsers(Map<Integer, User> users) {this.users = users;}

     Session s = sessionFactory.getCurrentSession();

     s.beginTransaction();

     Group g =(Group)s.load(Group.class, 1);

     for(Map.Entry<Integer,User> entry : g.getUsers().entrySet()) {

         System.out.println(entry.getValue().getName());

     }

     s.getTransaction().commit();

public class Animal {

  private int id;

  private String name;   

  private boolean sex;

  public int getId() {return id;  }

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;}

  public boolean isSex() {return sex;}

  public void setSex(boolean sex) {this.sex = sex;} 

}

public class Pig extends Animal {

  private int weight;

  public int getWeight() {return weight;}

  public void setWeight(int weight) {this.weight = weight;}

}

public class Bird extends Animal {

  private int height;

  public int getHeight() {return height;}

  public void setHeight(int height) {this.height = height;} 

}

  <class name="Animal" table="t_animal"lazy="false">

      <id name="id">

          <generator class="native"/>

      </id>

      <discriminator column="type" type="string"/>

      <property name="name"/>

      <property name="sex"/>

      <subclass name="Pig" discriminator-value="P">

          <property name="weight"/>

      </subclass>

      <subclass name="Bird" discriminator-value="B">

          <property name="height"/>

      </subclass>

  </class>

@Entity

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@DiscriminatorColumn(

name="discriminator",

discriminatorType=DiscriminatorType.STRING)

@DiscriminatorValue("person")

public class Person {private int id;private String name;

  @Id

  @GeneratedValue

public int getId() {return id;}

create table t_animal (id integer not null auto_increment, typevarchar(255) not null, name varchar(255), sex bit, weight integer, heightinteger, primary key (id))

session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            Pig pig = new Pig();

            pig.setName("豬豬");

            pig.setSex(true);

            pig.setWeight(100);

            session.save(pig);

            Bird bird = new Bird();

            bird.setName("鳥鳥");

            bird.setSex(false);

            bird.setHeight(50);

            session.save(bird);

            tx.commit();

Hibernate: insert into t_animal (name, sex, weight, type) values (?, ?, ?,'P')//自動確定無height欄位,並且設定識別符號為P

Hibernate: insert into t_animal (name, sex, height, type) values (?, ?, ?,'B') //自動確定無weight欄位,並且設定識別符號為B

    session =HibernateUtils.getSession();

    tx =session.beginTransaction();

    Pig pig =(Pig)session.load(Pig.class, 1);

    System.out.println("pig.name=" + pig.getName());

    System.out.println("pig.weight=" + pig.getWeight());

    Bird bird =(Bird)session.load(Bird.class, 2);

    System.out.println("bird.name" + bird.getName());

    System.out.println("bird.height=" + bird.getHeight());

    tx.commit();

Hibernate: select pig0_.id as id0_0_, pig0_.name as name0_0_, pig0_.sex assex0_0_, pig0_.weight as weight0_0_ from t_animal pig0_ where pig0_.id=? and pig0_.type='P'

//hibernate會根據對映檔案自動確定哪些欄位(雖然表中有height,但hibernate並不會載入)屬於這個子類，並且確定識別符號為B（已經在配置檔案中設定了）

pig.name=豬豬

pig.weight=100

Hibernate: select bird0_.id as id0_0_, bird0_.name as name0_0_, bird0_.sexas sex0_0_, bird0_.height as height0_0_ from t_animal bird0_ where bird0_.id=?and bird0_.type='B'

//hibernate會根據對映檔案自動確定哪些欄位雖然表中有weight,但hibernate並不會載入屬於這個子類，並且確定識別符號為B（已經在配置檔案中設定了）

bird.name=鳥鳥

bird.height=50

session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            //不會發出SQL，返回一個代理類

            Animal animal =(Animal)session.load(Animal.class, 1);

            //發出SQL語句，並且載入所有欄位的資料(因為使用父類載入物件資料)

            System.out.println("animal.name=" + animal.getName());

            System.out.println("animal.sex=" + animal.isSex());

            tx.commit();

Hibernate: select animal0_.id as id0_0_, animal0_.name as name0_0_,animal0_.sex as sex0_0_, animal0_.weight asweight0_0_, animal0_.height as height0_0_, animal0_.type as type0_0_ from t_animal animal0_ where animal0_.id=?

//注：因為使用父類載入資料，所以hibernate會將所有欄位(height、weight、type)的資料全部載入，並且條件中沒有識別欄位type(也就不區分什麼子類，把所有子類全部載入上來。)

            session = HibernateUtils.getSession();

            tx =session.beginTransaction();

            //不會發出SQL語句(load預設支援延遲載入(lazy))，返回一個animal的代理物件(此代理類是繼承Animal生成的，也就是說是Animal一個子類)

            Animal animal =(Animal)session.load(Animal.class, 1);

            //因為在上面返回的是一個代理類(父類的一個子類)，所以animal不是Pig

            //通過instanceof是反應不出正直的物件型別的，因此load在預設情況下是不支援多型查詢的。

            if (animal instanceof Pig) {

                System.out.println("是豬");

            } else {

                System.out.println("不是豬");//這就是結果

            }

            System.out.println("animal.name=" + animal.getName());

            System.out.println("animal.sex=" + animal.isSex());

            tx.commit();

session = HibernateUtils.getSession();

            tx = session.beginTransaction();

            //會發出SQL語句，因為設定lazy為false，不支援延遲載入

            Animal animal =(Animal)session.load(Animal.class, 1);

            //可以正確的判斷出Pig的型別，因為lazy=false，返回具體的Pid型別

            //此時load支援多型查詢

            if (animal instanceof Pig) {

                System.out.println("是豬");//結果

            } else {

                System.out.println("不是豬");

            }

            System.out.println("animal.name=" + animal.getName());

            System.out.println("animal.sex=" + animal.isSex());

            tx.commit();

            session = HibernateUtils.getSession();

            tx = session.beginTransaction();

            //會發出SQL語句，因為get不支援延遲載入，返回的是正直的型別，

            Animal animal =(Animal)session.load(Animal.class, 1);

            //可以判斷出正直的型別

            //get是支援多型查詢

            if (animal instanceof Pig) {

                System.out.println("是豬");//結果

            } else {

                System.out.println("不是豬");

            }

            System.out.println("animal.name=" + animal.getName());

            System.out.println("animal.sex=" + animal.isSex());

            tx.commit();

List animalList = session.createQuery("from Animal").list();

            for (Iteratoriter = animalList.iterator(); iter.hasNext();) {

                Animal a = (Animal)iter.next();

                //能夠正確鑑別出正直的型別，HQL是支援多型查詢的。

                if (a instanceof Pig) {

                    System.out.println("是Pig");

                } else if (a instanceof Bird) {

                    System.out.println("是Bird");

                }

            }

List list = session.createQuery("from java.lang.Object").list();

            for (Iteratoriter = list.iterator(); iter.hasNext();){

                Object o =iter.next();

                if (o instanceof Pig) {

                    System.out.println("是Pig");

                } else {

                    System.out.println("是Bird");

                }

            }

    <class name="com.wjt276.hibernate.Animal" table="t_animal">

        <id name="id"column="id"><!-- 對映主鍵 -->

            <generator class="native"/>

        </id>

        <property name="name"/><!-- 對映普通屬性 -->

        <property name="sex"/>

        <!--<joined-subclass>標籤：繼承對映　每個類對映成一個表 -->

        <joined-subclass name="com.wjt276.hibernate.Pig" table="t_pig">

<!-- <key>標籤：會在相應的表（當前對映的表）裡，加入一個外來鍵 , 參照指向當前類的父類(當前Class標籤物件的表(t_animal))-->

            <key column="pigid"/>

            <property name="weight"/>

        </joined-subclass>

        <joined-subclass name="com.wjt276.hibernate.Bird" table="t_bird">

            <key column="birdid"/>

            <property name="height"/>

        </joined-subclass>

    </class>

@Entity

@Inheritance(strategy=InheritanceType.JOINED)

public class Person {

    private int id;

    private String name;

    @Id

    @GeneratedValue

    public int getId() {return id;}

create table t_animal (id integer notnull auto_increment, name varchar(255), sex bit, primary key (id))

create table t_bird (birdid integernot null, height integer, primary key (birdid))

create table t_pig (pigid integer notnull, weight integer, primary key (pigid))

altertable t_bird add index FKCB5B05A4A554009D(birdid), add constraint FKCB5B05A4A554009D foreign key (birdid) referencest_animal (id)

alter table t_pig add index FK68F8743FE77AC32 (pigid), add constraint FK68F8743FE77AC32 foreign key (pigid) references t_animal (id)

//共生成三個表，並在子類表中各有一個外來鍵參照指向父類表

    <class name="com.wjt276.hibernate.Animal" table="t_animal">

        <id name="id"column="id"><!-- 對映主鍵 -->

            <generator class="assigned"/><!-- 每個具體類對映一個表主鍵生成策略不可使用native -->       </id>  

        <property name="name"/><!-- 對映普通屬性 -->

        <property name="sex"/>

        <!--使用<union-subclass>標籤來對映"每個具體類對映成一張表"的對映關係

            ，實現上上面的表t_animal雖然對映到資料庫中，但它沒有任何作用。      -->

        <union-subclass name="com.wjt276.hibernate.Pig" table="t_pig">

            <property name="weight"/>

        </union-subclass>

        <union-subclass name="com.wjt276.hibernate.Bird" table="t_bird">

            <property name="height"/>

        </union-subclass>

    </class>

@Entity

@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)

@TableGenerator(

      name="t_gen",

      table="t_gen_table",

      pkColumnName="t_pk",

      valueColumnName="t_value",

      pkColumnValue="person_pk",

      initialValue=1,

      allocationSize=1

      )

public class Person {

private int id;

private String name;

  @Id

  @GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)

  public int getId() {return id;}

create table t_animal (id integer not null, name varchar(255), sex bit, primary key (id))

create table t_bird (id integer not null, name varchar(255), sex bit, height integer, primary key(id))

create table t_pig (id integer not null, name varchar(255), sex bit, weight integer, primary key(id))

注：表t_animal、 t_bird、t_pig並不是自增的，是因為bird、pig都是animal類，也就是說animal不可以有相同的ID號(Bird、Pig是型別，只是儲存的位置不同而以)

<class name="com.wjt276.hibernate.Animal" table="t_animal" abstract="true">

        <id name="id"column="id"><!-- 對映主鍵 -->

…………

/** * 節點*/

public class Node {

    private int id; //識別符號

    private String name; //節點名稱 

    private int level; //層次，為了輸出設計   

    private boolean leaf; //是否為葉子節點，這是為了效率設計，可有可無

    //父節點：因為多個節點屬於一個父節點，因此用hibernate對映關係說是“多對一”

    private Node parent;

    //子節點：因為一個節點有多個子節點，因此用hibernate對映關係說是“一對多”

    private Set children;

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {  this.name = name;}

    public int getLevel() { return level;}

    public void setLevel(int level) {this.level = level;}

    public boolean isLeaf() {return leaf;}

    public void setLeaf(boolean leaf) {this.leaf = leaf;}

    public Node getParent() {return parent;}

    public void setParent(Nodeparent) {this.parent = parent;}

    public SetgetChildren() {return children;}

    public void setChildren(Setchildren) {this.children = children;}}

  <class name="com.wjt276.hibernate.Node" table="t_node">

      <id name="id" column="id">

          <generator class="native"/>

      </id>

      <property name="name"/>

      <property name="level"/>

      <property name="leaf"/>

<!— 一對多：加入一個外來鍵，參照當前表t_node主鍵，    而屬性parent型別為Node，也就是當前類，則會在同一個表中加入這個欄位，參照這個表的主鍵-->

      <many-to-one name="parent" column="pid"/>

  <!--<set>標籤是對映一對多的方式，加入一個外來鍵，參照主鍵。-->

      <set name="children" lazy="extra"inverse="true">

          <key column="pid"/>

          <one-to-many class="com.wjt276.hibernate.Node"/>

      </set>     

  </class>

@Entity

public class Node {

    private int id; // 識別符號

    private String name; // 節點名稱

    private int level; // 層次，為了輸出設計

    private boolean leaf; // 是否為葉子節點，這是為了效率設計，可有可無

    // 父節點：因為多個節點屬於一個父節點，因此用hibernate對映關係說是“多對一”

    private Node parent;

    // 子節點：因為一個節點有多個子節點，因此用hibernate對映關係說是“一對多”

    private Set<Node> children = newHashSet<Node>();

    @Id

    @GeneratedValue

    public int getId() {return id;}

    @OneToMany(mappedBy="parent")

    public Set<Node>getChildren() {return children;}

    @ManyToOne

    @JoinColumn(name="pid")

    public Node getParent() {return parent;}

public class NodeTest extends TestCase {

  //測試節點的存在

  public void testSave1(){

      NodeManage.getInstanse().createNode("F:\\hibernate\\hibernate_training_tree");

  }

  //測試節點的載入

  public void testPrintById(){

      NodeManage.getInstanse().printNodeById(1);

  }}

public classNodeManage {  

    private static NodeManage nodeManage= newNodeManage();

    private NodeManage(){}//因為要使用單例，所以將其構造方法私有化

    //向外提供一個介面

    public static NodeManage getInstanse(){

        return nodeManage;

    }

    /**

     * 建立樹

     *@param filePath 需要建立樹目錄的根目錄

     */

    public void createNode(String dir) {

        Session session = null;    

        try {

            session =HibernateUtils.getSession();

            session.beginTransaction();

            File root = new File(dir);

            //因為第一個節點無父節點，因為是null

            this.saveNode(root, session, null,0);

            session.getTransaction().commit();

        } catch (HibernateException e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        } finally {

            HibernateUtils.closeSession(session);

        }}

    /**

     * 儲存節點物件至資料庫

     *@param file 節點所對應的檔案

     *@param session session

     *@param parent 父節點

     *@param level 級別

     */

    public void saveNode(File file, Sessionsession, Node parent, int level) {

        if (file == null ||!file.exists()){return;}

        //如果是檔案則返回true,則表示是葉子節點，否則為目錄，非葉子節點

        boolean isLeaf = file.isFile();

        Node node = new Node();

        node.setName(file.getName());

        node.setLeaf(isLeaf);

        node.setLevel(level);

        node.setParent(parent);

        session.save(node);

        //進行迴圈迭代子目錄

        File[] subFiles = file.listFiles();

        if (subFiles != null &&subFiles.length > 0){

            for (int i = 0; i <subFiles.length ; i++){

                this.saveNode(subFiles[i],session, node, level + 1);

            }}}

    /**

     * 輸出樹結構

     *@param id

     */

    public void printNodeById(int id) {

        Session session = null;

        try {

            session =HibernateUtils.getSession();

            session.beginTransaction();

            Node node =(Node)session.get(Node.class, 1);

            printNode(node);

            session.getTransaction().commit();

        } catch (HibernateException e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        } finally {

            HibernateUtils.closeSession(session);

        }      

    }  

    private void printNode(Node node) {    

        if (node == null){  return; }

        int level = node.getLevel();

        if (level > 0){

            for (int i = 0; i < level; i++){

                System.out.print("  |");

            }

            System.out.print("--");            

        }

        System.out.println(node.getName() +(node.isLeaf() ? "" : "[" + node.getChildren().size() +"]"));

        Set children = node.getChildren();

        for (Iterator iter =children.iterator(); iter.hasNext(); ){

            Node child = (Node)iter.next();

            printNode(child);

        }}}

* 課程

@Entity

public class Course {

  private int id;

  private String name;

  @Id

  @GeneratedValue

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;}}

* 分數

@Entity

@Table(name = "score")

public class Score {

  private int id;

  private int score;

  private Student student;

  private Course course;

  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToOne

  @JoinColumn(name = "student_id")

  public StudentgetStudent() {return student;}

  @ManyToOne

  @JoinColumn(name = "score_id")

  public Course getCourse(){ return course;}

  public int getScore() { return score;}

  public void setScore(int score) {this.score = score;}

  public void setStudent(Studentstudent) {this.student = student;}

  public void setCourse(Coursecourse) {this.course = course;}

  public void setId(int id) { this.id = id;}}

* 學生通過課程可以導航到分數

@Entity

public class Student {

  private int id;

  private String name;

  private Set<Course> courses = newHashSet<Course>();

  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToMany

  @JoinTable(name = "score", //此表就是Score實體類在資料庫生成的表叫score

          joinColumns= @JoinColumn(name = "student_id"),

          inverseJoinColumns= @JoinColumn(name = "course_id")

      )

  public Set<Course>getCourses() {return courses;}

  public voidsetCourses(Set<Course> courses) {this.courses = courses;}

  public void setId(int id) { this.id = id;}

  public String getName() {return name;}

  public void setName(Stringname) {this.name = name;}}

/** 版塊*/

@Entity

public class Category {

    private int id;

    private String name;

    @Id

    @GeneratedValue

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {this.name = name;}}

/**主題*/

@Entity

public class Topic {

    private int id;

    private String title;

    private Category category;

    //private Category category2;

    private Date createDate;   

    public DategetCreateDate() {return createDate;}

    public void setCreateDate(DatecreateDate) {this.createDate = createDate;}

    @ManyToOne(fetch=FetchType.LAZY)

    public CategorygetCategory() { return category;}

    public voidsetCategory(Category category) {this.category = category;   }

    @Id

    @GeneratedValue

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getTitle(){return title;}

    public void setTitle(Stringtitle) {this.title = title;}}

/**主題回覆*/

@Entity

public class Msg {

    private int id;

    private String cont;

    private Topic topic;   

    @ManyToOne

    public Topic getTopic() {return topic;}

    public void setTopic(Topictopic) {this.topic = topic;}

    @Id

    @GeneratedValue

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getCont() {return cont;}

    public void setCont(Stringcont) {this.cont = cont;}}

/**臨時類 */

public class MsgInfo { //VO DTO Value Object username p1 p2UserInfo->User->DB

    private int id;

    private String cont;

    private String topicName;

    private String categoryName;

    public MsgInfo(int id, String cont,String topicName, String categoryName) {

        super();

        this.id = id;

        this.cont = cont;

        this.topicName = topicName;

        this.categoryName =categoryName;

    }

    public StringgetTopicName() {return topicName;}

    public voidsetTopicName(String topicName) {this.topicName = topicName;}

    public StringgetCategoryName() {return categoryName;}

    public voidsetCategoryName(String categoryName) {

        this.categoryName =categoryName;

    }

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getCont() {return cont;}

    public void setCont(Stringcont) {this.cont = cont;}}

    @Test

    public void testSave() {

        Sessionsession = sf.openSession();

        session.beginTransaction();    

        for(int i=0; i<10; i++){

            Categoryc = new Category();

            c.setName("c" + i);

            session.save(c);

        }      

        for(int i=0; i<10; i++){

            Categoryc = new Category();

            c.setId(1);

            Topic t= new Topic();

            t.setCategory(c);

            t.setTitle("t" + i);

            t.setCreateDate(new Date());

            session.save(t);           

        }      

        for(int i=0; i<10; i++){         

            Topic t= new Topic();

            t.setId(1);

            Msg m = new Msg();

            m.setCont("m" + i);

            m.setTopic(t);

            session.save(m);           

        }

        session.getTransaction().commit();

        session.close();

    }

        /** QL:from + 實體類名稱 */

        Query q =session.createQuery("from Category");

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getName());

        }

        /* 可以為實體類起個別名，然後使用它 */

        Query q =session.createQuery("from Category c wherec.name > 'c5'");

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getName());

        }

        //排序

        Query q =session.createQuery("from Category c orderby c.name desc");

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getName());

        }

         * 為載入上來的物件屬性起別名，還可以使用

        Query q =session.createQuery("select distinct c fromCategory c order by c.name desc");

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getName());

        }

        /*Query q = session.createQuery("from Category c where c.id > :minand c.id < :max");

        //q.setParameter("min",2);

        //q.setParameter("max",8);

        q.setInteger("min",2);

        q.setInteger("max",8);*/

         * 可以使用冒號(：),作為佔位符，來接受引數使用。如下(鏈式程式設計)

        Query q =session.createQuery("from Category c wherec.id > :min and c.id < :max")

            .setInteger("min", 2)

            .setInteger("max", 8);

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getId()+ "-" + c.getName());

        }

        Query q =session.createQuery("from Category c wherec.id > ? and c.id < ?");

        q.setParameter(0, 2)

            .setParameter(1, 8);

//      q.setParameter(1, 8);

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getId()+ "-" + c.getName());

        }

//分頁

        Query q =session.createQuery("from Category c orderby c.name desc");

        q.setMaxResults(4);//每頁顯示的最大記錄數

        q.setFirstResult(2);//從第幾條開始顯示，從0開始

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getId()+ "-" + c.getName());

        }

        Query q =session.createQuery("select c.id,  c.name from Category c order by c.namedesc");

        List<Object[]>categories = (List<Object[]>)q.list();

        for(Object[] o : categories) {

            System.out.println(o[0] + "-" + o[1]);

        }

    //設定fetch type 為lazy後將不會有第二條sql語句

        Query q =session.createQuery("from Topic t wheret.category.id = 1");

        List<Topic>topics = (List<Topic>)q.list();

        for(Topic t : topics) {

            System.out.println(t.getTitle());

            //System.out.println(t.getCategory().getName());

        }

    //設定fetch type 為lazy後將不會有第二條sql語句

        Query q =session.createQuery("from Topic t wheret.category.id = 1");

        List<Topic>topics = (List<Topic>)q.list();

        for(Topic t : topics) {

            System.out.println(t.getTitle());

        }

        Query q =session.createQuery("from Msg m wherem.topic.category.id = 1");

        for(Object o : q.list()) {

            Msg m = (Msg)o;

            System.out.println(m.getCont());

        }

//瞭解即可

    //VO Value Object

    //DTO data transfer object

        Query q =session.createQuery("select newcom.bjsxt.hibernate.MsgInfo(m.id, m.cont, m.topic.title, m.topic.category.name)from Msg");

        for(Object o : q.list()) {

            MsgInfo m = (MsgInfo)o;

            System.out.println(m.getCont());

        }

    //動手測試left right join

    //為什麼不能直接寫Category名，而必須寫t.category

    //因為有可能存在多個成員變數（同一個類），需要指明用哪一個成員變數的連線條件來做連線

        Query q =session.createQuery("select t.title, c.namefrom Topic t join t.category c "); //join Category c

        for(Object o : q.list()) {

            Object[] m = (Object[])o;

            System.out.println(m[0] + "-" + m[1]);

        }

    //學習使用uniqueResult

        Query q = session.createQuery("from Msg m where m = :MsgToSearch "); //不重要

        Msg m = new Msg();

        m.setId(1);

        q.setParameter("MsgToSearch", m);

        Msg mResult =(Msg)q.uniqueResult();

        System.out.println(mResult.getCont());

        Query q =session.createQuery("select count(*) fromMsg m");

        long count = (Long)q.uniqueResult();

        System.out.println(count);

    Query q = session.createQuery("select max(m.id), min(m.id), avg(m.id), sum(m.id)from Msg m");

        Object[] o =(Object[])q.uniqueResult();

        System.out.println(o[0] + "-" + o[1] + "-" + o[2] + "-" + o[3]);

        Query q =session.createQuery("from Msg m where m.idbetween 3 and 5");

        for(Object o : q.list()) {

            Msg m = (Msg)o;

            System.out.println(m.getId()+ "-" + m.getCont());

        }

        Query q =session.createQuery("from Msg m where m.idin (3,4, 5)");

        for(Object o : q.list()) {

            Msg m = (Msg)o;

            System.out.println(m.getId()+ "-" + m.getCont());

        }

    //is null 與 is notnull

        Query q =session.createQuery("from Msg m where m.contis not null");

        for(Object o : q.list()) {

            Msg m = (Msg)o;

            System.out.println(m.getId()+ "-" + m.getCont());

        }

@Entity

@NamedQueries({

            @NamedQuery(name="topic.selectCertainTopic", query="from Topic t where t.id = :id")

        })

        /*@NamedNativeQueries(

        {

    @NamedNativeQuery(name="topic.select2_5Topic",query="select * from topic limit 2, 5")

        })*/

public class Topic {

    private int id;

    private String title;

    private Category category;

    private Date createDate;

    private List<Msg> msgs = newArrayList<Msg>();

    @OneToMany(mappedBy="topic")

    public List<Msg> getMsgs() {return msgs;}

    public void setMsgs(List<Msg> msgs) {this.msgs = msgs;}

    public Date getCreateDate() {return createDate;}

    public void setCreateDate(Date createDate) {this.createDate = createDate;   }

    @ManyToOne(fetch=FetchType.LAZY)

    public Category getCategory() { return category;}

    public void setCategory(Category category) {this.category = category;}

    @Id

    @GeneratedValue

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getTitle() {  return title;}

    public void setTitle(String title) {this.title = title;}}

    //is empty and is not empty

        Query q =session.createQuery("from Topic t wheret.msgs is empty");

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getId()+ "-" + t.getTitle());

        }

        Query q =session.createQuery("from Topic t wheret.title like '%5'");

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getId()+ "-" + t.getTitle());

        }

        Query q =session.createQuery("from Topic t wheret.title like '_5'");

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getId()+ "-" + t.getTitle());

        }

    //不重要

        Query q = session.createQuery("select lower(t.title)," +

                                             "upper(t.title)," +

                                             "trim(t.title)," +

                                             "concat(t.title,'***')," +

                                             "length(t.title)" +

                                             " from Topict ");

        for(Object o : q.list()) {

            Object[] arr = (Object[])o;

    System.out.println(arr[0] + "-" + arr[1] + "-" + arr[2] + "-" + arr[3] + "-" + arr[4] + "-");

        }

        Query q =session.createQuery("select abs(t.id)," +

                                             "sqrt(t.id)," +

                                             "mod(t.id,2)" +

                                             " from Topict ");

        for(Object o : q.list()) {

            Object[] arr =(Object[])o;

            System.out.println(arr[0] + "-" + arr[1] + "-" + arr[2] );

        }

Query q = session.createQuery("selectcurrent_date, current_time, current_timestamp, t.id from Topic t");

        for(Object o : q.list()) {

            Object[] arr =(Object[])o;

            System.out.println(arr[0] + " | " + arr[1] + " | " + arr[2] + " | " + arr[3]);

        }

        Query q =session.createQuery("from Topic t wheret.createDate < :date");

        q.setParameter("date", new Date());

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getTitle());

        }

        Query q =session.createQuery("select t.title,count(*) from Topic t group by t.title") ;

        for(Object o : q.list()) {

            Object[] arr =(Object[])o;

            System.out.println(arr[0] + "|" + arr[1]);

        }

Query q = session.createQuery("selectt.title, count(*) from Topic t group by t.title having count(*) >= 1") ;

        for(Object o : q.list()) {

            Object[] arr =(Object[])o;

            System.out.println(arr[0] + "|" + arr[1]);

        }

        Query q =session.createQuery("from Topic t where t.id< (select avg(t.id) from Topic t)") ;

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getTitle());

        }

        Query q =session.createQuery("from Topic t where t.id< ALL (select t.id from Topic t where mod(t.id, 2)= 0) ") ;

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getTitle());

        }

    //用in 可以實現exists的功能

    //但是exists執行效率高

// t.id not in (1)

        Query q =session.createQuery("from Topic t where notexists (select m.id from Msg m where m.topic.id=t.id)") ;

//      Query q =session.createQuery("from Topic t where exists (select m.id from Msg mwhere m.topic.id=t.id)") ;

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getTitle());

        }

    //update and delete

    //規範並沒有說明是不是要更新persistent object，所以如果要使用，建議在單獨的trasaction中執行

        Query q =session.createQuery("update Topic t sett.title = upper(t.title)") ;

        q.executeUpdate();

        q = session.createQuery("from Topic");

        for(Object o : q.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getTitle());

        }

        session.createQuery("update Topic t set t.title = lower(t.title)")

            .executeUpdate();

//不重要

        Query q =session.getNamedQuery("topic.selectCertainTopic");

        q.setParameter("id", 5);

        Topic t =(Topic)q.uniqueResult();

        System.out.println(t.getTitle());

    //Native（瞭解）

        SQLQuery q =session.createSQLQuery("select *from category limit 2,4").addEntity(Category.class);

        List<Category>categories = (List<Category>)q.list();

        for(Category c : categories) {

            System.out.println(c.getName());

        }

    public void testHQL_35() {

        //尚未實現JPA命名的NativeSQL

    }

        //criterion 標準/準則/約束

        Criteria c =session.createCriteria(Topic.class) //from Topic                 

                     .add(Restrictions.gt("id", 2)) //greater than = id > 2

                     .add(Restrictions.lt("id", 8)) //little than = id < 8

                     .add(Restrictions.like("title", "t_"))

                     .createCriteria("category")

                .add(Restrictions.between("id", 3, 5)) //category.id >= 3 and category.id <=5

                     ;

        //DetachedCriterea

        for(Object o : c.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getId()+ "-" + t.getTitle());

        }

Session session = HibernateSessionFactory.getSessionFactory().openSession(); 

Transaction ts = null; 

Criteria criteria = session.createCriteria(Order.class); 

int pageSize = 15;  

int pageNo = 1;  

criteria.setFirstResult((pageNo-1)*pageSize);  

criteria.setMaxResults(pageSize); 

Iterator it = criteria.list().iterator(); 

ts.commit(); 

HibernateSessionFactory.closeSession(); 

Session session = HibernateSessionFactory.getSessionFactory().openSession(); 

Transaction ts = session.beginTransaction(); 

Criteria cuscriteria = session.createCriteria(Customer.class); 

Criteria ordCriteria = cusCriteria.createCriteria("orders"); 

ordCriteria.add(Restrictions.gt("money", new Double(1000)));  

Iterator it = cusCriteria.list().iterator(); 

ts.commit(); 

HibernateSessionFactory.closeSession(); 

Session session = sf.openSession();

        session.beginTransaction();

        Topic tExample = new Topic();

        tExample.setTitle("T_");       

        Example e = Example.create(tExample)

                    .ignoreCase().enableLike();

        Criteria c = session.createCriteria(Topic.class)

                     .add(Restrictions.gt("id", 2))

                     .add(Restrictions.lt("id", 8))

                     .add(e);      

        for(Object o : c.list()) {

            Topic t = (Topic)o;

            System.out.println(t.getId() + "-" + t.getTitle());

        }

        session.getTransaction().commit();

        session.close();

Session session = HibernateSessionFactory.getSessionFactory().openSession(); 

Transaction ts = session.beginTransaction(); 

Customer c = new Customer(); 

c.setCname("Hibernate");  

Criteria criteria = session.createCriteria(Customer.class); 

Criteria.add(Example.create(c));  

Iterator it = criteria.list().iterator(); 

ts.commit();  

HibernateSessionFactory.closeSession();

session= HibernateUtils.getSession();

            tx = session.beginTransaction();

            /**

             * 出現N+1問題

             * 發出查詢id列表的sql語句

             * Hibernate: select student0_.id as col_0_0_ from t_student student0_

             *

             * 再依次發出根據id查詢Student物件的sql語句

             * Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_,

             * student0_.createTime as createTime1_0_, student0_.classesid as classesid1_0_

             * from t_student student0_ where student0_.id=?

             */

            Iterator students = session.createQuery("fromStudent").iterate();

            while (students.hasNext()){

                Student student =(Student)students.next();

                System.out.println(student.getName());

            }

tx.commit();

Liststudents = session.createQuery("from Student").list();

            for (Iterator iter = students.iterator();iter.hasNext();){

                Student student =(Student)iter.next();

                System.out.println(student.getName());

            }                       System.out.println("---------------------------------------------------------");

             // 不會出現N+1問題，因為list操作已經將資料加入到一級快取。

            Iterator iters =session.createQuery("from Student").iterate();

            while (iters.hasNext()){

                Student student =(Student)iters.next();

                System.out.println(student.getName());

            }

Liststudents = session.createQuery("from Student").list();

            for (Iterator iter = students.iterator();iter.hasNext();){

                Student student =(Student)iter.next();

                System.out.println(student.getName());

            }

            System.out.println("------------------------------------------------");

            //會再次發現SQL語句進行查詢，因為預設情況list只向快取中放入資料，不會使用快取中資料

            students = session.createQuery("fromStudent").list();

            for (Iterator iter = students.iterator();iter.hasNext();){

                Student student =(Student)iter.next();

                System.out.println(student.getName());

            }