亚洲精品无码永久在线观看你懂的,亚洲色图校园春色,日韩亚洲综合精品国产

hibernate 自定义数据类型映��（转）

lanxin1020 — Sun, 24 May 2009 11:57:00 GMT

UserType and CompositeUserType�?span class="hilite1">Hibernate中提供的用户�c�d��自定义接口。根据这个接口，可以实现自定义的数据�c�d��?nbsp;

最�q�看<<深入��出Hibernate>>,作者在书中介绍�?span class="hilite1">Hibernate 提供的用戯��定义数据�c�d��Q�于是效仿书中的�Ҏ��Q�在数据库表中添加一个字�D는�于记录所有好友的userid�Q�每个userid之间�?;"加以分隔�Q�同时将该字�D�|��ؓ一个特�D�的List集合�Q�利用UserType interface实现String解析后将各个userid��装在List中，��List中的记录��装成以";"分隔的String�?
使用UserType接口�Q�实��C��较好的设计风��|��以及更好的重用性�?
/*
* 用户自定义的数据�c�d��Q�对应数据库中的一个字�D�，在该字段中，保存�?
* 多个用户需要的信息�Q�之间用";"加以分隔.
* @Author:Paul
* @Date:April 18th,2008
*/
package com.globalhands.hibernate.userTypes;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.sql.Types;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;

public class SpecialList implements UserType {
private List specialList;

private static final char SPLITTER = ';';

private static final int[] TYPES = new int[] { Types.VARCHAR };

public String assemble(Serializable arg0, Object arg1)
throws HibernateException {
return null;
}

/*
* ��List��装��Z��个String对象
*/
public String assemble(List specialList) throws HibernateException {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < specialList.size() - 1; i++) {
sb.append(specialList.get(i)).append(this.SPLITTER);
}
sb.append(specialList.get(specialList.size() - 1));
return sb.toString();
}

/*
* 创徏一个新的List实例�Q�包含原有的List实例中的所有元�?
*/
public Object deepCopy(Object value) throws HibernateException {
List sourceList = (List) value;
List targetList = new ArrayList();
targetList.addAll(sourceList);
return targetList;
}

public Serializable disassemble(Object arg0) throws HibernateException {
return null;
}

/*
* 判断specialList是否发生变化
*/
public boolean equals(Object x, Object y) throws HibernateException {
if (x == y) {
return true;
}
if (x != null && y != null) {
List xList = (List) x;
List yList = (List) y;

if (xList.size() != yList.size()) {
return false;
}

for (int i = 0; i <= xList.size() - 1; i++) {
String str1 = (String) xList.get(i);
String str2 = (String) yList.get(i);
if (!xList.equals(yList)) {
return false;
}
}
return true;
}
return false;
}

public int hashCode(Object arg0) throws HibernateException {
return 0;
}

public boolean isMutable() {
return false;
}

/*
* 从resultset中取出email字段�Q��ƈ��其解析为List�c�d��后返�?
*/
public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
throws HibernateException, SQLException {
String value = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);
if (value != null) {
return parse(value);
} else {
return null;
}
}

/*
* ��以";"分隔的字�W�串解析��Z��个字�W�串数组
*/
private List parse(String value) {
String[] strs = value.split(";");
List specialList = new ArrayList();
for (int i = 0; i <= strs.length - 1; i++) {
specialList.add(strs[i]);
}
return specialList;
}

/*
* ��List型的email信息�l�装成字�W�串之后保存到email字段
*/
public void nullSafeSet(PreparedStatement st, Object value, int index)
throws HibernateException, SQLException {
if (value != null) {
String str = assemble((List) value);
Hibernate.STRING.nullSafeSet(st, str, index);
} else {
Hibernate.STRING.nullSafeSet(st, value, index);
}
}

public Object replace(Object arg0, Object arg1, Object arg2)
throws HibernateException {
return null;
}

public Class returnedClass() {
return List.class;
}

public int[] sqlTypes() {
return TYPES;
}

}
同时�Q�修改相应的[ormapping_filename].hbm.xml中相应字�D늚�映射信息
type="com.globalhands.hibernate.userTypes.SpecialList">

之后�Q�修改POJO�c�M��该字�D늚��q�回�c�d��为List�?
使用JUnit��试�E�序�?

lanxin1020 2009-05-24 19:57 发表评论

Hibernate悲观锁和乐观�?�?

lanxin1020 — Sun, 12 Apr 2009 08:12:00 GMT

Hibernate悲观锁和乐观�?/a>

�Q��{�Q?span class="hilite1">Hibernate支持两种锁机�Ӟ��
即通常所说的“悲观锁（Pessimistic Locking�Q?#8221;�?
“乐观锁（OptimisticLocking�Q?#8221;�?
悲观锁的实现�Q�往往依靠数据库提供的锁机�Ӟ��也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则�Q�即使在本系�l�中实现了加锁机�Ӟ��也无法保证外部系�l�不会修�Ҏ��据）�?
Hibernate的加锁模式有�Q?
Ø LockMode.NONE �Q?无锁机制�?
Ø LockMode.WRITE �Q?span class="hilite1">Hibernate在Insert和Update记录的时候会自动
获取�?
Ø LockMode.READ �Q?Hibernate在读取记录的时候会自动获取�?
以上�q�三�U�锁机制一般由Hibernate内部使用�Q�如Hibernate��Z��保证Update
�q�程中对象不会被外界修改�Q�会在save�Ҏ��实现中自动�ؓ目标对象加上WRITE锁�?
Ø LockMode.UPGRADE �Q�利用数据库的for update子句加锁�?
Ø LockMode. UPGRADE_NOWAIT �Q�Oracle的特定实玎ͼ�利用Oracle的for
update nowait子句实现加锁�?
乐观锁，大多是基于数据版本（Version�Q�记录机制实现。何谓数据版本？即�ؓ数据增加一个版本标识，在基于数据库表的版本解决�Ҏ��中，一般是通过为数据库表增加一�?#8220;version”字段来实现。读取出数据�Ӟ��此版本号一同读出，之后更新�Ӟ��Ҏ��版本号加一。此�Ӟ��提交数据的版本数据与数据库表对应记录的当前版本信息�q�行比对�Q�如果提交的数据版本号大于数据库表当前版本号�Q�则予以更新�Q�否则认为是�q�期数据�?
悲观锁与乐观锁的比较:
悲观锁大多数情况下依靠数据库的锁机制实现�Q�以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销�Q�特别是寚w��事务而言�Q�这��L��开销往往无法承受;
相对悲观锁而言�Q�乐观锁机制采取了更加宽杄��加锁机制。乐观锁机制往往��Z��pȝ��中的数据存储逻辑�Q�因此也具备一定的局限性，如在上例中，�׃��乐观锁机制是在我们的�pȝ��中实玎ͼ�来自外部�pȝ��的更新操作不受我们系�l�的控制�Q�因此可能会造成脏数据被更新到数据库中。在
�pȝ��设计阶段�Q�我们应该充分考虑到这些情况出现的可能性，�q�进行相应调��_��如将乐观锁策略在数据库存储过�E�中实现�Q�对外只开攑֟�于此存储�q�程的数据更新途径�Q�而不是将数据库表直接对外公开�Q��?
Hibernate 在其数据讉K��引擎中内�|�了乐观锁实现。如果不用考虑外部�pȝ��Ҏ��据库的更新操作，利用Hibernate提供的透明化乐观锁实现�Q�将大大提升我们的生产力�?
Hibernate中可以通过class描述�W�的optimistic-lock属性结合version描述�W�指定�?
optimistic-lock属性有如下可选取��|��
Ø none
无乐观锁
Ø version
通过版本机制实现乐观�?
Ø dirty
通过��查发生变动过的属性实��C��观锁
Ø all
通过��查所有属性实��C��观锁
其中通过version实现的乐观锁机制�?span class="hilite1">Hibernate官方推荐的乐观锁实现�Q�同时也�?span class="hilite1">Hibernate中，目前唯一在数据对象脱��?Session发生修改的情况下依然有效的锁机制。因此，一般情况下�Q�我们都选择version方式作�ؓHibernate乐观锁实现机制�?

lanxin1020 2009-04-12 16:12 发表评论

使用 SchemaExport 自动��

lanxin1020 — Sat, 11 Apr 2009 08:31:00 GMT

使用 SchemaExport 自动��

使用Hibernate自带的工�?em>hbm2ddl�Q�徏立根据你的对象徏立数据库:

首先建好POJO object, XML Mapping File(也可以��用工��h��据POJO class建立)�Q�配�|�文�?hibernate.cfg.xml)

Java代码

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;


public class SchemaUtil {

public static void main(String[] args) {



Configuration cfg = new Configuration().configure();
SchemaExport schemaExport= new SchemaExport(cfg);
schemaExport.create(false, true);
}
}

lanxin1020 2009-04-11 16:31 发表评论

SchemaExportTask(转自良葛�?

lanxin1020 — Sat, 11 Apr 2009 03:37:00 GMT

在您撰寫�?.hbm.xml映射文�g之後�Q�您可以使用 net.sf.hibernate.tool.hbm2ddl.SchemaExportTask來自動徏立資料��n表格�Q�這邊所使用的方式是�i�合Ant進行自動化徏構，首先我們假�a�將使用以下的User.hbm.xml�Q?

User.hbm.xml

"1.0"?>
"-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">


"onlyfun.caterpillar.User" table="USER">
"id" type="string" unsaved-value="null">
"user_id" sql-type="char(32)"/>
"uuid.hex"/>

"name" type="string" not-null="true">
"name" length="16" not-null="true"/>

"sex" type="char" />
"age" type="int"/>

　在這個映��文件中�Q?lt;column/>標籤用於指定建立表格時的一些資�a�，例如映射的表格欄位名�E�，或是sql-type�?length�{�屬性，如果不指定這些資訊時，SchemaExportTask��自動��用Hibernate的類型至SQL��型�{�資�a�來建立表格�Q�sql -type用於指定表格�Ƅ位型態�Q�not-null表示�Ƅ位不能為null�Q�length則用於指定表格文字欄位長度，這些屬性的說明�Q�都可以�?Hibernate參考手冊的�?5.1扑ֈ��?/p>

　下面的build.xml用於Ant自動化徏構時�Q�生成資料��n表格之用�Q?/p>

build.xml

"Hibernate" default="schema" basedir=".">
"source.root" value="src"/>
"class.root" value="classes"/>
"lib.dir" value="lib"/>
"data.dir" value="data"/>
"project.class.path">

"${class.root}" />

"${lib.dir}">
"*.jar"/>

"${classpath}"/>

"schema" description="Generate DB schema from the O/R mapping files">

"schemaexport"
classname="net.sf.hibernate.tool.hbm2ddl.SchemaExportTask"
classpathref="project.class.path"/>
"${source.root}/hibernate.properties"
quiet="no" text="no" drop="no" delimiter=";">
"${source.root}">
"**/*.hbm.xml"/>

　標籤定義一個新的�Q務schemaexport�Q�相關的屬性設定是�Ҏ��參考手冊的��a�定的，我們在這邊使用 hibernate.properties來告�a�SchemaExportTask盔R��的JDBC資訊�Q�quiet、text�{�屬性的定義�Q�可以看參考手冊的�?5.2�?/p>

　這個Ant建構檔案�Q�會扑ְ�src目錄下包括子目錄中有�?.hbm.xml�Q�並自動�Ҏ��映射資訊建立表格�Q�我們還必須提供hibernate.properties�Q�置於src下）來告知JDBC連接的相關訊息：

hibernate.properties

hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost/HibernateTest
hibernate.connection.username=caterpillar
hibernate.connection.password=123456

　這邊使用的是MySQL�Q�請實際�Ҏ��您所使用的資料��n�a�定dialect、驅動程式等資訊�Q�在開始運行Ant使用SchemaExportTask進行自動表格建立之前�Q�您要先建立資料庫，這邊的例子則是在MySQL中先建立HibernateTest�Q?/p>

mysql> create database HibernateTest;
Query OK, 1 row affected (0.03 sec)

　接著��可以運行Ant了，埯��i�果如下�Q?/p>

ant
Buildfile: build.xml
schema:
[schemaexport] log4j:WARN No appenders could be found for logger (net.sf.hiberna
te.cfg.Environment).
[schemaexport] log4j:WARN Please initialize the log4j system properly.
[schemaexport] drop table if exists USER;
[schemaexport] create table USER (
[schemaexport]    user_id char(32) not null,
[schemaexport]    name varchar(16) not null,
[schemaexport]    sex char(1),
[schemaexport]    age integer,
[schemaexport]    primary key (user_id)
[schemaexport] );
BUILD SUCCESSFUL
Total time: 5 seconds

　運行的過�E�中�Q�我們可以看到徏立表格的SQL語句�Q�而自動徏立好的資料��n表格資訊如下�Q?/p>

mysql> DESCRIBE user;
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| user_id | varchar(32) |      | PRI |         |       |
| name    | varchar(16) |      |     |         |       |
| sex     | char(1)     | YES  |     | NULL    |       |
| age     | int(11)     | YES  |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+
4 rows in set (0.04 sec)

更多有關SchemaExportTask的資�a�，可以看看參考手冊的�W?5章工��L��指南的部份�?/p>

lanxin1020 2009-04-11 11:37 发表评论

Hibernate延迟加蝲机制(�?

lanxin1020 — Sat, 11 Apr 2009 02:35:00 GMT

延迟加蝲�Q?
延迟加蝲机制是�ؓ了避免一些无谓的性能开销而提出来的，所谓�g�q�加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加蝲以及寚w��合的延迟加蝲�Q�另外在Hibernate3中还提供了对属性的延迟加蝲。下面我们就分别介绍�q�些�U�类的�g�q�加载的�l�节�?
A、实体对象的延迟加蝲�Q?/span>
如果惛_��实体对象使用延迟加蝲�Q�必��要在实体的映射配置文�g中进行相应的配置�Q�如下所�C�：

lazy=”true”>

   ……

通过��class的lazy属性设�|��ؓtrue�Q�来开启实体的延迟加蝲�Ҏ��。如果我们运行下面的代码�Q?
User user=(User)session.load(User.class,”1”);�Q?�Q?
System.out.println(user.getName());�Q?�Q?
当运行到(1)处时�Q�Hibernate�q�没有发起对数据的查询，如果我们此时通过一些调试工�?比如JBuilder2005的Debug工具)�Q�观察此时user对象的内存快照，我们会惊奇的发现�Q�此时返回的可能是User$EnhancerByCGLIB$$bede8986�c�d��的对象，而且其属性�ؓnull,�q�是怎么回事�Q�还记得前面我曾讲过session.load()�Ҏ��Q�会�q�回实体对象的代理类对象�Q�这里所�q�回的对象类型就是User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理�c�d��象，�q�且在代理类对象中包含目标对象的所有属性和�Ҏ��Q�而且所有属性均被赋��gؓnull。通过调试器显�C�的内存快照�Q�我们可以看出此时真正的User对象�Q�是包含在代理对象的CGLIB$CALBACK_0.target属性中�Q�当代码�q�行刎ͼ�2�Q�处�Ӟ��此时调用user.getName()�Ҏ��Q�这旉��过CGLIB赋予的回调机�Ӟ��实际上调用CGLIB$CALBACK_0.getName()�Ҏ��Q�当调用该方法时�Q�Hibernate会首先检查CGLIB$CALBACK_0.target属性是否�ؓnull�Q�如果不为空�Q�则调用目标对象的getName�Ҏ��Q�如果�ؓ�I�，则会发�v数据库查询，生成�c�M��q�样的SQL语句�Q�select * from user where id=’1’;来查询数据，�q�构造目标对象，�q�且��它赋值到CGLIB$CALBACK_0.target属性中�?
   �q�样�Q�通过一个中间代理对象，Hibernate实现了实体的延迟加蝲�Q�只有当用户真正发�v获得实体对象属性的动作�Ӟ��才真正会发�v数据库查询操作。所以实体的延迟加蝲是用通过中间代理�c�d��成的�Q�所以只有session.load()�Ҏ��才会利用实体延迟加蝲�Q�因为只有session.load()�Ҏ��才会�q�回实体�cȝ��代理�c�d��象�?
B�?nbsp;       集合�c�d��的�g�q�加载：
在Hibernate的�g�q�加载机制中�Q�针寚w��合类型的应用�Q�意义是最为重大的�Q�因��有可能��性能得到大幅度的提高�Q��ؓ此Hibernate�q�行了大量的努力�Q�其中包括对JDK Collection的独立实玎ͼ�我们在一对多兌��中，定义的用来容�U�_��联对象的Set集合�Q��ƈ不是java.util.Set�c�d��或其子类型，而是net.sf.hibernate.collection.Set�c�d��Q�通过使用自定义集合类的实玎ͼ�Hibernate实现了集合类型的延迟加蝲。�ؓ了对集合�c�d��使用延迟加蝲�Q�我们必��d��下配�|�我们的实体�cȝ��关于兌��的部分：

…..

通过��?lt;set>元素的lazy属性设�|��ؓtrue来开启集合类型的延迟加蝲�Ҏ��。我们看下面的代码：
User user=(User)session.load(User.class,”1”);
Collection addset=user.getAddresses(); (1)
Iterator it=addset.iterator(); (2)
while(it.hasNext()){
Address address=(Address)it.next();
System.out.println(address.getAddress());
}
当程序执行到(1)处时�Q�这时�ƈ不会发�v对关联数据的查询来加载关联数据，只有�q�行�?2)处时�Q�真正的数据��d��操作才会开始，�q�时Hibernate会根据缓存中�W�合条�g的数据烦引，来查扄��合条件的实体对象�?
�q�里我们引入了一个全新的概念——数据烦引，下面我们首先��接一下什么是数据索引。在Hibernate中对集合�c�d��q�行�~�存�Ӟ��是分两部分进行缓存的�Q�首先缓存集合中所有实体的id列表�Q�然后缓存实体对象，�q�些实体对象的id列表�Q�就是所谓的数据索引。当查找数据索引�Ӟ��如果没有扑ֈ�对应的数据烦引，�q�时��׃��一条select SQL的执行，获得�W�合条�g的数据，�q�构造实体对象集合和数据索引�Q�然后返回实体对象的集合�Q��ƈ且将实体对象和数据烦引纳入Hibernate的缓存之中。另一斚w��Q�如果找到对应的数据索引�Q�则从数据烦引中取出id列表�Q�然后根据id在缓存中查找对应的实体，如果扑ֈ��׃��~�存中返回，如果没有扑ֈ��Q�在发�vselect SQL查询。在�q�里我们看出了另外一个问题，�q�个问题可能会对性能产生影响�Q�这��是集合�c�d��的缓存策略。如果我们如下配�|�集合类型：

…..
lazy=”true” inverse=”true”>

�q�里我们应用�?lt;cache usage=”read-only”/>配置�Q�如果采用这�U�策略来配置集合�c�d��Q�Hibernate��只会对数据索引�q�行�~�存�Q�而不会对集合中的实体对象�q�行�~�存。如上配�|�我们运行下面的代码�Q?
User user=(User)session.load(User.class,”1”);
Collection addset=user.getAddresses();
Iterator it=addset.iterator();
while(it.hasNext()){
Address address=(Address)it.next();
System.out.println(address.getAddress());
}
System.out.println(“Second query……”);
User user2=(User)session.load(User.class,”1”);
Collection it2=user2.getAddresses();
while(it2.hasNext()){
Address address2=(Address)it2.next();
System.out.println(address2.getAddress());
}
�q�行�q�段代码�Q�会得到�c�M��下面的输出：
Select * from user where id=’1’;
Select * from address where user_id=’1’;
Tianjin
Dalian
Second query……
Select * from address where id=’1’;
Select * from address where id=’2’;
Tianjin
Dalian
我们看到�Q�当�W�二�ơ执行查询时�Q�执行了两条对address表的查询操作�Q��ؓ什么会�q�样�Q�这是因为当�W�一�ơ加载实体后�Q�根据集合类型缓存策略的配置�Q�只寚w��合数据烦引进行了�~�存�Q�而�ƈ没有寚w��合中的实体对象进行缓存，所以在�W�二�ơ再�ơ加载实体时�Q�Hibernate扑ֈ�了对应实体的数据索引�Q�但是根据数据烦引，却无法在�~�存中找到对应的实体�Q�所以Hibernate�Ҏ��扑ֈ�的数据烦引发起了两条select SQL的查询操作，�q�里造成了对性能的浪费，怎样才能避免�q�种情况呢？我们必须寚w��合类型中的实体也指定�~�存�{�略�Q�所以我们要如下寚w��合类型进行配�|�：

…..
lazy=”true” inverse=”true”>

此时Hibernate会对集合�c�d��中的实体也进行缓存，如果�Ҏ��q�个配置再次�q�行上面的代码，��会得到�c�M��如下的输出：
Select * from user where id=’1’;
Select * from address where user_id=’1’;
Tianjin
Dalian
Second query……
Tianjin
Dalian
�q�时��不会再有根据数据烦引进行查询的SQL语句�Q�因为此时可以直接从�~�存中获得集合类型中存放的实体对象�?
C�?nbsp; 属性�g�q�加载：
在Hibernate3中，引入了一�U�新的特性——属性的延迟加蝲�Q�这个机制又��取高性能查询提供了有力的工具。在前面我们讲大数据对象��d��Ӟ��在User对象中有一个resume字段�Q�该字段是一个java.sql.Clob�c�d��Q�包含了用户的简历信息，当我们加载该对象�Ӟ��我们不得不每一�ơ都要加载这个字�D�，而不论我们是否真的需要它�Q�而且�q�种大数据对象的��d��本��n会带来很大的性能开销。在Hibernate2中，我们只有通过我们前面讲过的面性能的粒度细分，来分解User�c�，来解册��个问题（请参照那一节的��Q�，但是在Hibernate3中，我们可以通过属性�g�q�加载机�Ӟ��来��我们获得只有当我们真正需要操作这个字�D�|��Q�才去读取这个字�D�|��据的能力�Q��ؓ此我们必��d��下配�|�我们的实体�c�：

……

通过�?lt;property>元素的lazy属性设�|�true来开启属性的延迟加蝲�Q�在Hibernate3中�ؓ了实现属性的延迟加蝲�Q��用了�c�d��强器来对实体�cȝ��Class文�g�q�行强化处理�Q�通过增强器的增强�Q�将CGLIB的回调机刉��辑�Q�加入实体类�Q�这里我们可以看出属性的延迟加蝲�Q�还是通过CGLIB来实现的。CGLIB是Apache的一个开源工�E�，�q�个�c�d��可以操纵java�cȝ��字节码，�Ҏ��字节码来动态构造符合要求的�c�d��象。根据上面的配置我们�q�行下面的代码：
String sql=”from User user where user.name=’zx’ ”;
Query query=session.createQuery(sql); (1)
List list=query.list();
for(int i=0;i User user=(User)list.get(i);
System.out.println(user.getName());
System.out.println(user.getResume()); (2)
}
当执行到(1)处时�Q�会生成�c�M��如下的SQL语句�Q?
Select id,age,name from user where name=’zx’;
�q�时Hibernate会检索User实体中所有非延迟加蝲属性对应的字段数据�Q�当执行�?2)处时�Q�会生成�c�M��如下的SQL语句�Q?
Select resume from user where id=’1’;
�q�时会发起对resume字段数据真正的读取操作�?

lanxin1020 2009-04-11 10:35 发表评论

lanxin1020 — Sat, 11 Apr 2009 02:24:00 GMT

1.1.1.         基本的缓存原�?
Hibernate�~�存分�ؓ二��Q�第一�U�存放于session中称��Z��U�缓存，默认带有且不能卸载�?

�W�二�U�是由sessionFactory控制的进�E��~�存。是全局�׃�n的缓存，凡是会调用二�U�缓存的查询�Ҏ�� ?

会从中受益。只有经正确的配�|�后二��~�存才会发挥作用。同时在�q�行条�g查询时必��M��用相应的�Ҏ��

才能从缓存中获取数据。比如Query.iterate()�Ҏ��、load、get�Ҏ��{�。必��L��意的是session.find�?

法永�q�是从数据库中获取数据，不会从二�U�缓存中获取数据�Q�即便其中有其所需要的数据也是如此�?

查询时��用缓存的实现�q�程为：首先查询一�U�缓存中是否��h��需要的数据�Q�如果没有，查询二��~�存�Q?

如果二��~�存中也没有�Q�此时再执行查询数据库的工作。要注意的是�Q�此3�U�方式的查询速度是依�ơ降�?

的�?

1.2.   存在的问�?
1.2.1.      一�U�缓存的问题以及使用二��~�存的原�?
     因�ؓSession的生命期往往很短�Q�存在于Session内部的第一�U�最快缓存的生命期当然也很短�Q�所�?

�W�一�U�缓存的命中率是很低的。其对系�l�性能的改善也是很有限的。当�Ӟ��q�个Session内部�~�存的主�?

作用是保持Session内部数据状态同步。�ƈ非是hibernate��Z��大幅提高�pȝ��性能所提供的�?

��Z��提高使用hibernate的性能�Q�除了常规的一些需要注意的�Ҏ��比如�Q?

使用延迟加蝲、迫切外�q�接、查询过滤等以外�Q�还需要配�|�hibernate的二�U�缓存。其对系�l�整体性能�?

改善往往��h��立竿见媄的效果！

�Q�经�q�自�׃��前作��目的经验，一般会�?~4倍的性能提高�Q?

1.2.2.      N+1�ơ查询的问题
执行条�g查询�Ӟ��iterate�Q�）�Ҏ��h��著名�?“n+1”�ơ查询的问题�Q�也��是说在�W�一�ơ查询时

iterate�Ҏ��会执行满��x��件的查询�l�果数再加一�ơ（n+1�Q�的查询。但是此问题只存在于�W�一�ơ查询时

�Q�在后面执行相同查询时性能会得到极大的改善。此�Ҏ��适合于查询数据量较大的业务数据�?

但是注意�Q�当数据量特别大�Ӟ��比如��水�U�数据等�Q�需要针�Ҏ��持久化对象配�|�其具体的缓存策略，�?

如设�|�其存在于缓存中的最大记录数、缓存存在的旉��{�参敎ͼ�以避免系�l�将大量的数据同时装载入�?

存中引�v内存资源的迅速耗尽�Q�反而降低系�l�的性能�Q�！�Q?

1.3.   使用hibernate二��~�存的其他注意事��：
1.3.1.      关于数据的有效�?
另外�Q�hibernate会自行维护二�U�缓存中的数据，以保证缓存中的数据和数据库中的真实数据的一致性！

无论何时�Q�当你调用save()、update()�?saveOrUpdate()�Ҏ��传递一个对象时�Q�或使用load()�?get()

、list()、iterate() 或scroll()�Ҏ��获得一个对象时, 该对象都��被加入到Session的内部缓存中�?

当随后flush()�Ҏ��被调用时�Q�对象的状态会和数据库取得同步�?

也就是说删除、更新、增加数据的时候，同时更新�~�存。当然这也包括二�U�缓存！

只要是调用hibernate API执行数据库相关的工作。hibernate都会��Z��自动保证 �~�存数据的有效性！�Q?

但是�Q�如果你使用了JDBC�l�过hibernate直接执行�Ҏ��据库的操作。此�Ӟ��Hibernate不会/也不可能自行

感知到数据库被进行的变化改动�Q�也��׃��能再保证�~�存中数据的有效性！�Q?

�q�也是所有的ORM产品共同��h��的问题。幸�q�的是，Hibernate为我们暴露了Cache的清除方法，�q�给我们

提供了一个手动保证数据有效性的��Z��Q�！

一�U�缓存，二��~�存都有相应的清除方法�?

其中二��~�存提供的清除方法�ؓ�Q?

按对象class清空�~�存

                按对象class和对象的主键id清空�~�存

                清空对象的集合中的缓存数据等�?



1.3.2.      适合使用的情�?
�q��所有的情况都适合于��用二�U�缓存，需要根据具体情冉|��军_��。同时可以针�Ҏ��一个持久化对象�?

�|�其具体的缓存策略�?

适合于��用二�U�缓存的情况�Q?

1、数据不会被�W�三方修改；

一般情况下�Q�会被hibernate以外修改的数据最好不要配�|�二�U�缓存，以免引�v不一致的数据。但是如�?

此数据因为性能的原因需要被�~�存�Q�同时又有可能被�W?�Ҏ��如SQL修改�Q�也可以为其配置二��~�存。只

是此旉��要在sql执行修改后手动调用cache的清除方法。以保证数据的一致�?

2、数据大��在可接收范围之内；

     如果数据表数据量特别巨大�Q�此时不适合于二�U�缓存。原因是�~�存的数据量�q�大可能会引起内存资

源紧张，反而降低性能�?

如果数据表数据量特别巨大�Q�但是经�怋�用的往往只是较新的那部分数据。此�Ӟ��也可为其配置二��~?

存。但是必��d��独配�|�其持久化类的缓存策略，比如最大缓存数、缓存过期时间等�Q�将�q�些参数降低�?

一个合理的范围�Q�太高会引�v内存资源紧张�Q�太低了�~�存的意义不大）�?

3、数据更新频率低�Q?

     对于数据更新频率�q�高的数据，频繁同步�~�存中数据的代�h可能�?查询�~�存中的数据从中获得�?

好处相当�Q�坏处益处相抉|��。此时缓存的意义也不大�?

4、非关键数据�Q�不是胦务数据等�Q?

财务数据�{�是非常重要的数据，�l�对不允许出现或使用无效的数据，所以此时�ؓ了安全�v见最好不�?

使用二��~�存�?

因�ؓ此时 “正确�?#8221;的重要性远�q�大�?“高性能”的重要性�?

2.     目前�pȝ��中��用hibernate�~�存的徏�?
1.4.   目前情况
一般系�l�中有三�U�情况会�l�开hibernate执行数据库操作：

1、多个应用系�l�同时访问一个数据库

   此种情况使用hibernate二��~�存会不可避免的造成数据不一致的问题�Q?

   此时要进行详�l�的设计。比如在设计上避免对同一数据表的同时的写入操作，

   使用数据库各�U��别的锁定机制�{��?

2、动态表相关

   所�?#8220;动态表”是指在系�l�运行时�Ҏ��用户的操作系�l�自动徏立的数据表�?

   比如“自定义表�?#8221;�{�属于用戯��定义扩展开发性质的功能模块，因�ؓ此时数据表是�q�行时徏立的�Q?

所以不能进行hibernate的映��。因此对它的操作只能是绕开hibernate的直接数据库JDBC操作�?

      如果此时动态表中的数据没有设计�~�存�Q�就不存在数据不一致的问题�?

lanxin1020 2009-04-11 10:24 发表评论

hibernate �~�存机制(�?

lanxin1020 — Sat, 11 Apr 2009 02:18:00 GMT

�~�存是介于应用程序和物理数据源之��_��其作用是��Z��降低应用�E�序对物理数据源讉K��的频�ơ，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复�Ӟ��应用�E�序在运行时从缓存读写数据，在特定的时刻或事件会同步�~�存和物理数据源的数据�?

　　�~�存的介质一般是内存�Q�所以读写速度很快。但如果�~�存中存攄��数据量非常大�Ӟ��也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，�q�要考虑到管理缓存的�q�发讉K��和缓存数据的生命周期�?

　　Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分�ؓ两类�Q�内�|�缓存和外置�~�存。Session的缓存是内置的，不能被卸载，也被�U�CؓHibernate的第一�U�缓存。SessionFactory的内�|�缓存和Session的缓存在实现方式上比较相��|��前者是SessionFactory对象的一些集合属性包含的数据�Q�后者是指Session的一些集合属性包含的数据。SessionFactory的内�|�缓存中存放了映��元数据和预定义SQL语句�Q�映��元数据是映��文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶�D�|��据映��元数据推导出来�Q�SessionFactory的内�|�缓存是只读的，应用�E�序不能修改�~�存中的映射元数据和预定义SQL语句�Q�因此SessionFactory不需要进行内�|�缓存与映射文�g的同步。SessionFactory的外�|�缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用�q�个插�g。外�|�缓存的数据是数据库数据的拷贝，外置�~�存的介质可以是内存或者硬盘。SessionFactory的外�|�缓存也被称为Hibernate的第二��~�存�?

　　Hibernate的这两��~�存都位于持久化层，存放的都是数据库数据的拷贝，那么它们之间的区别是什么呢�Q��ؓ了理解二者的区别�Q�需要深入理解持久化层的�~�存的两个特性：�~�存的范围和�~�存的�ƈ发访问策略�?

持久化层的缓存的范围

　　�~�存的范围决定了�~�存的生命周期以及可以被谁访问。缓存的范围分�ؓ三类�?

　　1 事务范围�Q�缓存只能被当前事务讉K��。缓存的生命周期依赖于事务的生命周期�Q�当事务�l�束�Ӟ��~�存也就�l�束生命周期。在此范围下�Q�缓存的介质是内存。事务可以是数据库事务或者应用事务，每个事务都有独自的缓存，�~�存内的数据通常采用�怺�兌��的的对象形式�?

　　2 �q�程范围�Q�缓存被�q�程内的所有事务共享。这些事务有可能是�ƈ发访问缓存，因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进�E�的生命周期�Q�进�E�结束时�Q�缓存也��q��束了生命周期。进�E�范围的�~�存可能会存攑֤�量的数据�Q�所以存攄��介质可以是内存或��盘。缓存内的数据既可以是相互关联的对象形式也可以是对象的松散数据�Ş式。松散的对象数据形式有点�c�M��于对象的序列化数据，但是对象分解为松散的��法比对象序列化的算法要求更快�?

　　3 集群范围�Q�在集群环境中，�~�存被一个机器或者多个机器的�q�程�׃�n。缓存中的数据被复制到集��环境中的每个进�E�节点，�q�程间通过�q�程通信来保证缓存中的数据的一致性，�~�存中的数据通常采用对象的松散数据�Ş式�?

　　对大多数应用来说�Q�应该慎重地考虑是否需要��用集��范围的�~�存�Q�因��问的速度不一定会比直接访问数据库数据的速度快多��?

　　持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，�q�可以到�q�程范围或集��范围的�~�存内查询，如果�q�是没有查到�Q�那么只有到数据库中查询。事务范围的�~�存是持久化层的�W�一�U�缓存，通常它是必需的；�q�程范围或集��范围的�~�存是持久化层的�W�二�U�缓存，通常是可选的�?

持久化层的缓存的�q�发讉K��{�略

　　当多个�ƈ发的事务同时讉K��持久化层的缓存的相同数据�Ӟ��会引起�ƈ发问题，必须采用必要的事务隔��L��施�?

　　在进�E�范围或集群范围的缓存，即第二��~�存�Q�会出现�q�发问题。因此可以设定以下四�U�类型的�q�发讉K��{�略�Q�每一�U�策略对应一�U�事务隔��ȝ�别�?

　　事务型：仅仅在受��理环境中适用。它提供了Repeatable Read事务隔离�U�别。对于经常被��M��很少修改的数据，可以采用�q�种隔离�c�d��Q�因为它可以防止脏读和不可重复读�q�类的�ƈ发问题�?

　　��d��型：提供了Read Committed事务隔离�U�别。仅仅在非集��的环境中适用。对于经常被��M��很少修改的数据，可以采用�q�种隔离�c�d��Q�因为它可以防止脏读�q�类的�ƈ发问题�?

　　非严��D��写型�Q�不保证�~�存与数据库中数据的一致性。如果存在两个事务同时访问缓存中相同数据的可能，必须��数据配置一个很短的数据�q�期旉��Q�从而尽量避免脏诅R��对于极��被修改�Q��ƈ且允许偶��脏�ȝ��数据�Q�可以采用这�U��ƈ发访问策略�?

　　只读型：对于从来不会修改的数据，如参考数据，可以使用�q�种�q�发讉K��{�略�?

　　事务型�ƈ发访问策略是事务隔离�U�别最高，只读型的隔离�U�别最低。事务隔��ȝ�别越高，�q�发性能��p��低�?

lanxin1020 2009-04-11 10:18 发表评论

Hibernate 体系�l�构与工作原�?�?

lanxin1020 — Thu, 09 Apr 2009 15:54:00 GMT

1.Hibernate 的初始化.
��d��Hibernate 的配�|�信�?〉创建Session Factory
1)创徏Configeration�cȝ��实例�?br /> 它的构造方法：��配�|�信�?Hibernate config.xml)��d��到内存�?br /> 一个Configeration 实例代表Hibernate 所有Java�c�d��Sql数据库映��的集合�?br /> 2)创徏SessionFactory实例
把Configeration 对象中的所有配�|�信息拷贝到SessionFactory的缓存中�?br /> SessionFactory的实例代表一个数据库存储员源�Q�创建后不再与Configeration 对象兌��?br /> �~�存(cache):指Java对象的属�?通常是一些集合类型的属性－�Q�占用内存空间�?br />      SessionFactory的缓存中�Q�Hibernate 配置信息。OR映射元数据�?br /> �~�存�Q�大�Q�重量��对象 ��：轻量�U�对�?br /> 3)调用SessionFactory创徏Session的方�?br /> 1】用戯��行提供JDBC�q�接�?br />    Connection con=dataSource.getConnection();
   Session s=sessionFactory.openSession(con);
2】让SessionFactory提供�q�接
   Session s=sessionFactory.openSession();
4)通过Session 接口提供的各�U�方法来操纵数据库访问�?

Hibernate 的缓存体�p?br /> 一�U�缓存：
Session 有一个内�|�的�~�存�Q�其中存放了被当前工作单元加载的对象�?br /> 每个Session 都有自己独立的缓存，且只能被当前工作单元讉K��?br /> 二��~�存�Q?br /> SessionFactory的外�|�的可插拔的�~�存插�g。其中的数据可被多个Session�׃�n讉K��?br /> SessionFactory的内�|�缓存：存放了映��元数据�Q�预定义的Sql语句�?/p>

Hibernate 中Java对象的状�?br /> 1.临时状�?(transient)
特征�Q?br /> 1】不处于Session �~�存�?br /> 2】数据库中没有对象记�?br /> Java如何�q�入临时状�?br /> 1】通过new语句刚创��Z��个对象时
2】当调用Session 的delete()�Ҏ��Q�从Session �~�存中删除一个对象时�?/p>

2.持久化状�?persisted)
特征�Q?br />    1】处于Session �~�存�?br />    2】持久化对象数据库中设有对象记录
   3】Session 在特定时��M��保持二者同�?br /> Java如何�q�入持久化状�?br />    1】Session 的save()把��Ӟ��》持久化状�?br />    2】Session 的load(),get()�Ҏ��q�回的对�?br />    3】Session 的find()�q�回的list集合中存攄��对象
   4】Session 的update(),saveOrupdate()使游��－》持久化
3.游离状�?detached)
特征�Q?br />    1】不再位于Session �~�存�?br />    2】游��d��象由持久化状态�{变而来�Q�数据库中可能还有对应记录�?br /> Java如何�q�入持久化状态－》游��ȝ��?br />    1】Session 的close()�Ҏ��
   2】Session 的evict()�Ҏ��Q�从�~�存中删除一个对象。提高性能。少用�?/p>

lanxin1020 2009-04-09 23:54 发表评论

Hibernate 的原理与配置(�?

lanxin1020 — Thu, 09 Apr 2009 15:50:00 GMT

也许你听说过Hibernate的大名，但可能一直不了解它，也许你一直��望��用它�q�行开发，那么本文正是你所需要的�Q�在本文中，我向大家重点介绍Hibernate的核心API调用库，�q�讲解一下它的基本配�|��?

　　看完本文后，我相信你对什么是ORM�Q�对�?关系映射�Q�以及它的优点会有一个深�ȝ��认识�Q�我们先通过一个简单的例子开始来展现它的威力�?

　　正如一些传�l�的�l�典计算机文章大都会通过一�?#8220;hello,world”的例子开始讲解一��P��我们也不例外�Q�我们也��从一个相对简单的例子来阐�q�Hibernate的开发方法，但如果要真正阐述Hibernate的一些重要思想�Q�仅仅靠在屏�q�上打印一些字�W�是�q�远不够的，在我们的�C�Z��E�序中，我们��创��Z��些对象，�q�将其保存在数据库中�Q�然后对它们�q�行更新和查询�?

　　阅读��D��

　　“Hello World”“Hello world”�C�Z��E�序让您对Hibernate有一个简单的认识�?
　　理解Hibernate的架构介�l�Hibernate接口的主要功能�?
　　核心接口Hibernate�?个核心接口，通过�q�几个接口开发�h员可以存储和获得持久对象�Q��ƈ且能够进行事务控�?
　　一个重要的术语�Q�TypeType是Hibernate发明者发明的一个术语，它在整个构架中是一个非常基��、有着强大功能的元素，一个Type对象能将一个Java�c�d��映射到数据库中一个表的字�D�中厅R�?
　　�{�略接口Hibernate与某些其它开源��Y件不同的�q�有一点――高度的可扩展性，�q�通过它的内置�{�略机制来实现�?
　　基础配置Hibernate可以配置成可在�Q何Java环境中运行，一般说来，它通常被用�?�Q?层的C/S模式的项目中�Q��ƈ被部�|�在服务端�?
　　创徏一个SessionFactory对象要创��Z��个SessionFactory对象�Q�必��d��Hibernate初始化时创徏一个Configuration�cȝ��实例�Q��ƈ��已写好的映��文件交由它处理�?

　　“Hello World”

　　Hibernate应用�E�序定义了一些持久类�Q��ƈ且定义了�q�些�c�M��数据库表格的映射关系。在我们�q�个“Hello world”�C�Z��E�序中包含了一个类和一个映��文件。让我们看看�q�个��单的持久�c�d��含有一些什么？映射文�g是怎样定义的？另外�Q�我们该怎样用Hibernate来操作这个持久类�?

　　我们�q�个��单示例程序的目的是将一些持久类存储在数据库中，然后从数据库取出来，�q�将其信息正文显�C�给用户。其中Message正是一个简单的持久�c�：�Q�它包含我们要显�C�的信息�Q�其源代码如下：

　　列表1　Message.Java　一个简单的持久�c?

　　package hello;
　　public class Message {
　　private Long id;
　　private String text;
　　private Message nextMessage;
　　private Message() {}
　　public Message(String text) {
　　this.text = text;
　　}
　　public Long getId() {
　　return id;
　　}
　　private void setId(Long id) {
　　this.id = id;
　　}
　　public String getText() {
　　return text;
　　}
　　public void setText(String text) {
　　this.text = text;
　　}
　　public Message getNextMessage() {
　　return nextMessage;
　　}
　　public void setNextMessage(Message nextMessage) {
　　this.nextMessage = nextMessage;
　　}
　　}

　　Message�c�L��三个属性：Message的id 、消息正文、以及一个指向下一条消息的指针。其中id属性让我们的应用程序能够唯一的识别这条消息，通常它等同于数据库中的主键，如果多个Message�cȝ��实例对象拥有相同的id�Q�那它们代表数据库某个表的同一个记录。在�q�里我们选择了长整型作�ؓ我们的id��|��但这不是必需的。Hibernate允许我们使用��L��的类型来作�ؓ对象的id��|��在后面我们会�Ҏ��作详�l�描�q��?

　　你可能注意到Message�cȝ��代码�c�M��于JavaBean的代码风��|��q�且它有一个没有参数的构造函敎ͼ�在我们以后的代码中我��l��用这�U�风格来�~�写持久�cȝ��代码�?

　　Hibernate会自动管理Message�cȝ��实例�Q��ƈ通过内部机制使其持久化，但实际上Message对象�q�没有实��C�Q何关于Hibernate的类或接口，因此我们也可以将它作��Z��个普通的Java�c�L��使用�Q?

　　Message message = new Message("Hello World");
　　System.out.println( message.getText() );

　　以上�q�段代码正是我们所期望的结果：它打�?#8220;hello world”到屏�q�上。但�q��ƈ不是我们的最�l�目标；实际上Hibernate与诸如EJB容器�q�样的环境在持久层实现的方式上有很大的不同。我们的持久�c?Message�c?可以用在与容器无关的环境中，不像EJB必须要有EJB容器才能执行。�ؓ了能更清楚地表现�q�点�Q�以下代码将我们的一个新消息保存到数据库中去�Q?

　　Session session = getSessionFactory().openSession();
　　Transaction tx = session.beginTransaction();
　　Message message = new Message("Hello World");
　　session.save(message);
　　tx.commit();
　　session.close();

　　以上�q�段代码调用了Hibernate的Session和Transaction接口�Q�关于getSessionFactory()�Ҏ��我们��会马上提到�Q�。它相当于我们执行了以下SQL语句�Q?

　　insert into MESSAGES (MESSAGE_ID, MESSAGE_TEXT, NEXT_MESSAGE_ID)
　　values (1, 'Hello World', null)

　　在以上的SQL语句中，MESSAGE_ID字段到底被初始化成了什么值呢�Q�由于我们�ƈ没有在先前的代码中�ؓmessage对象的id属性赋与初始��|��那它是否为null呢？实际上Hibernate对id属性作了特�D�处理：�׃��它是一个对象的唯一标识�Q�因此当我们�q�行save()调用�Ӟ��Hibernate会�ؓ它自动赋予一个唯一的��|��我们��在后面内容中讲�q�它是如何生成这个值的�Q��?

　　我们假设你已�l�在数据库中创徏了一个名为MESSAGE的表�Q�那么既然前面这�D�代码让我们��Message对象存入了数据库中，那么现在我们��p��它们一一取出来。下面这�D�代码将按照字母��序�Q�将数据库中的所有Message对象取出来，�q�将它们的消息正文打印到屏幕上：

　　Session newSession = getSessionFactory().openSession();
　　Transaction newTransaction = newSession.beginTransaction();
　　List messages =newSession.find("from Message as m order by m.text asc");
　　System.out.println( messages.size() + " message(s) found:" );
　　for ( Iterator iter = messages.iterator(); iter.hasNext(); ) {
　　Message message = (Message) iter.next();
　　System.out.println( message.getText() );
　　}
　　newTransaction.commit();
　　newSession.close();

　　在以上这�D�代码中�Q�你可能被find()�Ҏ��的这个参数困扰着�Q?from Message as m order by m.text asc"�Q�其实它是Hibernate自己定义的查询语�a��Q�全�U�叫Hibernate Query Language(HQL)。通俗地讲HQL与SQL的关�p�d��不多��是方言与普通话之间的关�p�，咋一看，你会觉得它有点类��g��SQL语句。其实在find()调用�Ӟ��Hibernate会将�q�段HQL语言��译成如下的SQL语句�Q?

　　select m.MESSAGE_ID, m.MESSAGE_TEXT, m.NEXT_MESSAGE_ID
　　from MESSAGES m
　　order by m.MESSAGE_TEXT asc

　　以下��是�q�行�l�果�Q?

　　1 message(s) found:
　　Hello World

　　如果你以前没有ORM�Q�对象－关系映射�Q�的开发经验，那你可能惛_��代码的某个地方去��L��q�段SQL语句�Q�但在Hibernate中你可能会失望：它根本不存在�Q�所有就SQL语句都是Hibernate动态生成的�?

　　也许你会觉得�q�缺点什么，对！仅凭以上代码Hibernate是无法将我们的Message�c�L��久化的。我们还需要一些更多的信息�Q�这��是映射定义表！�q�个表在Hibernate中是以XML格式来体现的�Q�它定义了Message�cȝ��属性是怎样与数据库中的MESSAGES表的字段�q�行一一对应的，列表2是这个示例程序的映射配置文�g清单�Q?

　　列表2�Q�示例程序的对象�Q�关�p�L��表

　　�Q?xml version="1.0"?�Q?
　　�Q?DOCTYPE hibernate-mapping PUBLIC
　　"-//Hibernate/Hibernate Mapping DTD//EN"
　　"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"�Q?
　　�Q�hibernate-mapping�Q?
　　�Q�class name="hello.Message" table="MESSAGES"�Q?
　　�Q�id name="id" column="MESSAGE_ID"�Q?
　　�Q�generator class="increment"/�Q?
　　�Q?id�Q?
　　�Q�property name="text" column="MESSAGE_TEXT"/�Q?
　　�Q�many-to-one name="nextMessage" cascade="all" column="NEXT_MESSAGE_ID"/�Q?
　　�Q?class�Q?
　　�Q?hibernate-mapping�Q?

　　以上�q�个文档告诉Hibernate怎样��Message�c�L��到MESSAGES表中�Q�其中Message�cȝ��id属性与表的MESSAGE_ID字段对应�Q�text属性与表的MESSAGE_TEXT字段对应�Q�nextMessage属性是一个多对一的关�p�，它与表中的NEXT_MESSAGE_ID相对应�?

　　相对于有些开源项目来��_��Hibernate的配�|�文件其实是很容易理解的。你可以��L��C��改与�l�护它。只要你定义好了持久�c�M��数据库中表字�D늚�对应关系��p��了，Hibernate会自动帮你生成SQL语句来对Message对象�q�行插入、更新、删除、查扑ַ�作，你可以不写一句SQL语句�Q�甚至不需要懂得SQL语言�Q?

　　现在让我们做一个新的试验，我们先取出第一个Message对象�Q�然后修改它的消息正文，最后我们再生成一个新的Message对象�Q��ƈ��它作�ؓ�W�一个Message对象的下一条消息，其代码如下：

　　列表3　更新一条消�?

　　Session session = getSessionFactory().openSession();
　　Transaction tx = session.beginTransaction();
　　// 1 is the generated id of the first message
　　Message message =(Message) session.load( Message.class, new Long(1) );
　　message.setText("Greetings Earthling");
　　Message nextMessage = new Message("Take me to your leader (please)");
　　message.setNextMessage( nextMessage );
　　tx.commit();
　　session.close();

　　以上�q�段代码在调用时�Q�Hibernate内部自动生成如下的SQL语句�Q?

　　select m.MESSAGE_ID, m.MESSAGE_TEXT, m.NEXT_MESSAGE_ID
　　from MESSAGES m
　　where m.MESSAGE_ID = 1

　　insert into MESSAGES (MESSAGE_ID, MESSAGE_TEXT, NEXT_MESSAGE_ID)
　　values (2, 'Take me to your leader (please)', null)

　　update MESSAGES
　　set MESSAGE_TEXT = 'Greetings Earthling', NEXT_MESSAGE_ID = 2
　　where MESSAGE_ID = 1

　　当第一个Message对象的text属性和nextMessage被程序修�Ҏ��Q�请注意Hibernate是如何检��到�q�种变化�Q��ƈ如何在数据库中自动对它更新的。这实际上是Hibernate的一个很有�h值的特色�Q�我们把它称�?#8220;自动脏数据检��?#8221;�Q�Hibernate的这个特色��得当我们修改一个持久对象的属性后�Q�不必显式地通知Hibernate��d��它在数据库中�q�行更新。同��L��Q�当�W�一个Message对象调用setNextMessage()�Ҏ��第二个Message对象作�ؓ它的下一条消息的引用�Ӟ��W�二条消息会无需调用save()�Ҏ��Q�便可以自动��C��存在数据库中。这�U�特色被�U�Cؓ“�U�联保存”�Q�它也免��M��我们昑ּ�地对�W�二个Message对象调用save()�Ҏ��之苦�?

　　如果我们再运行先前的那段��数据库中所有的Message对象都打印出来的代码�Q�那它的�q�行�l�果如下�Q?

　　2 message(s) found:
　　Greetings Earthling
　　Take me to your leader (please)

　　“Hello world”�C�Z��E�序现在介绍完毕。我们�ȝ��对Hibernate有了一个简单的认识�Q�下面我们将回过头来�Q�对Hibernate的主要API调用作一下简要的介绍�Q?
　　

　　理解Hibernate的架�?/strong>

　　当你想用Hibernate开发自��q��Z��持久层的应用�Ӟ��W�一件事情应当是熟悉它的�~�程接口。Hibernate的API接口设计得尽量简�z�明了，以方便开发�h员。然而实际上�׃��ORM的复杂性，它的API一般都不可能设计得很简单。但是别担心�Q�你没有必要一下子了解所有的Hibernate的API接口�?br />
　　我们��应用层攑֜�了持久层的上部，实际上在传统的项目中�Q�应用层充当着持久层的一个客��L��角色。但对于一些简单的��目来说�Q�应用层和持久层�q�没有区分得那么清楚�Q�这也没什么，在这�U�情况下你可以将应用层和持久层合�q�成了一层�?

　　Hibernate的接口大致可以分��Z��下几�U�类型：

　　· 一些被用户的应用程序调用的�Q�用来完成基本的创徏、读取、更新、删除操作以及查询操作的接口。这些接口是Hibernate实现用户�E�序的商业逻辑的主要接口，它们包括Session、Transaction和Query�?

　　· Hibernate用来��d��诸如映射表这�c�配�|�文件的接口�Q�典型的代表有Configuration�c�R�?

　　· 回调(Callback)接口。它允许应用�E�序能对一些事件的发生作出相应的操作，例如Interceptor、Lifecycle和Validatable都是�q�一�c�L��口�?

　　· 一些可以用来扩展Hibernate的映��机制的接口�Q�例如UserType、CompositeUserType和IdentifierGenerator。这些接口可��q��L��序来实现�Q�如果有必要�Q��?

　　Hibernate使用了J2EE架构中的如下技术：JDBC、JTA、JNDI。其中JDBC是一个支持关�p�L��据库操作的一个基��层；它与JNDI和JTA一��L��合，使得Hibernate可以方便地集成到J2EE应用服务器中厅R�?

　　在这里，我们不会详细地去讨论Hibernate API接口中的所有方法，我们只简要讲一下每个主要接口的功能�Q�如果你想了解得更多的话�Q�你可以在Hibernate的源码包中的net.sf.hibernate子包中去查看�q�些接口的源代码。下面我们依�ơ讲一下所有的主要接口�Q?

　　核心接口

　　以下5个核心接口几乎在��M��实际开发中都会用到。通过�q�些接口�Q�你不仅可以存储和获得持久对象，�q�且能够�q�行事务控制�?

　　Session接口

　　Session接口对于Hibernate 开发�h员来说是一个最重要的接口。然而在Hibernate中，实例化的Session是一个轻量��的类�Q�创建和销毁它都不会占用很多资源。这在实际项目中��实很重要，因�ؓ在客��L��序中�Q�可能会不断地创��Z��及销毁Session对象�Q�如果Session的开销太大�Q�会�l�系�l�带来不良媄响。但值得注意的是Session对象是非�U�程安全的，因此在你的设计中�Q�最好是一个线�E�只创徏一个Session对象�?

　　在Hibernate的设计者的头脑中，他们��session看作介于数据�q�接与事务管理一�U�中间接口。我们可以将session惌��成一个持久对象的�~�冲区，Hibernate能检��到�q�些持久对象的改变，�q�及时刷新数据库。我们有时也�U�Session是一个持久层��理器，因�ؓ它包含这一些持久层相关的操作，诸如存储持久对象��x��据库�Q�以及从数据库从获得它们。请注意�Q�Hibernate 的session不同于JSP应用中的HttpSession。当我们使用session�q�个术语�Ӟ��我们指的是Hibernate中的session�Q�而我们以后会��HttpSesion对象�U�Cؓ用户session�?

　　SessionFactory 接口

　　�q�里用到了一个设计模式――工厂模式，用户�E�序从工厂类SessionFactory中取得Session的实例�?

　　令你感到奇怪的是SessionFactory�q�不是轻量��的！实际上它的设计者的意图是让它能在整个应用中�׃�n。典型地来说�Q�一个项目通常只需要一个SessionFactory��够了，但是当你的项目要操作多个数据库时�Q�那你必��Mؓ每个数据库指定一个SessionFactory�?
　　SessionFactory在Hibernate中实际�v��C��一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据�Q�还�~�冲了一些将来有可能重复利用的数据�?

　　Configuration 接口

　　Configuration接口的作用是对Hibernate�q�行配置�Q�以及对它进行启动。在Hibernate的启动过�E�中�Q�Configuration�cȝ��实例首先定位映射文档的位�|�，��d��q�些配置�Q�然后创��Z��个SessionFactory对象�?

　　虽然Configuration接口在整个Hibernate��目中只扮演着一个很��的角色�Q�但它是启动hibernate时你所遇到的每一个对象�?

　　Transaction 接口

　　Transaction接口是一个可选的API�Q�你可以选择不��用这个接口，取而代之的是Hibernate的设计者自己写的底层事务处理代码�?Transaction接口是对实际事务实现的一个抽象，�q�些实现包括JDBC的事务、JTA中的UserTransaction、甚臛_��以是CORBA事务。之所以这栯��计是能让开发者能够��用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移倹{�?

　　Query和Criteria接口

　　Query接口让你方便地对数据库及持久对象�q�行查询�Q�它可以有两�U�表达方式：HQL语言或本地数据库的SQL语句。Query�l�常被用来绑定查询参数、限制查询记录数量，�q�最�l�执行查询操作�?

　　Criteria接口与Query接口非常�c�M��Q�它允许你创建�ƈ执行面向对象的标准化查询�?

　　值得注意的是Query接口也是轻量�U�的�Q�它不能在Session之外使用�?

　　Callback 接口

　　当一些有用的事�g发生时――例如持久对象的载入、存储、删除时�Q�Callback接口会通知Hibernate��L��收一个通知消息。一般而言�Q�Callback接口在用��L��序中�q�不是必��ȝ��Q�但你要在你的项目中创徏审计日志�Ӟ��你可能会用到它�?

　　 一个重要的术语�Q�Type

　　Hibernate的设计者们发明了一个术语：Type�Q�它在整个构架中是一个非常基��、有着强大功能的元素。一个Type对象能将一个Java�c�d��映射到数据库中一个表的字�D�中去（实际上，它可以映��到表的多个字段中去�Q�。持久类的所有属性都对应一个type。这�U�设计思想使用Hibernate有着高度的灵�z�L��和扩展性�?

　　Hibernate内置很多type�c�d��Q�几乎包括所有的Java基本�c�d��Q�例如Java.util.Currency、Java.util.calendar、byte[]和Java.io.Serializable�?

　　不仅如此�Q�Hibernate�q�支持用戯��定义的type�Q�通过实现接口UserType和接口CompositeUserType�Q�你可以加入自己的type。你可以利用�q�种特色让你的项目中使用自定义的诸如Address、Name�q�样的type�Q�这样你��可以获得更大的便利�Q�让你的代码更优雅。自定义type在Hibernate中是一��Ҏ��心特�Ԍ��它的设计者鼓�׃��多多使用它来创徏一个灵�z�R��优雅的��目�Q?

　　�{�略接口

　　Hibernate与某些其它开源��Y件不同的�q�有一点――高度的可扩展性，�q�通过它的内置�{�略机制来实现。当你感觉到Hibernate的某些功能不��I��或者有某些�~�陷�Ӟ��你可以开发一个自��q��{�略来替换它�Q�而你所要做的仅仅只是��承它的某个策略接口，然后实现你的新策略就可以了，以下是它的策略接口：

　　· 主键的生�?(IdentifierGenerator 接口)

　　· 本地SQL语言支持 (Dialect 抽象�c?

　　· �~�冲机制 (Cache 和CacheProvider 接口)

　　· JDBC �q�接��理 (ConnectionProvider接口)

　　· 事务��理 (TransactionFactory, Transaction, �?TransactionManagerLookup 接口)

　　· ORM �{�略 (ClassPersister 接口)

　　· 属性访问策�?(PropertyAccessor 接口)

　　· 代理对象的创�?(ProxyFactory接口)

　　Hibernate��Z��上所列的机制分别创徏了一个缺省的实现�Q�因此如果你只是要增强它的某个策略的功能的话�Q�只需��单地�l�承�q�个�c�d��可以了，没有必要从头开始写代码�?

　　以上��是Hibernate的一些核心接口，但当我们真正开始用它进行开发时�Q�你的脑��里可能��M��有一个疑问：我是通过什么方式，�q�从哪里取得Session的呢�Q�以下我们就解答�q�个问题�?

　　基础配置

　　现在回顾一下我们先前的内容�Q�我们写��Z��一个示例程序，�q�简要地讲解了Hibernate的一些核心类。但要真正��你的��目�q�行��h��Q�还有一件事必须要做�Q�配�|�。Hibernate可以配置成可在�Q何Java环境中运行，一般说来，它通常被用�?�Q?层的C/S模式的项目中�Q��ƈ被部�|�在服务端。在�q�种��目中，Web��览器、或Java GUI�E�序充当者客��L��。尽��我们的焦点主要是集中在多层web应用�Q�但实际上在一些基于命令行的应用中也可以��用Hibernate。�ƈ且，对Hibernate的配�|�在不同的环境下都会不同�Q�Hibernate�q�行在两�U�环境下�Q�可��理环境和不可管理环�?

　　· 可管理环境――这�U�环境可��理如下资源�Q�池资源��理�Q�诸如数据库�q�接池和�Q�还有事务管理、安全定义。一些典型的J2EE服务器（JBoss、Weblogic、WebSphere�Q�已�l�实��C��q�些�?

　　· 不可��理环境――只是提供了一些基本的功能�Q�诸如像Jetty或Tomcat�q�样的servlet容器环境。一个普通的Java桌面应用或命令行�E�序也可以认为是处于�q�种环境下。这�U�环境不能提供自动事务处理、资源管理或安全��理�Q�这些都必须由应用程序自己来定义�?

　　Hibernate的设计者们��这两种环境设计了一个统一的抽象界面，因此对于开发者来说只有一�U�环境：可管理环境。如果实际项目是建立在诸如Tomcat�q�类不可��理的环境中�Ӟ��那Hibernate��会使用它自��q��事务处理代码和JDBC�q�接池，使其变�ؓ一个可��理环境�?
　　对于可管理的环境而言�Q�Hibernate会将自己集成在这�U�环境中。对于开发者而言�Q�你所要做的工作非常简单：只需从一个Configuration�c�M��创徏一个SessionFactory�c�d��可以了�?
　　创徏一个SessionFactory对象

　　��Z��能创��Z��个SessionFactory对象�Q�你必须在Hibernate初始化时创徏一个Configuration�cȝ��实例�Q��ƈ��已写好的映��文件交由它处理。这��P��Configuration对象��可以创��Z��个SessionFactory对象�Q�当SessionFactory对象创徏成功后，Configuration对象��没有用了，你可以简单地抛弃它。如下是�C�Z��代码�Q?

　　Configuration cfg = new Configuration();
　　cfg.addResource("hello/Message.hbm.xml");
　　cfg.setProperties( System.getProperties() );
　　SessionFactory sessions = cfg.buildSessionFactory();

　　在以上代码中�Q�Message.hb.xml�q�个映射文�g的位�|�比较特�D�，它与当前的classpath相关。例如classpath包含当前目录�Q�那在上�q�C��码中的Message.hbm.xml映射文�g��可以保存在当前目录下的hello目录中�?

　　作�ؓ一�U�约定，Hibernate的映��文仉��认以.htm.xml作�ؓ其扩展名。另一个约定是坚持为每一个持久类写一个配�|�文�Ӟ��想一惛_��果你��所有持久类的映��写入一个单独的配置文�g中的话，那这个配�|�文件肯定非常庞大，不易�l�护。但�q�里又出��C��一个新问题�Q�如果�ؓ每个�c�d��一个配�|�文件的话，�q�么多的配置文�g应该存放在哪里呢�Q?

　　Hibernate推荐你将每个映射文�g保存在与持久�cȝ��同的目录下，�q�且与持久类同名。例如我们第一个示例程序中的Message持久�c�L��在hello目录下，那你必须在这个目录下存放名�ؓMessage.hbm.xml的映��文件。这样一个持久类都有自己的一个映��文�Ӟ��避免了出现像struts��目中的“struts-config.xml地狱”的情��c��如果你不遵循这�U�规定，那你必须手动地用addResource()�Ҏ��一个个的映��文件蝲入；但你如果遵��@�q�种规定�Q�那你可以方便地用addClass()�Ҏ��同时��持久类和它的映��文件蝲入，以下是体现这�U�便利性的�C�Z��代码�Q?

　　SessionFactory sessions = new Configuration()
　　.addClass(org.hibernate.auction.model.Item.class)
　　.addClass(org.hibernate.auction.model.Category.class)
　　.addClass(org.hibernate.auction.model.Bid.class)
　　.setProperties( System.getProperties() )
　　.buildSessionFactory();

　　当然�Q�Hibernate的映��文件还有很多其它的配置选项�Q�比如数据库�q�接的设定，或是能够改变Hibernate�q�行时行为的一些设定。所有的讄��可能是非常庞杂的�Q��以让你喘不过气来�Q�但是不必担心，因�ؓHibernate为绝大多数值都讑֮�了一个合理缺省��|��你只需要修改这些配�|�文件中的极��一部分倹{�?

　　你可以通过以下几种方式来修改Hibernate的系�l�配�|�参敎ͼ�

　　· ��一个Java.util.Properties实例作�ؓ参数传给Configuration�cȝ��setProperties()�Ҏ��?

　　· 在Hibernate启动时用Java –Dproperty=value的方式设�|�倹{�?

　　· 在classpath可以扑ֈ�的�\径下创徏一个名为hibernate.properties的配�|�文件�?

　　· 在classpath可以扑ֈ�的�\径下创徏一个名为hibernate.cfg.xml的文�Ӟ��q�在�Ӟ��property�Q�标�{�中定义属性倹{�?

　　以上��是对Hibernate的一个大致介�l�，如果你想知道得更多，那本文还是远�q�不够的�Q�我��陆�l�推出更多关于Hibernate的资料。但有一�Ҏ��毫无疑问的：它的��是一个非�怼��U�的持久层解决�Ҏ��Q?/p>

lanxin1020 2009-04-09 23:50 发表评论

Hibernate实体对象的生命周期（转）

lanxin1020 — Wed, 08 Apr 2009 04:02:00 GMT

Hibernate实体对象的生命周�?/a>
关键�? hibernate学习�W�记
在用Hibernate的时候，时不时会因�ؓ没有处理好实体对象的状态而犯一些莫名其妙的异常�Q�在�q�里对实体对象的各种状态整理一下，希望能有所帮助�?

Hibernate实体对象�Q�即指Hibernate O/R影射关系中的域对�?即O/R中的"O"。在Hibrenate实体对象的生命周期中存在着三中状态，卻I��
1�Q�自��q��态（Transient�Q��?
2�Q�持久状态（Persistent�Q��?
3�Q�游��ȝ��态（Detached�Q��?

1�Q�自��q��态（Transient�Q?/strong>
自由状态（Transient�Q?/span>,是指实体对象在内存中自由存在�Q�他与数据库的记录无兟뀂如�Q?

Java代码

TUser user = new TUser();
user.setName("MyName");

TUser user = new TUser(); user.setName("MyName");

�q�里的user对象只是一个非常普通的java对象�Q�与数据库中的记录没有�Q何关�p�R�?

2�Q�持久状态（Persistent�Q?/strong>
持久状态（Persistent�Q?/span>,卛_��体对象处于Hibernate框架的管理状态，实体对象被纳入Hibernate的实体容器中��理。处�?span style="color: brown">持久状�?/span>的对象，其更变将由Hibernate固化到数据库中。如�Q?

Java代码

//创徏两个处于自由状态的实体对象�?
TUser user_1 = new TUser();
TUser user_2 = new TUser();

user_1.setName("Name_1");
user_2.setName("Name_2");

Transaction tx = session.begintransaction();
session.save(user_1);
//通过session的save�Ҏ��Q�user_1对象已经被纳入Hibernate的实体管理容器，处于持久化状
//�?Persistent)�Q�这时候对user_1对象的�Q何修攚w��被同步到数据库中�?

tx.commit();

//而user_2仍然才处于自��q��态（Transient�Q�，不受Hibernate框架的管理�?/span>

//创徏两个处于自由状态的实体对象�? TUser user_1 = new TUser(); TUser user_2 = new TUser(); user_1.setName("Name_1"); user_2.setName("Name_2"); Transaction tx = session.begintransaction(); session.save(user_1); //通过session的save�Ҏ��Q�user_1对象已经被纳入Hibernate的实体管理容器，处于持久化状 //�?Persistent)�Q�这时候对user_1对象的�Q何修攚w��被同步到数据库中�? tx.commit(); //而user_2仍然才处于自��q��态（Transient�Q�，不受Hibernate框架的管理�?

从上面看刎ͼ�处于自由状�?/span>的实体对象，可以通过Hibernate的Session.sava�Ҏ��转化�?span style="color: brown">持久状�?/span>�?
除了用Session.save�Ҏ��外，�q�可以通过其他�Ҏ��来获取一�?span style="color: brown">持久状�?/span>的对象，那就是直接通过Hibernate加蝲的对象，通过Session.load�Ҏ��Q�可以直接加载一个处�?span style="color: brown">持久状�?/span>的实体对象。如下：

Java代码

TUser user = Session.load(TUser.class,new Integer(1));
//在load�Ҏ��没返回之前，��已�l�先把对象纳入Hibernate的管理范��_��所以这里的user
//已经处于持久状态�?/span>

TUser user = Session.load(TUser.class,new Integer(1)); //在load�Ҏ��没返回之前，��已�l�先把对象纳入Hibernate的管理范��_��所以这里的user //已经处于持久状态�?

从上面的代码可以看出�Q�处�?span style="color: brown">持久状�?/span>的实体对象一定要和Session兌��Q��ƈ处于该Session的有效期内�?

3�Q�游��ȝ��态（Detached�Q?/strong>
处于持久状�?/span>的实体对象，在其兌��的Session关闭以后�Q�此实体对象��处�?span style="color: brown">游离状�?/span>�Q?

Java代码

TUser user = new TUser();
user.setName("name_1");
Transaction tx = session.begintransaction();
session.save(user);//把自��q��态的实体对象user转�ؓ持久状态，
tx.commit();
session.close();
//session关闭以后�Q�处于持久状态的实体对象user��{为游��ȝ��态�?
//因�ؓ此时user已经和session��q��关系�?/span>

TUser user = new TUser(); user.setName("name_1"); Transaction tx = session.begintransaction(); session.save(user);//把自��q��态的实体对象user转�ؓ持久状态， tx.commit(); session.close(); //session关闭以后�Q�处于持久状态的实体对象user��{为游��ȝ��态�? //因�ؓ此时user已经和session��q��关系�?

�׃��面可以看到实体对象的游离状�?/span>是在对象和它所寄宿的Session��q��关系后�Ş成的�Q�但处于自由状�?/span>的实体对象也没有和�Q何session有关联，那么他们两者有什么区别呢�Q�关键的��在我们�?span style="color: brown">自由状�?/span>的实体对象执行了Session.save�Ҏ��Q?
当我们执�?

Java代码

TUser user = new TUser();

TUser user = new TUser();

�Ӟ��我们只是创徏了一个普通的对象�Q�他�q�没有和数据库里的�Q何一条记录对应，当我们执�?
Session.save以后�Q�Hibernate��׃ؓuser讄��了一个主键，��是user.Id属性，通过�q�个属性，Hibernate��把user对象和数据库里的记录兌��h��Q�所�?span style="color: brown">自由状�?/span>�?span style="color: brown">游离状�?/span>的基本区别就�?处于游离状�?/span>的实体对象，在数据库里有对应的记录，因此它可以通过和session兌��再次转�ؓ持久状�?/span>�?

三种状态的转化
自由状�?->持久状态：可以通过Session.sava�Ҏ��来�{换�?
持久状�?->游离状态：可以通过Session.close�Ҏ��来关闭session�Q�获取游��ȝ��态的对象
持久状�?->自由状态：可以通过Session.delete�Ҏ��来删除实体对象对应的数据库记录，使实体对象处于自��q��态�?

补充一下，有时可能会想�Q�可以通过认�ؓ的个处于自由状�?/span>的实体对象设�|�一个Id�?

Java代码

user.Id=1

user.Id=1
�Q�来��Zؓ的创��Z��?span style="color: brown">游离状�?/span>的对象�?
�q�里注意一点，我们可以��Zؓ地给实体对象讄��Id��|��我我们无法知道这个ID值在数据库里有没有对应的记录�Q�如果没有，��q��我们��Zؓ地设�|�了Id�Q�也不能说一个有ID的实体对象就是一�?span style="color: brown">游离状�?/span>的对象�?/div>

lanxin1020 2009-04-08 12:02 发表评论

亚洲精品无码永久在线观看你懂的,亚洲色图校园春色,日韩亚洲综合精品国产

hibernate 自定义数据类型映���（转）

Hibernate悲观锁和乐观�?�?

使用 SchemaExport 自动�����

SchemaExportTask(转自 良葛�?

Hibernate延迟加蝲机制(�?

hibernate �~�存机制(�?

Hibernate 体系�l�构与工作原�?�?

Hibernate 的原理与配置(�?

Hibernate实体对象的生命周期（转）

Hibernate实体对象的生命周�?/a>

hibernate 自定义数据类型映��（转）

使用 SchemaExport 自动��

SchemaExportTask(转自良葛�?