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

}

<ehcache>

<!-- 设置当缓存对象益出时，对象保存到磁盘时的保存路径。

　　　如　d:\xxxx

The following properties aretranslated:

user.home - User's home directory

user.dir - User's current workingdirectory

java.io.tmpdir - windows的暂时文件夹 -->

<diskStore path="java.io.tmpdir"/>

<!--默认配置/或对某一个类进行管理

maxInMemory       - 缓存中能够存入的最多个对象数

eternal           - true:表示永不失效，false：不是永久有效的。

timeToIdleSeconds - 空暇时间，当第一次訪问后在空暇时间内没有訪问，则对象失效，单位为秒

timeToLiveSeconds - 被缓存的对象有效的生命时间，单位为秒

overflowToDisk  当缓存中对象数超过核定数(益出时)时，对象是否保存到磁盘上。true:保存；false：不保存

假设保存，则保存路径在标签<diskStore>中属性path指定

-->

<defaultCache

maxElementsInMemory="10000"

eternal="false"

timeToIdleSeconds="120"

timeToLiveSeconds="120"

overflowToDisk="true"

/>

</ehcache>

<!--开启二级缓存，hibernate默认的二级缓存就是开启的 -->

<property name="hibernate.cache.use_second_level_cache">true</property>

<!--指定二级缓存提供商-->

<property name="hibernate.cache.provider_class">

org.hibernate.cache.EhCacheProvider

</property>

<cache 

    usage="transactional|read-write|nonstrict-read-write|read-only"  (1)

    region="RegionName"                                              (2)

    include="all|non-lazy"                                           (3)

/>

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

<!--  指定实体类使用二级缓存　-->

        <cache usage="read-only"/>//***********

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

<generator class="native"/>

</id>

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

<!--

使用多对一标签映射 一对多双向，下列的column值必需与多的一端的key字段值一样。

-->

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

</class>

<hibernate-configuration>

<session-factory>

…………

<mapping resource="com/wjt276/hibernate/Classes.hbm.xml"/>

<mapping resource="com/wjt276/hibernate/Student.hbm.xml"/>

<class-cache class="com.wjt276.hibernate.Student"usage="read-only"/>

</session-factory>

</hibernate-configuration>

@Entity

@Cache(usage= CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

publicclass Forest { ... }

@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)

@JoinColumn(name="CUST_ID")

@Cache(usage =CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

public SortedSet<Ticket> getTickets(){

return tickets;

}

@Cache(

CacheConcurrencyStrategy usage();                 (1)

String region() default "";                       (2)

String include() default"all";                   (3)

)

使用SessionFactory清除二级缓存

Sessionsession = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Student student = (Student)session.load(Student.class, 1);

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

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

//管理二级缓存

SessionFactory factory = HibernateUtils.getSessionFactory();

//factory.evict(Student.class);

factory.evict(Student.class, 1);

try {

session = HibernateUtils.getSession();

session.beginTransaction();

//会发出查询sql，由于二级缓存中的数据被清除了

Student student = (Student)session.load(Student.class, 1);

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

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

Sessionsession = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

//仅向二级缓存读数据，而不向二级缓存写数据

session.setCacheMode(CacheMode.GET);

Student student =(Student)session.load(Student.class, 1);

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

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

try {

session = HibernateUtils.getSession();

session.beginTransaction();

//发出sql语句，由于session设置了CacheMode为GET，所以二级缓存中没有数据

Student student =(Student)session.load(Student.class, 1);

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

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

try {

session = HibernateUtils.getSession();

session.beginTransaction();

//仅仅向二级缓存写数据，而不从二级缓存读数据

session.setCacheMode(CacheMode.PUT);

//会发出查询sql，由于session将CacheMode设置成了PUT

Student student =(Student)session.load(Student.class, 1);

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

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

<propertyname="hibernate.cache.use_query_cache">true</property>

         query.setCacheable(true);

session= HibernateUtils.getSession();

session.beginTransaction();

Query query = session.createQuery("selects.name from Student s");

//启用查询查询缓存

query.setCacheable(true);

List names = query.list();

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

String name =(String)iter.next();

System.out.println(name);

}

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

query = session.createQuery("selects.name from Student s");

//启用查询查询缓存

query.setCacheable(true);

//没有发出查询sql，由于启用了查询缓存

names = query.list();

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

String name =(String)iter.next();

System.out.println(name);

}

         session.getTransaction().commit();

Session session = sf.openSession();

session.beginTransaction();

List<Category>categories = (List<Category>)session.createQuery("from Category")

.setCacheable(true).list();

session.getTransaction().commit();

session.close();

Session session2 = sf.openSession();

session2.beginTransaction();

List<Category>categories2 = (List<Category>)session2.createQuery("from Category")

.setCacheable(true).list();

session2.getTransaction().commit();

         session2.close();

方法：select@@tx_isolation;

比如：改动为未提交读：settransaction isolation level read uncommitted;

public class Inventory {

private int itemNo;

privateString itemName;

private int quantity;

public intgetItemNo() {

return itemNo;

}

public voidsetItemNo(intitemNo) {

this.itemNo =itemNo;

}

publicString getItemName() {

return itemName;

}

public voidsetItemName(String itemName) {

this.itemName =itemName;

}

public intgetQuantity() {

return quantity;

}

public voidsetQuantity(intquantity) {

this.quantity =quantity;

}

}

<hibernate-mapping>

<class name="com.wjt276.hibernate.Inventory"table="t_inventory">

<id name="itemNo">

<generator class="native"/>

</id>

<property name="itemName"/>

<property name="quantity"/>

</class>

</hibernate-mapping>

session= HibernateUtils.getSession();

tx = session.beginTransaction();

Inventory inv =(Inventory)session.load(Inventory.class, 1,LockMode.UPGRADE);

System.out.println(inv.getItemName());

inv.setQuantity(inv.getQuantity()-200);

session.update(inv);

tx.commit();

Hibernate:select inventory0_.itemNo as itemNo0_0_, inventory0_.itemName as itemName0_0_,inventory0_.quantity as quantity0_0_ from t_inventory inventory0_ where inventory0_.itemNo=?for update　//在select语句中增加for update进行使用悲观锁。

脑白金

Hibernate:update t_inventory set itemName=?, quantity=? where itemNo=?

注：仅仅实用户释放锁后，别的用户才干够读取

public classInventory {

private int itemNo;

privateString itemName;

private int quantity;

private int version;//Hibernate用户实现版本号方式乐观锁，但须要在映射文件里配置

public intgetItemNo() {

return itemNo;

}

public voidsetItemNo(intitemNo) {

this.itemNo =itemNo;

}

publicString getItemName() {

return itemName;

}

public voidsetItemName(String itemName) {

this.itemName =itemName;

}

public intgetQuantity() {

return quantity;

}

public voidsetQuantity(intquantity) {

this.quantity =quantity;

}

public intgetVersion() {

return version;

}

public voidsetVersion(intversion) {

this.version =version;

}

}

<hibernate-mapping>

<!-- 映射实体类时，须要增加一个开启乐观锁的属性

optimistic-lock="version"　共同拥有好几种方式：

- none  -version   - dirty - all

同一时候须要在主键映射后面映射版本号号字段

-->

<class name="com.wjt276.hibernate.Inventory"table="t_inventory"optimistic-lock="version">

<id name="itemNo">

<generator class="native"/>

</id>

<version name="version"/><!—必需配置在主键映射后面 -->

<property name="itemName"/>

<property name="quantity"/>

</class>

</hibernate-mapping>

createtable t_inventory (itemNo integer not null auto_increment, versioninteger not null, itemName varchar(255), quantity integer,primary key (itemNo))