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