`
niuzehao
  • 浏览: 812 次
  • 性别: Icon_minigender_1
  • 来自: 上海
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

hibernater学习笔记

HibernateXMLjunitSQL.net 
阅读更多
hibernate基本映射
实体类---表
实体类中的普通属性---表字段

采用<class>标签映射成数据库表，通过<property>标签将普通属性映射成表字段
所谓普通属性指不包括自定义类、集合和数组等

注意：如果实体类和实体类中的属性和sql中的关键字重复，必须采用table或column重新命名

实体类的设计原则：
* 实现一个默认的（即无参数的）构造方法（constructor）
* 提供一个标识属性（identifier property）（可选）
* 使用非final的类 (可选)
* 为持久化字段声明访问器(accessors)

主键生成策略：
uuid、native和assigned
1.uuid的用法
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="User1" table="t_user1">
<id name="id" column="user_id" length="32">
<generator class="uuid"/>
</id>
<property name="name" unique="true" not-null="true" length="20"/>
<property name="password" not-null="true" length="10"/>
<property name="createTime" column="create_time"/>
<property name="expireTime" column="expire_time"/>
</class>
</hibernate-mapping>
2.native的用法
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="User2" table="t_user2">
<id name="id" column="user_id">
<generator class="native"/>
</id>
<property name="name" unique="true" not-null="true" length="20"/>
<property name="password" not-null="true" length="10"/>
<property name="createTime" column="createtime"/>
<property name="expireTime" column="expiretime"/>
</class>
</hibernate-mapping>
3. assigned的用法
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="User3" table="t_user3">
<id name="id" column="user_id" length="32">
<generator class="assigned"/>
</id>
<property name="name" unique="true" not-null="true" length="20"/>
<property name="password" not-null="true" length="10"/>
<property name="createTime" column="create_time"/>
<property name="expireTime" column="expire_time"/>
</class>
</hibernate-mapping>

测试实体对象的生命周期

junit简介：
* 编写测试类xxxTest，需要继承TestCase
* 编写单元测试方法，测试方法必须以test开头，测试方法不能含有参数和返回值，如：
  public void testHello1() {}
* 最好单元测试的代码单独建立一个目录

了解Hibernate中CRUD操作

了解get和load的区别？
* get不支持lazy，load支持lazy
* 采用get加载数据，如果没有匹配的数据，返回null，而load则抛出异常

transient状态的特征？
* 在数据库中没有与之匹配的数据
* 没有纳入session的管理

persistent状态的特征？
* persistent状态的对象在数据库中有与之匹配的数据
* 纳入了session的管理
* 在清理缓存（脏数据检查）的时候,会和数据库同步

detached状态的特征？
* 在数据库中有与之匹配的数据
* 没有纳入session的管理


hibernate一级缓存

一级缓存很短和session的生命周期一致，一级缓存也叫session级的缓存或事务级缓存

那些方法支持一级缓存：
* get()
* load()
* iterate（查询实体对象）

如何管理一级缓存：
* session.clear(),session.evict()

如何避免一次性大量的实体数据入库导致内存溢出
* 先flush，再clear

如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具

hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享
二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

二级缓存的配置和使用：
* 将echcache.xml文件拷贝到src下
* 开启二级缓存，修改hibernate.cfg.xml文件
<property name="hibernate.cache.use_second_level_cache">true</property>
* 指定缓存产品提供商，修改hibernate.cfg.xml文件
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
* 指定那些实体类使用二级缓存（两种方法）
* 在映射文件中采用<cache>标签
* 在hibernate.cfg.xml文件中，采用<class-cache>标签

二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互
1.Ehcache.xml的配置
<ehcache>


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

    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

  
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />
</ehcache>
2.hibernate.cfg.xml的配置
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_cache</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">bjsxt</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>

<!-- 指定缓存产品提供商 -->
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

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

<class-cache class="com.bjsxt.hibernate.Student" usage="read-only"/>
</session-factory>
</hibernate-configuration>
3.student.xml的配置
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Student" table="t_student">
<!--
<cache usage="read-only"/>
-->
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="classes" column="classesid"/>
</class>
</hibernate-mapping>

集合映射
1. Collection.xml的配置
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.CollectionMapping" table="t_CollectionMapping">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="setValue" table="t_set_value">
<key column="set_id"/>
<element type="string" column="set_value"/>
</set>
<list name="listValue" table="t_list_value">
<key column="list_id"/>
<list-index column="list_index"/>
<element type="string" column="list_value"/>
</list>
<array name="arrayValue" table="t_array_value">
<key column="array_id"/>
<list-index column="array_index"/>
<element type="string" column="array_value"/>
</array>
<map name="mapValue" table="t_map_value">
<key column="map_id"/>
<map-key type="string" column="map_key"/>
<element type="string" column="map_value"/>
</map>
</class>
</hibernate-mapping>
2.collection.java
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.CollectionMapping" table="t_CollectionMapping">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="setValue" table="t_set_value">
<key column="set_id"/>
<element type="string" column="set_value"/>
</set>
<list name="listValue" table="t_list_value">
<key column="list_id"/>
<list-index column="list_index"/>
<element type="string" column="list_value"/>
</list>
<array name="arrayValue" table="t_array_value">
<key column="array_id"/>
<list-index column="array_index"/>
<element type="string" column="array_value"/>
</array>
<map name="mapValue" table="t_map_value">
<key column="map_id"/>
<map-key type="string" column="map_key"/>
<element type="string" column="map_value"/>
</map>
</class>
</hibernate-mapping>

component映射

在hibernate中,component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，
component可以成为是值对象（DDD）

采用component映射的好处：它实现了对象模型的细粒度划分，层次会更分明，复用率会更高
1.user.java
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(String name) {
this.name = name;
}

public Contact getContact() {
return contact;
}

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

}
2.contact.java
package com.bjsxt.hibernate;

public class Contact {

private String email;

private String address;

private String zipCode;

private String contactTel;

public String getEmail() {
return email;
}

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

public String getAddress() {
return address;
}

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

public String getZipCode() {
return zipCode;
}

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

public String getContactTel() {
return contactTel;
}

public void setContactTel(String contactTel) {
this.contactTel = contactTel;
}
}

3.component.xml的配置
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<component name="contact">
<property name="email"/>
<property name="address"/>
<property name="zipCode"/>
<property name="contactTel"/>
</component>
</class>
</hibernate-mapping>

复合（联合）主键映射

通常将复合主键相关的属性，单独放到一个类中
* 此类必须实现序列化接口
* 覆写hashcode和equals方法

1. FiscalYearPeriod.java
package com.bjsxt.hibernate;

import java.util.Date;
 
/**
* 核算期间
* @author wangy
*
*/
public class FiscalYearPeriod {

private FiscalYearPeriodPK fiscalYearPeriodPK;

//开始日期
private Date beginDate;

//结束日期
private Date endDate;

//状态
private String periodSts;

public Date getBeginDate() {
return beginDate;
}

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

public Date getEndDate() {
return endDate;
}

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

public String getPeriodSts() {
return periodSts;
}

public void setPeriodSts(String periodSts) {
this.periodSts = periodSts;
}

public FiscalYearPeriodPK getFiscalYearPeriodPK() {
return fiscalYearPeriodPK;
}

public void setFiscalYearPeriodPK(FiscalYearPeriodPK fiscalYearPeriodPK) {
this.fiscalYearPeriodPK = fiscalYearPeriodPK;
}
}
2. FiscalYearPeriodPK.java
package com.bjsxt.hibernate;

import java.io.Serializable;

public class FiscalYearPeriodPK implements 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;
final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;
if (fiscalPeriod != other.fiscalPeriod)
return false;
if (fiscalYear != other.fiscalYear)
return false;
return true;
}
3. FiscalYearPeriod.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<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>

整棵继承树映射成一张表

每棵继承树映射成一张表
t_animal
id name sex weight height type
1 猪猪 true 100 P
2 鸟鸟 false 50 B

1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、理解如何存储
存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值
正确的加载对象

多态查询：在hibernate加载数据的时候能鉴别出正真的类型（instanceOf）

get支持多态查询
load只有在lazy=false，才支持多态查询
hql支持多态查询

1.Animal.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<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>
</hibernate-mapping>

每个子类映射成一张表

每个子类映射成一张表
t_animal
id name sex
1
猪猪 true
2
鸟鸟 false
t_pig
pid weight
1 100
t_bird
bid height
2 50

1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，
这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，
有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。
如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

1.Animal.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Bird" table="t_bird">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>


每个具体类映射成一张表



每个具体类映射成一张表
t_pig
id name sex weight
1 猪猪 true 100
t_bird
id name sex height
2 鸟鸟 false 50
1、理解如何映射
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，
即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，
joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
父类用普通<class>标签定义即可
子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
Union-subclass标签不再需要包含key标签（与joined-subclass不同）
Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，
定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，
但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所
有属性的映射字段。

注意：在保存对象的时候id是不能重复的（不能使用自增生成主键）

1.Animal.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" abstract="true">
<id name="id">
<generator class="assigned"/>
</id>
<property name="name"/>
<property name="sex"/>
<union-subclass name="Pig" table="t_pig">
<property name="weight"/>
</union-subclass>
<union-subclass name="Bird" table="t_bird">
<property name="height"/>
</union-subclass>
</class>
</hibernate-mapping>


hibernate抓取策略（单端代理的批量抓取）

保持默认，同fetch="select",如：
<many-to-one name="classes" column="classesid" fetch="select"/>

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合


设置fetch="join",如：
<many-to-one name="classes" column="classesid" fetch="join"/>

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

保持默认，同fetch="select",如：
<set name="students" inverse="true" cascade="all" fetch="select">

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

设置fetch="join",如：
<set name="students" inverse="true" cascade="all" fetch="join">

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

设置fetch="subselect",如：
<set name="students" inverse="true" cascade="all" fetch="subselect">

fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合


hibernate抓取策略，,batch-szie在<class>上的应用

batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml
<class name="Classes" table="t_classes" batch-size="3">

batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml
<set name="students" inverse="true" cascade="all" batch-size="5">


hibernate查询语言hql

在hql中关键字不区分大小写，但是属性和类名区分大小写

1、简单属性查询【重要】
* 单一属性查询，返回结果集属性列表，元素类型和实体类中相应的属性类型一致
* 多个属性查询,返回的集合元素是对象数组,数组元素的类型和对应的属性在实体类中的类型一致
  数组的长度取决与select中属性的个数
* 如果认为返回数组不够对象化，可以采用hql动态实例化Student对象
参见：SimplePropertyQueryTest.java 
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 简单属性查询
* @author Administrator
*
*/
public class SimplePropertyQueryTest extends TestCase {

/**
* 单一属性查询
*/
public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//返回结果集属性列表，元素类型和实体类中相应的属性类型一致
List students = session.createQuery("select name from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
String name = (String)iter.next();
System.out.println(name);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 多个属性查询
*/
public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//查询多个属性，其集合元素是对象数组
//数组元素的类型和对应的属性在实体类中的类型一致
//数组的长度取决与select中属性的个数
List students = session.createQuery("select id, name from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 返回Student实体对象
*/
public void testQuery3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//如果认为返回数组不够对象化，可以采用hql动态实例化Student对象
//此时list中为Student对象集合
List students = session.createQuery("select new Student(id, name) from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getId() + "," + student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 使用别名
*/
public void testQuery4() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//可以使用别名
List students = session.createQuery("select s.id, s.name from Student s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 使用别名
*/
public void testQuery5() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//可以使用as命名别名
List students = session.createQuery("select s.id, s.name from Student as s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}


2、实体对象查询【重要】
* N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题
  所谓的N+1是在查询的时候发出了N+1条sql语句
  1: 首先发出一条查询对象id列表的sql
  N: 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句
* list和iterate的区别？
* list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据
* iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题
参见：SimpleObjectQueryTest1.java/SimpleObjectQueryTest2.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 实体对象查询
* @author Administrator
*
*/
public class SimpleObjectQueryTest1 extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//返回Student对象的集合
//可以忽略select
List students = session.createQuery("from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//返回Student对象的集合
//可以忽略select,表可以使用别名
List students = session.createQuery("from Student s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//返回Student对象的集合
//可以忽略select,表可以使用as命名别名
List students = session.createQuery("from Student as s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery4() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//返回Student对象的集合
//使用select查询实体对象，必须采用别名
List students = session.createQuery("select s from Student as s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}


public void testQuery5() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//不支持select * from .....这样的查询语句
List students = session.createQuery("select * from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 实体对象查询
* @author Administrator
*
*/
public class SimpleObjectQueryTest2 extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

/**
* 采用list查询发出一条查询语句，取得Student对象数据、
*
* Hibernate: select student0_.id as id1_, student0_.name as name1_,
* student0_.createTime as createTime1_, student0_.classesid as classesid1_
* from t_student student0_
*
*/
List students = session.createQuery("from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

/**
* 出现N+1问题
*
* 1：发出查询id列表的sql
*   Hibernate: select student0_.id as col_0_0_ from t_student student0_
*
* N：在依次发出根据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 iter = session.createQuery("from Student").iterate();
while(iter.hasNext()) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = 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操作已经将Student对象放到了一级缓存中，所以再次使用iterate操作的时候
* 它首先发出一条查询id列表的sql，在根据id到缓存中去数据，只有在缓存中找不到相应的
* 数据时，才会发出sql到数据库中查询
*
*/
Iterator iter = session.createQuery("from Student").iterate();
while(iter.hasNext()) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery4() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = 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每次都会向数据库发出查询对象的sql，除非配置查询缓存，所以下面的list操作
* 虽然在一级缓存中已经有了对象数据，但list默认情况下不会利用缓存，而再次发出sql
*
* 默认情况下，list会向缓存中放入数据，但不会利用数据
*
*/
students = session.createQuery("from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}


3、条件查询【重要】
* 可以采用拼字符串的方式传递参数
* 可以采用 ？来传递参数（索引从0开始）
* 可以采用 :参数名 来传递参数
* 如果传递多个参数，可以采用setParamterList方法
* 在hql中可以使用数据库的函数，如：date_format
参见：SimpleConditionQueryTest.java
package com.bjsxt.hibernate;

import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 条件查询
* @author Administrator
*
*/
public class SimpleConditionQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//可以拼字符串
List students = session.createQuery("select s.id, s.name from Student s where s.name like '%1%'").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

// Query query = session.createQuery("select s.id, s.name from Student s where s.name like ?");
// query.setParameter(0, "%1%");
// List students = query.list();

//可以使用？方式传递参数
//参数的索引从0开始
//传递的参数值，不用单引号引起来
//注意方法链编程
List students = session.createQuery("select s.id, s.name from Student s where s.name like ?")
       .setParameter(0, "%1%")
       .list();

for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//使用 ：参数名称 的方式传递参数值
List students = session.createQuery("select s.id, s.name from Student s where s.name like :myname")
       .setParameter("myname", "%1%")
       .list();

for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery4() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//使用 ：参数名称 的方式传递参数值
List students = session.createQuery("select s.id, s.name from Student s where s.name like :myname and s.id=:myid")
       .setParameter("myname", "%1%")
       .setParameter("myid", 12)
       .list();

for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery5() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//支持in，需要使用setParameterList进行参数传递
List students = session.createQuery("select s.id, s.name from Student s where s.id in(:myids)")
.setParameterList("myids", new Object[]{1, 2, 3, 4, 5})
       .list();

for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery6() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//查询2008年2月创建的学生
List students = session.createQuery("select s.id, s.name from Student s where date_format(s.createTime, '%Y-%m')=?")
.setParameter(0, "2008-02")
       .list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery7() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//查询2008-01-10到2008-02-15创建的学生
List students = session.createQuery("select s.id, s.name from Student s where s.createTime between ? and ?")
.setParameter(0, sdf.parse("2008-01-10 00:00:00"))
.setParameter(1, sdf.parse("2008-02-15 23:59:59"))
       .list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}

 
4、hibernate也支持直接使用sql进行查询
参见：SqlQueryTest.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 原生sql测试
* @author Administrator
*
*/
public class SqlQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.createSQLQuery("select * from t_student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}


5、外置命名查询
* 在映射文件中采用<query>标签来定义hql
* 在程序中采用session.getNamedQuery()方法得到hql查询串
参见：Student.hbm.xml、NameQueryTest.java
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="createTime"/>
<many-to-one name="classes" column="classesid"/>
<filter name="filtertest" condition="id &lt; :myid"/>
</class>

<query name="searchStudents">
<![CDATA[
SELECT s FROM Student s where s.id<?
]]>
</query>

<filter-def name="filtertest">
<filter-param name="myid" type="integer"/>
</filter-def>
</hibernate-mapping>
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 外置命名查询
* @author Administrator
*
*/
public class NameQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.getNamedQuery("searchStudents")
.setParameter(0, 10)
.list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}


6、查询过滤器
* 在映射文件中定义过滤器参数
* 在类的映射中使用这些参数
* 在程序中启用过滤器
参见：Student.hbm.xml、FilterQueryTest.java
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="createTime"/>
<many-to-one name="classes" column="classesid"/>
<filter name="filtertest" condition="id &lt; :myid"/>
</class>

<query name="searchStudents">
<![CDATA[
SELECT s FROM Student s where s.id<?
]]>
</query>

<filter-def name="filtertest">
<filter-param name="myid" type="integer"/>
</filter-def>
</hibernate-mapping>
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 查询过滤器
* @author Administrator
*
*/
public class FilterQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

session.enableFilter("filtertest")
    .setParameter("myid", 20);

List students = session.createQuery("from Student").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}


7、分页查询【重要】
* setFirstResult()，从0开始
* setMaxResults,每页显示多少条数据
参见：PageQueryTest.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 分页查询
* @author Administrator
*
*/
public class PageQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.createQuery("from Student")
.setFirstResult(1)
.setMaxResults(2)
.list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println(student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}

 
8、对象导航查询，在hql中采用 . 进行导航【重要】
参见：ObjectNavQueryTest.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 对象导航查询
* @author Administrator
*
*/
public class ObjectNavQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.createQuery("select s.name from Student s where s.classes.name like '%1%'").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
String name = (String)iter.next();
System.out.println(name);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}


9、连接查询【重要】
* 内连
* 外连接（左连接/右连接）
参见：JoinQueryTest.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 连接查询
* @author Administrator
*
*/
public class JoinQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//List students = session.createQuery("select c.name, s.name from Student s join s.classes c").list();
List students = session.createQuery("select c.name, s.name from Student s inner join s.classes c").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.createQuery("select c.name, s.name from Classes c left join c.students s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students = session.createQuery("select c.name, s.name from Classes c right join c.students s").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + "," + obj[1]);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}


10、统计查询【重要】
参见：StatQueryTest.java
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* 统计查询
* @author Administrator
*
*/
public class StatQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

// List students =session.createQuery("select count(*) from Student").list();
// Long count = (Long)students.get(0);
// System.out.println(count);

Long count = (Long)session.createQuery("select count(*) from Student").uniqueResult();
System.out.println(count);

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testQuery2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

List students =session.createQuery("select c.name, count(s) from Student s inner join s.classes c " +
"group by c.name order by c.name").list();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + ", " + obj[1]);
}

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}


11、DML风格的操作（尽量少用，因为和缓存不同步）
参见：DMLQueryTest.java
package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
* DML风格的操作
* @author Administrator
*
*/
public class DMLQueryTest extends TestCase {

public void testQuery1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

session.createQuery("update Student s set s.name=? where s.id < ?")
.setParameter(0, "李四")
.setParameter(1, 5)
.executeUpdate();

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}


hibernate lazy策略
可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用

hibernate在集合上的lazy策略，可以取值：true/false/extra

<class>标签上的lazy不会影响到集合上的lazy特性

hibernate在单端关联上的lazy策略，可以取值：false/proxy/noproxy

<class>标签上的lazy不会影响到单端关联上的lazy特性



hibernate多对多关联映射(单向User---->Role)
具体映射方式：
<set name="roles" table="t_user_role">
<key column="userid"/>
<many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
</set>















hibernate多对多关联映射(双向User<---->Role)

映射方法：
<set name="roles" table="t_user_role">
<key column="userid"/>
<many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
</set>
table属性值必须和单向关联中的table属性值一致
<key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致
在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致

1.user.java
package com.bjsxt.hibernate;

import java.util.Set;

public class User {

private int id;

private String name;

private Set roles;

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 Set getRoles() {
return roles;
}

public void setRoles(Set roles) {
this.roles = roles;
}

}
2.role.java
package com.bjsxt.hibernate;

import java.util.Set;

public class Role {

private int id;

private String name;

private Set users;

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 Set getUsers() {
return users;
}

public void setUsers(Set users) {
this.users = users;
}
}
3.user.hb.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="userid"/>
<many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
</set>
</class>
</hibernate-mapping>
4.role.hb.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="users" table="t_user_role" order-by="userid">
<key column="roleid"/>
<many-to-many class="com.bjsxt.hibernate.User" column="userid"/>
</set>
</class>
</hibernate-mapping>


hibernate多对一关联映射

关联映射的本质：
* 将关联关系映射到数据库，所谓的关联关系是对象模型在内存中的一个或多个引用

<many-to-one>会在多的一端加入一个外键，指向一的一端，这个外键是由<many-to-one>
中的column属性定义的，如果忽略了这个属性那么默认的外键与实体的属性一致

<many-to-one>标签的定义示例：
* <many-to-one name="group" column="groupid"/>

理解级联的含义？
* 是对象的连锁操作


hihernate一对多关联映射（单向Classes----->Student）

一对多关联映射利用了多对一关联映射原理

多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一
一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多

也就是说一对多和多对一的映射策略是一样的，只是站的角度不同

在一一端维护关系的缺点：
* 如果将t_student表里的classesid字段设置为非空，则无法保存
* 因为不是在student这一端维护关系，所以student不知道是哪个班的，
  所以需要发出多余的update语句来更新关系
1.classes.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students">
<key column="classesid"/>
<one-to-many class="Student"/>
</set>
</class>
</hibernate-mapping>


hihernate一对多关联映射（双向Classes<----->Student）

一对多双向关联映射：
* 在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端
* 在多一端采用<many-to-one>

注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误

如果在”一“一端维护一对多关联关系，hibernate会发出多余的udpate语句，所以我们一般在多
的一端来维护关联关系

关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，
默认inverse为false，所以我们可以从”一“一端和”多“一端维护关联关系，
如果设置成inverse为true，则我们只能从多一端来维护关联关系

注意：inverse属性，只影响数据的存储，也就是持久化

inverse和cascade
* inverse是关联关系的控制方向
* cascade操作上的连锁反应


hibernate一对一主键关联映射（单向关联Person---->IdCard）

一对一主键关联映射:让两个实体对象的id保持相同，这样可以避免多余的字段被创建

具体映射：

<id name="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"/>

hibernate一对一主键关联映射（双向关联Person<---->IdCard）

需要在idcard映射文件中加入<one-to-one>标签指向person，指示hibernate如何加载person
默认根据主键加载
1.person.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Person" table="t_person">
<id name="id">
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<one-to-one name="idCard" constrained="true"/>
</class>
</hibernate-mapping>
2.IdCard.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person"/>
</class>
</hibernate-mapping>

hibernate一对一主键关联映射（单向关联Person---->IdCard）

一对一主键关联映射:让两个实体对象的id保持相同，这样可以避免多余的字段被创建

具体映射：

<id name="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"/>
分享到：
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    HIBERNATER 学习笔记.doc

    ### HIBERNATE 学习笔记 #### 一、为什么使用Hibernate？ Hibernate 是一款非常流行的开源持久层框架，它能够简化 Java 应用程序与数据库之间的交互过程。使用 Hibernate 的主要原因是它可以极大地提高开发效率，...

    智慧园区3D可视化解决方案PPT(24页).pptx

    在智慧园区建设的浪潮中，一个集高效、安全、便捷于一体的综合解决方案正逐步成为现代园区管理的标配。这一方案旨在解决传统园区面临的智能化水平低、信息孤岛、管理手段落后等痛点，通过信息化平台与智能硬件的深度融合，为园区带来前所未有的变革。 首先，智慧园区综合解决方案以提升园区整体智能化水平为核心，打破了信息孤岛现象。通过构建统一的智能运营中心（IOC），采用1+N模式，即一个智能运营中心集成多个应用系统，实现了园区内各系统的互联互通与数据共享。IOC运营中心如同园区的“智慧大脑”，利用大数据可视化技术，将园区安防、机电设备运行、车辆通行、人员流动、能源能耗等关键信息实时呈现在拼接巨屏上，管理者可直观掌握园区运行状态，实现科学决策。这种“万物互联”的能力不仅消除了系统间的壁垒，还大幅提升了管理效率，让园区管理更加精细化、智能化。 更令人兴奋的是，该方案融入了诸多前沿科技，让智慧园区充满了未来感。例如，利用AI视频分析技术，智慧园区实现了对人脸、车辆、行为的智能识别与追踪，不仅极大提升了安防水平，还能为园区提供精准的人流分析、车辆管理等增值服务。同时，无人机巡查、巡逻机器人等智能设备的加入，让园区安全无死角，管理更轻松。特别是巡逻机器人，不仅能进行360度地面全天候巡检，还能自主绕障、充电，甚至具备火灾预警、空气质量检测等环境感知能力，成为了园区管理的得力助手。此外，通过构建高精度数字孪生系统，将园区现实场景与数字世界完美融合，管理者可借助VR/AR技术进行远程巡检、设备维护等操作，仿佛置身于一个虚拟与现实交织的智慧世界。 最值得关注的是，智慧园区综合解决方案还带来了显著的经济与社会效益。通过优化园区管理流程，实现降本增效。例如，智能库存管理、及时响应采购需求等举措，大幅减少了库存积压与浪费；而设备自动化与远程监控则降低了维修与人力成本。同时，借助大数据分析技术，园区可精准把握产业趋势，优化招商策略，提高入驻企业满意度与营收水平。此外，智慧园区的低碳节能设计，通过能源分析与精细化管理，实现了能耗的显著降低，为园区可持续发展奠定了坚实基础。总之，这一综合解决方案不仅让园区管理变得更加智慧、高效，更为入驻企业与员工带来了更加舒适、便捷的工作与生活环境，是未来园区建设的必然趋势。

    labelme标注的json转mask掩码图，用于分割数据集 批量转化，生成cityscapes格式的数据集

    labelme标注的json转mask掩码图，用于分割数据集 批量转化，生成cityscapes格式的数据集

    （参考GUI）MATLAB GUI漂浮物垃圾分类检测.zip

    （参考GUI）MATLAB GUI漂浮物垃圾分类检测.zip

    人脸识别_OpenCV_活体检测_证件照拍照_Demo_1741778955.zip

    人脸识别项目源码实战

    人脸识别_科大讯飞_Face_签到系统_Swface_1741770704.zip

    人脸识别项目实战

    跟网型逆变器小干扰稳定性分析与控制策略优化simulink仿真模型和代码.zip

    本仿真模型基于MATLAB/Simulink（版本MATLAB 2016Rb）软件。建议采用matlab2016 Rb及以上版本打开。（若需要其他版本可联系代为转换） CSDN详情地址：https://blog.csdn.net/qq_50594161/article/details/146242453sharetype=blogdetail&sharerId=146242453&sharerefer=PC&sharesource=qq_50594161&spm=1011.2480.3001.8118

    16-1文本表示&词嵌入.ipynb

    实战练习分词、创建词表、文本处理

    45页-零碳智慧园区标准解决方案：模块化、可扩展且可复制的解决方案.pdf

    在智慧园区建设的浪潮中，一个集高效、安全、便捷于一体的综合解决方案正逐步成为现代园区管理的标配。这一方案旨在解决传统园区面临的智能化水平低、信息孤岛、管理手段落后等痛点，通过信息化平台与智能硬件的深度融合，为园区带来前所未有的变革。 首先，智慧园区综合解决方案以提升园区整体智能化水平为核心，打破了信息孤岛现象。通过构建统一的智能运营中心（IOC），采用1+N模式，即一个智能运营中心集成多个应用系统，实现了园区内各系统的互联互通与数据共享。IOC运营中心如同园区的“智慧大脑”，利用大数据可视化技术，将园区安防、机电设备运行、车辆通行、人员流动、能源能耗等关键信息实时呈现在拼接巨屏上，管理者可直观掌握园区运行状态，实现科学决策。这种“万物互联”的能力不仅消除了系统间的壁垒，还大幅提升了管理效率，让园区管理更加精细化、智能化。 更令人兴奋的是，该方案融入了诸多前沿科技，让智慧园区充满了未来感。例如，利用AI视频分析技术，智慧园区实现了对人脸、车辆、行为的智能识别与追踪，不仅极大提升了安防水平，还能为园区提供精准的人流分析、车辆管理等增值服务。同时，无人机巡查、巡逻机器人等智能设备的加入，让园区安全无死角，管理更轻松。特别是巡逻机器人，不仅能进行360度地面全天候巡检，还能自主绕障、充电，甚至具备火灾预警、空气质量检测等环境感知能力，成为了园区管理的得力助手。此外，通过构建高精度数字孪生系统，将园区现实场景与数字世界完美融合，管理者可借助VR/AR技术进行远程巡检、设备维护等操作，仿佛置身于一个虚拟与现实交织的智慧世界。 最值得关注的是，智慧园区综合解决方案还带来了显著的经济与社会效益。通过优化园区管理流程，实现降本增效。例如，智能库存管理、及时响应采购需求等举措，大幅减少了库存积压与浪费；而设备自动化与远程监控则降低了维修与人力成本。同时，借助大数据分析技术，园区可精准把握产业趋势，优化招商策略，提高入驻企业满意度与营收水平。此外，智慧园区的低碳节能设计，通过能源分析与精细化管理，实现了能耗的显著降低，为园区可持续发展奠定了坚实基础。总之，这一综合解决方案不仅让园区管理变得更加智慧、高效，更为入驻企业与员工带来了更加舒适、便捷的工作与生活环境，是未来园区建设的必然趋势。

    人脸识别_活体检测_数据录入_登录系统Face_Login_1741778308.zip

    人脸识别项目源码实战

    学生信息管理平台是一个基于Java Web技术的综合性管理平台

    学生信息管理系统是一个基于Java Web技术的综合性管理平台。通过此系统，可以实现对学生、教师、选课信息等的动态管理， 提升学校管理效率。系统采用分层架构设计，前端使用HTML、CSS，JavaScript和jQuery，后端基于Servlet，JSP和Spring框架，数据库采用MySQL。主要有四个大功能，学生管理（ 增加学生信息、删除学生信息、修改学生信息、查询学生信息）、教师管理（增加教师信息、删除教师信息、修改教师信息、查询教师信息）、选课信息管理（添加选课、查询选课情况、删除选课记录）、系统管理（ 登录与注册功能、 用户角色管理（老师，学生，管理员）、系统日志查看）。 技术架构 1.前端技术 HTML,CSS：静态页面布局与样式 JavaScript，jQuery：动态交互、DOM操作和AJAX请求 2.后端技术 Servlet：控制层，处理用户请求 JSP：页面动态生成 Spring：依赖注入，业务逻辑分离 3.数据库 MySQL：存储学生、教师，课程等数据 JDBC：数据库连接与操作

    PHP进阶系列之Swoole入门精讲（课程视频）

    本课程是 PHP 进阶系列之 Swoole 入门精讲，系统讲解 Swoole 在 PHP 高性能开发中的应用，涵盖 协程、异步编程、WebSocket、TCP/UDP 通信、任务投递、定时器等核心功能。通过理论解析和实战案例相结合，帮助开发者掌握 Swoole 的基本使用方法及其在高并发场景下的应用。 适用人群： 适合 有一定 PHP 基础的开发者、希望提升后端性能优化能力的工程师，以及 对高并发、异步编程感兴趣的学习者。 能学到什么： 掌握 Swoole 基础——理解 Swoole 的核心概念，如协程、异步编程、事件驱动等。 高并发处理——学习如何使用 Swoole 构建高并发的 Web 服务器、TCP/UDP 服务器。 实战项目经验——通过案例实践，掌握 Swoole 在 WebSocket、消息队列、微服务等场景的应用。 阅读建议： 建议先掌握 PHP 基础，了解 HTTP 服务器和并发处理相关概念。学习过程中，结合 官方文档和实际项目 进行实践，加深理解，逐步提升 Swoole 开发能力。

    人脸识别_表情分析_spider运行_数据采集用途_1741771318.zip

    人脸识别项目实战

    美颜_GPUimage_人脸识别_动态贴纸_Demo_1741771705.zip

    人脸识别项目实战

    人脸照片文件批量分辨率裁剪工具

    功能简介：本工具可实现批量对照片文件的人脸识别，并按指定分辨率进行转换保存。 可为人脸识别采集系统提供很好的辅助工具。 软件基本于OPENVC开发，识别精确，转换高效。 人脸识别工具 +人脸采集处理

    基于强化学习与肌肉长度反馈控制的高效无意识姿态稳定算法研究（可复现，有问题请联系博主）

    内容概要：本文探讨了利用肌长变化反馈控制（FCM-ML）和演员-评论家强化学习（ACRL-NGN）来有效实现人体上肢和下肢无意识姿态稳定的算法方法。通过构建一个包含949条肌肉和22个关节的全身计算模型，在不同初始姿势的情况下进行模拟试验，验证了这些方法的有效性和鲁棒性，结果显示FCM-ML方法比其他传统方法更适用于此类任务。研究指出人类及其他脊椎动物在无意识状态下，通过抗拮抗性的肌肉长度变化反馈机制来维持舒适状态下的自然身体姿势（NBP）。此外，研究还表明这种控制策略有助于机器人设计、运动员训练以及康复患者的治疗。 适用人群：生物力学、机器人学以及神经科学领域的研究人员、工程师，以及关注人体姿态控制及其应用的学者和技术人员。 使用场景及目标：①解释人和非人的脊椎动物如何在无意识情况下维持最佳姿势，特别是处于重力环境中的自然身体姿势（NBP）。②为机器人肌肉控制提供理论支持和发展方向，特别是在模拟多肌肉协调控制方面。③指导运动训练及病患恢复计划的设计与优化。 其他说明：研究发现ACRL-NGN结合FCM-ML不仅能够迅速有效地实现期望的姿态稳定性，而且不需要对肌肉分类，这使其在复

    反编译apk重要的工具之一

    反编译apk重要的工具之一

    `计算机视觉_Python_PyQt5_Opencv_综合图像处理与识别跟踪系统`.zip

    人脸识别项目实战

    FDTD复现圆偏振超透镜 ,FDTD; 复现; 圆偏振; 超透镜;,FDTD技术在超透镜复现圆偏振的实践

    FDTD复现圆偏振超透镜 ,FDTD; 复现; 圆偏振; 超透镜;,FDTD技术在超透镜复现圆偏振的实践

Magicbox
Global site tag (gtag.js) - Google Analytics