Hibernate学习笔记

大小写不敏感

持久化类一般被定义为JavaBean，这是推荐的设计，但是并不是必须的。Hibernate也可以直接访问这些field。

所有的持久化类（persistent classes）都要求有无参的构造器，因为Hibernate必须使用Java反射机制来为你创建对象。

映射文件

一个映射文件看起来像这样

<hibernate-mapping>

    <class name="events.Event" table="EVENTS">

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

            <generator class="native"/>

        </id>

        <property name="date" type="timestamp" column="EVENT_DATE"/>

        <property name="title"/>

    </class>

</hibernate-mapping>

class元素代表要持久化的类以及它对应的数据表（一般情况下一个类对应一个表）

id元素中的name属性代表持久化类的标识符，而column则代表对应表中的主键。除此之外我们还要用generrator属性定义标识符的生成策略。

property属性用于映射持久化类的字段。有时候你需要手工指定转换成为的数据库数据类型以及数据表

Hibernate配置

配置Hibernate的工作就是配置hibernate.properties或者hibernate.cfg.xml

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->

        <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>

        <property name="connection.url">jdbc:hsqldb:hsql://localhost</property>

        <property name="connection.username">sa</property>

        <property name="connection.password"></property>

        <!-- JDBC connection pool (use the built-in) -->

        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->

        <property name="dialect">org.hibernate.dialect.HSQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->

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

        <!-- Disable the second-level cache  -->

        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->

        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->

        <property name="hbm2ddl.auto">create</property>

        <mapping resource="events/Event.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

在这里，我们配置了Hibernate的SessionFactory－一个关联于特定数据库全局的工厂（factory）。如果你要使用多个数据库，就要用多个的<session-factory>，通常把它们放在多个配置文件中（为了更容易启动）。

用Ant来构建程序 

build.xml

<project name="hibernate-tutorial" default="compile">

    <property name="sourcedir" value="${basedir}/src"/>

    <property name="targetdir" value="${basedir}/bin"/>

    <property name="librarydir" value="${basedir}/lib"/>

    <path id="libraries">

        <fileset dir="${librarydir}">

            <include name="*.jar"/>

        </fileset>

    </path>

    <target name="clean">

        <delete dir="${targetdir}"/>

        <mkdir dir="${targetdir}"/>

    </target>

    <target name="compile" depends="clean, copy-resources">

      <javac srcdir="${sourcedir}"

             destdir="${targetdir}"

             classpathref="libraries"/>

    </target>

    <target name="copy-resources">

        <copy todir="${targetdir}">

            <fileset dir="${sourcedir}">

                <exclude name="**/*.java"/>

            </fileset>

        </copy>

    </target>

</project>

启动和辅助类

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Session session = sessionFactory.getCurrentSession()

  映射 

理解对象标识符

映射组合

细粒度对象模型

Hibernate项目的主要目标之一就是支持细粒度模型，

实体类型和值类型Entity and value type

实体类型：一个实体类型对象拥有它自己的数据库标识符（primary key值），一个被实体引用的对象以一个引用的方式持久化在一个数据库中（a foreign key value）。一个实体拥有它自己的生命周期；它相对于其他实体独立存在。

值类型：一个值类型对象没有数据库标识符；它属于一个实体，并且它的持久化状态是嵌入到属主实体的数据表行中（除了集合类型以外，）值类型没有标识符或者标识符参数。值类型实例的生命周期绑定在它的属主实体上。

建立关系数据库模型的一个重要原则是在不会导致数据冗余的前提下，尽可能减少数据库表的数目及表之间的外键参照关系。

映射组合关系就是指多个类对应一个表的映射。如Address、Customer类对应CUSTOMER表。

主要通过<component>元素来完成的。

映射继承关系

数据表之间并不存在继承关系，如何映射类间的继承关系呢？有三种方法：

1.每一个具体类对应一个表table-per-concrete-class

2.整个继承层次对应一个表table-per-class-hierarchy

<hibernate-mapping>

    <class name="BillingDetails" table="BILLING_DETAILS" discriminator-value="BD">

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

            <generator class="native" />

        </id>

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

        <property name="name" column="OWNER" type="string" />

        

        <subclass name="CreditCard" discriminator-value="CC">

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

            

        </subclass>

        

    </class>

</hibernate-mapping>

<discriminator>

<subclass>

3.每个子类对应一个表table-per-subclass

<?xml version="1.0"?>

<hibernate-mapping>

    <class name="BillingDetails" table="BILLING_DETAILS">

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

            <generator class="native" />

        </id>

        <property name="owner" column="OWNER" type="string" />

        

        <joined-subclass name="CreditCard" table="CREDIT_CARD">

            <key column="CREDIT_CARD_ID">

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

                

        </joined-subclass>

        

    </class>

</hibernate-mapping>

<joined-subclass>

选择一个继承策略

1.如果不需要支持多态关联以及多态查询，倾向于使用table-per-concrete-class

2.如果需要多态关联和多态查询，并且子类包含的属性不多，倾向于使用table-per-class-hierarchy

3.如果需要多态关联和多态查询，而子类包含的属性很多，倾向于使用table-per-subclass

映射关联关系

一对一关联One-to-one associations

Hibernate提供了两种一对一关联关系的方法：

1. 使用（唯一）外键来关联Using a foreign key association

最简单的方法表现一对一关联是在外键上使用带有unique约束的<many-to-one>映射。

为什么要用many-to-one呢？实际上唯一外键关联的一对一关系只是多对一关系的一个特例而已。

Customer.java

public class Customer implements Serializable {

    .

    private Address homeAddress;

    private Address comAddress;

    public mypack.Address getHomeAddress() {

        return this.homeAddress;

    }

    public void setHomeAddress(mypack.Address homeAddress) {

        this.homeAddress = homeAddress;

    }

    public mypack.Address getComAddress() {

        return this.comAddress;

    }

    public void setComAddress(mypack.Address comAddress) {

        this.comAddress = comAddress;

    }

    .

}

Customer.hbm.xml

<hibernate-mapping>

    <class name="mypack.Customer" table="CUSTOMERS">

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

            <generator class="increment" />

        </id>

        <property name="name" column="NAME" type="string" />

        <many-to-one name="homeAddress" class="mypack.Address" column="HOME_ADDRESS_ID" cascade="all" unique="true" />

        <many-to-one name="comAddress" class="mypack.Address" column="COM_ADDRESS_ID" cascade="all" unique="true" />

    </class>

</hibernate-mapping>

为了实现双向一对一关系，我们

Address.java

public class Address implements Serializable {

    .

    private Customer customer;

    public mypack.Customer getCustomer() {

        return this.customer;

    }

    public void setCustomer(mypack.Customer customer) {

        this.customer = customer;

    }

    .

}

Address.hbm.xml

<hibernate-mapping>

    <class name="mypack.Address" table="ADDRESSES">

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

            <generator class="increment" />

        </id>

        <property name="city" column="CITY" type="string" />

        <property name="province" column="PROVINCE" type="string" />

        <property name="street" column="STREET" type="string" />

        <property name="zipcode" column="ZIPCODE" type="string" />

        <one-to-one name="customer" class="mypack.Customer" property-ref="homeAddress" />

    </class>

</hibernate-mapping>

2.使用主键来关联Using a primary key association

多对一单向关联many-to-One associations

Customer类是one，按照普通类来定义并映射，无需定义Orader对象的集合属性。

public class Customer implements Serializable {

.

}

<hibernate-mapping>

    <class name="mypack.Customer" table="CUSTOMERS">

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

            <generator class="increment" />

        </id>

        <property name="name" type="string">

            <column name="NAME" length="15" />

        </property>

    </class>

</hibernate-mapping>

Orader类是many，Orader类中需要定义一个customer属性

public class Order implements Serializable {

    .

    private mypack.Customer customer;

    public mypack.Customer getCustomer() {

        return this.customer;

    }

    public void setCustomer(mypack.Customer customer) {

        this.customer = customer;

    }

    .

}

<hibernate-mapping>

    <class name="mypack.Order" table="ORDERS">

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

            <generator class="increment" />

        </id>

        <property name="orderNumber" type="string">

            <column name="ORDER_NUMBER" length="15" />

        </property>

        <many-to-one name="customer" column="CUSTOMER_ID" class="mypack.Customer" not-null="true" />

    </class>

</hibernate-mapping>

一对多双向关联One-to-many associations

在双向关联中，我们既可以从Orader对象中得到它所属的Customer，亦可从Customer中获得它所关联的所有Order。

这时候，我们需要在Customer类中增加一个集合类型的Orders属性。

Customer.java

public class Customer implements Serializable {

    

    private Set orders;

    public Set getOrders() {

        return this.orders;

    }

    public void setOrders(Set orders) {

        this.orders = orders;

    }

    

}

Customer.hbm.xml

<hibernate-mapping>

    <class name="mypack.Customer" table="CUSTOMERS">

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

            <generator class="increment" />

        </id>

        <property name="name" type="string">

            <column name="NAME" length="15" />

        </property>

        <set name="orders" inverse="true" cascade="save-update">

            <key column="CUSTOMER_ID" />

            <one-to-many class="mypack.Order" />

        </set>

    </class>

</hibernate-mapping>

一对多双向自关联

同一个类既扮演了one的角色，又扮演了many的角色。典型的应用案例就是一个种类分层模型。

Category.hbm.xml

<hibernate-mapping>

    <class name="mypack.Category" table="CATEGORIES">

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

            <generator class="increment" />

        </id>

        <property name="name" type="string">

            <column name="NAME" length="15" />

        </property>

        <set name="childCategories" cascade="save-update" inverse="true">

            <key column="CATEGORY_ID" />

            <one-to-many class="mypack.Category" />

        </set>

        <many-to-one name="parentCategory" column="CATEGORY_ID" class="mypack.Category" />

    </class>

</hibernate-mapping>

多对多关联Many-to-many associations

多对多关联由于性能不佳，因此设计中应尽量避免使用。

单向多对多关联A unidirectional many-to-many association

双向多对多关联A bidirectional many-to-many association

使用组件集合的多对多关联Using a collection of components for a many-to-many association

所有的多对多关联都可以分解为两个一对多关联，按照这种方式映射多对多关联，会使域模型和关系数据模型具有更好的可扩展性。

Hibernate的映射类型

Java程序的数据类型往往和数据库的数据类型是不匹配的，你如何将一个JDK的Interger类型保存为数据库的VARCHAR类型呢？或者你AttachFileName类型存入数据库中去？有两种方法，一种是你将AttachFileName类型分解成为数据库中的类型，这样每次读取和写入的时候你都要做一个转换，比较麻烦。并且使得你的领域模型紧密的耦合在物理数据库模型上。

另一种方法就是，实现一个UserType，透明化的将AttachFileName保持在数据库中。

为什么需要客户化映射类型？

如何实现？

Hibernate提供两个客户友好的接口

UserType http://www.hibernate.org/hib_docs/v3/api/org/hibernate/usertype/UserType.html

实现UserType接口要实现以下几个方法

sqlType()：指定映射到数据库中的类型

returnedClass()：指定返回的Java类型

nullSafeGet()：DB->Java的转换

nullSafeSet()：Java->DB转换

assemble()：

disassemble()：

replace()：

内置映射类型

客户化映射类型

UserType：

CompositeUserType：不仅可以完成和UserType相同的功能，而且还提供了对HQL的支持。

映射值类型的集合

映射多态关联

Polymorphic many-to-one associations

Polymorphic collections

Polymorphic associations and table-per-concrete-class

   检索对象  

Hibernate检索对象的方式：

1.定位对象图方式：

根据已加载的对象，通过其属性存取方法（getter）来加载其关联的其他对象。如：

aUser.getAddress().getCity()

2.根据对象标识符来检索：

当已经知道需要加载对象的唯一标识符时，这是一个便利且高效的方法。

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

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

load()方法是比较旧的，get()

在get()和load()间作出选择是很容易的：如果你确定持久化对象存在，并且不考虑异常，load()将是好的选项。

3.HQL：

它是一个完全面向对象的查询语言。提供了最完整的查询功能。

HQL类似于OQL和EJB-QL，但是它不像OQL，HQL适合使用在数据库环境中，并且比EJB-QL功能更强大且优雅。

HQL仅用于对象的检索，而不负责插入、更新以及删除之类的工作。对象状态同步是持久化管理者的工作，而不是开发者。

Session类的find()方法及Query接口都支持HQL检索方式。这两者区别在于：前者只是执行一些简单HQL查询语句的便捷方法，不具有动态绑定参数的功能，而且在将来新的Hibernate版本中，find()有可能会被淘汰；而Query接口才是真正的HQL查询接口，它提供了完整的查询功能。

HQL

Query q = session.createQuery("from User u where u.firstname = :fname");

q.setString("fname", "Max");

List result = q.list();

4.使用Criteria API：

QBC让你可以在运行时期建立一个query，它主要由Criteria接口、Criterion接口和Expression类组成，它支持在运行时动态生成语句。

QBC：

QBC

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

criteria.add( Expression.like("firstname", "Max") );

List result = criteria.list();

QBE：

QBE

User exampleUser = new User();

exampleUser.setFirstname("Max");

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

criteria.add( Example.create(exampleUser) );

List result = criteria.list();

5.使用本地SQL查询：

HQL和Criteria检索方式生成标准的SQL查询语句，适用于所有数据库平台，因此这两种检索方式都是跨平台的。

有时你需要使用底层数据库的SQL方言，来生成一些特殊的查询。这时候你就需要使用本地SQL检索方式了。

本地SQL检索

        //创建Query对象

        Query query=session.createSQLQuery(

            "select {c.*} from CUSTOMERS c where c.NAME like :customerName"

            +"and c.AGE=:customerName","c",Customer.class);

        //动态绑定参数

        query.setString("cutomerName","T%");

        query.setInteger("cutomerAge",21);

        //执行SQL select语句，返回查询结果

        List result=query.list();

在你的Hibernate应用程序中，可以联合使用以上的检索技术。

检索策略

Hibernate允许你在关联元数据或者运行时选择以下四中检索策略之一：

1. 立即检索Immediate fetching

立即检索关联对象，连续地读取数据库（或者查找缓存）。

2. 延迟检索Lazy fetching

关联对象或者集合在它们第一次被访问的时候才被加载。

我们推荐，在一开始的时候，将所有的关联配置成延迟（或者批量延迟）检索在映射文件中。这个策略可以在运行的时候修改成为迫切检索。

在运行session.load()方法的时候，Hibernate不执行任何select语句，仅仅返回一个动态生成的代理类而已。

值得注意的是：延迟检索对get()和find()方法不管用。

3. 迫切（外连接）检索Eager (outer join) fetching

迫切检索让你可以明确地指定哪些关联对象应该和它的引用对象一起被导入。Hibernate可以利用SQL OUTER JOIN在单次数据库查询中返回关联对象，

要点：使用外连接，明确指定应该立即加载哪些对象。

优点：减少select语句的数量、可以控制哪些对象应该立即加载。

select c.ID,o.CUSTOMER,c.NAME,o.ID ORDER_ID,ORDER_NUMBER 

from CUSTOMERS c inner join ORDER o on c.ID=o.CUTOMER_ID;

4. 批量检索Batch fetching

批量检索不是严格意义上的关联检索策略。它是一项旨在提高延迟检索和立即检索性能的技术。通常，当你导入一个对象或者集合的时候，你的SQL Where字句指定对象标识符或者拥有对象的集合。如果批量检索是被允许的话，Hibernate将会查看有哪些代理实例或者未初始化集合是被当前session所引用的并且试图使用where子句中使用多重标识符值的方法来导入它们。

我们并不热衷于这种方法；因为迫切检索通常比它更快。批量检索对于那些想要提高系统性能但又不想思考太多优化SQL执行的初学者很有用。

select * from CUSTOMERS where ID=1 or ID=2 or ID=3 or ID=4;

选择一个检索策略

Hibernate允许你在映射文件中指定一个默认的关联检索策略，在query方法中你可以覆盖这默认的策略。

我们建议你首先看一下大概，当你要优化你程序的查询的时候才使用这个片段。

单点关联情况下的设置

对于一对一或者多对一关联，

outer-join有三种可能值：

outer-join="auto"

outer-join="true"

outer-join="false"

集合的设置

Neither attribute specified

outer-join="true"

lazy="true"

设置检索深度

如果select语句中的外连接表数目太多，会影响检索性能，此时可以通过在Hibernate.properties文件中设置检索深度：

hibernate.max_fetch_depth=1  #只允许外连接一张表

初始化延迟关联

有效地检索对象

执行查询

查询接口

createQuery()、createSQLQuery()和createCriteria()

分页查询

Query：

query.setFirstResult(0);   //设置

query.setMaxResults(10);

Criteria：

crit.setFirstResult(40);

crit.setMaxResults(20);

列出以及迭代结果

List result = session.createQuery("from User").list();

结果只有一个的情况：

有些情况下，我们知道结果只有一个——例如，我们想要知道最高的价格。

result.get(0) 或者setMaxResult(1).

uniqueResult()

Session.find() 比Query.list()更快吗？

find()只是提供简化的查询方法。

没有一个比另一个更快，推荐使用Query API

对象的基本查询Basic queries for objects

绑定参数Binding parameters

使用命名参数

        String queryString =

            "from Item item where item.description like :searchString";

        List result = session.createQuery(queryString)

                             .setString("searchString", searchString)

                             .list();

使用占位参数

        String queryString = "from Item item "

                + "where item.description like ? " + "and item.date > ?";

        List result = session.createQuery(queryString).setString(0,

                searchString).setDate(1, minDate).list();

使用命名查询

有时候你并不想把HQL查询语句写死到Java类中，这时你可以使用命名查询，将HQL语句写到XML文件中。

定义命名查询

<query name="findItemsByDescription"><![CDATA[

from Item item where item.description like :description

]]></query>

调用命名查询

session.getNamedQuery("findItemsByDescription")

.setString("description", description)

.list();

基本对象查询

简单查询

使用别名

多态查询

约束

比较操作

字符串匹配

逻辑操作

结果排序

连接查询

连接查询

交叉连接

inner join（内连接）

left outer join（左外连接）

right outer join（右外连接）

full join (全连接，并不常用)

报表查询

Criteria并不适合做报表查询，所有在这里我们只谈HQL

使用聚集函数

分组查询

使用having字句来限制分组

高级查询技术

检索对象性能优化

解决需要 n+1 次select的问题

事务、并发和缓存

你应该使用哪一种自动提交模式?

理解数据库事务

JDBC和JTA

JDBC事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库

分布式事务：使用JTA

JTA不仅仅应用在分布式事务中，它也用在CMT环境下。

在一个标准的单机程序或者基于web的程序中，只有jdbc事务操作是可用的。

在应用服务器中，Hibernate可以使用JTA，

Hibernate事务提供了JDBC以及JTA的抽象层。Hibernate允许扩展，所以你甚至可以插入一个CORBA事务服务适配器。

使用应用程序事务来工作

缓存理论和实践

开发实战

数据操纵

持久化的生命周期

临时对象

持久化对象

游离对象

对象标识符的范围

标识符范围的外表

实现equals() 和hashCode()

在Hibernate中使用可传递持久性

持久化的可达性

级联持久化

cascade="none"：忽略关联

cascade="save-update"：

cascade="delete"

cascade="all" 

cascade="all-delete-orphan"

cascade="delete-orphan"

管理自身关联

临时对象和游离对象的区别

Hibernate API

核心接口

Session interface

SessionFactory interface

Configuration interface

Transaction interface

Query and Criteria interfaces

Callback interfaces

扩展接口

Primary key generation (IdentifierGenerator interface)

SQL dialect support (Dialect abstract class)

Caching strategies (Cache and CacheProvider interfaces)

JDBC connection management (ConnectionProvider interface)

Transaction management (TransactionFactory, Transaction, and TransactionManagerLookup interfaces)

ORM strategies (ClassPersister interface hierarchy)

Property access strategies (PropertyAccessor interface)

Proxy creation (ProxyFactory interface)

Hibernate API使用步骤

1）获得Configuration

方法一：

Configuration cfg = new Configuration()

    .addResource("Item.hbm.xml")

    .addResource("Bid.hbm.xml");

方法二：

Configuration cfg = new Configuration()

    .addClass(org.hibernate.auction.Item.class)

    .addClass(org.hibernate.auction.Bid.class);

2）获得SessionFactory

SessionFactory sessions = cfg.buildSessionFactory();

3）获得Session

Session session = sessions.openSession(); // open a new Session

事务策略配置

有三个标准(内建)的选择:

org.hibernate.transaction.JDBCTransactionFactory

委托给数据库(JDBC)事务（默认）

org.hibernate.transaction.JTATransactionFactory

如果在上下文环境中存在运行着的事务(如, EJB会话Bean的方法), 则委托给容器管理的事务, 否则，将启动一个新的事务，并使用Bean管理的事务.

org.hibernate.transaction.CMTTransactionFactory

委托给容器管理的JTA事务

实例的状态

临时对象

持久化对象

游离对象

Hibernate开发步骤

1.定义hibernate.properties

hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect

hibernate.connection.driver_class=com.mysql.jdbc.Driver

hibernate.connection.url=jdbc:mysql://localhost:3306/SAMPLEDB

hibernate.connection.username=root

hibernate.connection.password=root

hibernate.show_sql=true

2.创建持久化类

对这个持久化类的要求：

a.通常持久化类都符合JavaBean规范，但这不是必须的。

b.对于分布式结构的Java应用，持久化类还必须实现Serialzable接口。

c.必须提供一个不带参数的默认构造器。

d.不要引入任何Hibernate API（这是建议，为了提高持久化类的独立性）

3.创建数据库Schema

4.建立映射文件

5.通过Hibernate API操纵数据库

Session常用方法

save()：临时对象持久化对象

update()：游离对象持久化对象

SaveOrUpdate()：both save() and update()

load()和get()：

delete()：

Clear()/Close()：

beginTransaction()：开始一个Hibernate编程事务

编写Hibernate应用程序

设计分层应用

在Servlet容器中使用Hibernate

在EJB容器中使用Hibernate

 

实现应用程序事务

Are application transactions really transactions?应用程序事务是真正的事务？

使用游离持久化对象

使用长会话

选择一个应用程序事务的途径

操纵特殊类型的数据

遗留schema和组合键

使用自然键来映射一个表

使用客户类型来映射遗留数据列

和触发器一起工作

审计日志

Hibernate建模方式

面向数据库建模:建模得到数据库模型schema,然后使用middlengen、hbm2java这样的工具得到hbm和类

面向对象建模:建模出类,然后通过xdoclet或者schemaupdate、hbm2dll这样的工具生成hbm以及schema.

hbm文件是支持重载的，

h3带来的annotation

E-R建模：

Middlegen

对象建模：

对象建模有两种方法，都以XDoclet为核心。

1.用Rose/Together生成类框架，附加XDoclet描述，然后通过xdoclet生成hbm文件。

2.使用andromda：将对象建模生成的模型导出为XML，然后用andromda的Hibernate转换成附带有xdoclet的POJO，同时生成hbm。

Hibernate实用工具

hbm2ddl

hbm2java

Hibernate3升级Hibernate2注意事项