其实Hibernate本n是个独立的框Ӟ它不需要Q何web server或application server的支持。然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。这Ҏ(gu)让h产生Hibernate复杂难懂的误解，特别是打M初学者的U极性?/p>
在这文章将不涉及Eclipse, log4j, Struts, Tomcat, XDocletQ和JBoss。本文的目的是演CZ下Hibernate的安装过E以及最基本的功能，从而给初学者一个低得不能再低的入门门槛?/p>
下蝲文g
你需要Java SDK?Hibernate包、Ant包、和JDBC Driver?/p>
1、Hibernate包下载地址:
http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc
2、Ant包下载地址:
http://apache.130th.net/ant/binaries/apache-ant-1.6.1-bin.zip
3、JDBC Driver要根据你用的database来定Q一般database官方|站上都会有。Hibernate支持常用的databaseQ比?MySQL, Oracle, PostgreSQL, 和MS-SQL Server。这些数据库都有JDBC Driver:
Oracle JDBC Driver下蝲地址(下蝲前必d意Oracle协议?
http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html
MySQL JDBC Driver下蝲地址
http://dev.mysql.com/downloads/connector/j/3.0.html
PostgreSQL JDBC Driver下蝲地址
http://jdbc.postgresql.org/download.html
MS-SQL Server JDBC Driver下蝲地址
http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en
4、将Hibernate包和Ant包分别解压至c:\dev\?此目录不重要Q你可以换其它Q何目??/p>
配置环境
1>、你需要添加一个新的环境变? ANT_HOMEQ让它指向c:\dev\<你的ANT包所在目?gt;。ƈ在PATH环境变量里添?ANT_HOME%\bin?/p>
2>、你需要添加一个新的环境变? JAVA_HOMEQ让它指向你的j2sdk根目录。ƈ在PATH环境变量里添?JAVA_HOME%\bin?/p>
3>、创Z个项目目录，比如c:\workspace\My1stHibernate?/p>
在项目目录下Q另外创Z个目? src, classes, lib?/p>
在lib目录下，创徏两个目录: hibernate和db?/p>
q样你有了如下的文gl构:
c:\workspace\My1stHibernate\
c:\workspace\My1stHibernate\src
c:\workspace\My1stHibernate\classes
c:\workspace\My1stHibernate\lib
c:\workspace\My1stHibernate\lib\hibernate
c:\workspace\My1stHibernate\lib\db
4、将c:\dev\<你的Hibernate包所在目?gt;\hibernate2.jar文gcopy到c:\workspace\My1stHibernate\lib\hibernate下?/p>
c:\dev\<你的Hibernate包所在目?gt;\lib\下的所有文件同样copy到c:\workspace\My1stHibernate\lib\hibernate下?/p>
你的JDBC Driver文g(一般是一个jar文g)copy到c:\workspace\My1stHibernate\lib\db下?br>
二、创建数据库
1、用你最喜爱的database软gQ创Z个hibernate_test的数据库?/p>
2、在此数据库下，新徏一个table名ؓCUSTOMER
CREATE TABLE CUSTOMER
(
CID INTEGER NOT NULL PRIMARY KEY,
USERNAME VARCHAR(12) NOT NULL,
PASSWORD VARCHAR(12)
);
三、编写Java文gQPOJOQ?/font>
public class Customer {
private int id;
private String username;
private String password;
public int getId() {
return id;
}
public String getPassword() {
return password;
}
public String getUsername() {
return username;
}
public void setId(int id) {
this.id = id;
}
public void setPassword(String password) {
this.password = password;
}
public void setUsername(String username) {
this.username = username;
}
}
此cd为c:\workspace\My1stHibernate\src\Customer.java文g?/p>
四、编写Testc?/font>
import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
public class Test {
public static void main(String[] args) {
try {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
for (int i = 0; i < 200; i++) {
Customer customer = new Customer();
customer.setUsername("customer" + i);
customer.setPassword("customer");
session.save(customer);
}
tx.commit();
session.close();
} catch (HibernateException e) {
e.printStackTrace();
}
}
}
此cd为c:\workspace\My1stHibernate\src\Test.java文g?br>
五、创建Hibernate映射文g
因ؓq里只有一个Class --- Customer 和一个Table --- CUSTOMERQ你只需要徏立一个映文?-- Customer.hbm.xmlQ来对应CustomercdCUSTOMER表之间的关系?/p>
hibernate 2针对实体对象和集?br>hibernate 3同时提供了属性的延迟加蝲功能?br>其中寚w合的延迟加蝲Ҏ(gu)意义最为重大?/div>
实体对象的gq加?
1.在hibernate配置文g中的class指定
集合cd的gq加载：
在set中指定lazy=true
q样只有实际加蝲与对象相兌的集合对象的时候，再通过session从数据库中加载实际的数据集?br>Hibernate.initializeҎ(gu)可以强制Hibernate立即加蝲兌的对象集Q例如：
Hibernate.initialize(user.getAddress());
集合cd的缓存：
如果为某个集合类讑֮了缓存，?br><set
name="address"
table="t_address"
lazy="true"
......
>
<cache usage="read-only"/>
<key column="user_id" />
<one-to-many class="cn.blogjava.TAddress" />
</set>
Hibernate寚w合类型进行缓存的时候，分两部分保存。首先是q个集合中所有实体的id列表Q其ơ才是各个实体对象?br>q里制定了cache usage="read-only"只会使得HibernateҎ(gu)据烦引进行缓存。也是说只~存了集合中的数据烦引，q不包含集合中的各个实体元素?br>如果指定cache usage="read-write"才会寚w合中的实体进行缓存?/p>
属性的延迟加蝲Q?br>在property节点中声明lazy=true,而且q需要借助Hibernatecd强器对POJOcȝ二进制Class文gq行强化处理?/p>
hibernate中的Collection
Hibernate对JDK Collention接口的独立实玎ͼ
׃传统的Java Set, Map, List实现不能满要求QHibernateҎ(gu)q些接口提供了自q实现?br>Hibernate的实玎ͼ
无序集：Set, Bag, Map
有序集：List
Bag相当于一个允讔R复元素存在的Set?br>因ؓHibernate是自qCollection实现Q所以如下语句会出错Q?br>Set hset = (HashSet)user.getAddresses();
会在q行期报告一个java.lang.ClassCastException,因ؓ实际上返回的是一个类型ؓorg.hibernate.collention.Set的对象?br>所有我们在写POJOӞ必须用JDK Collection Interface(如Set, Map)Q而非特定的JDK Collection实现c?如HashSet, HashMap)声明Collection型属性的原因。例如：
应该是private Set addresses;
而不是private HashSet addresses;
collectioncd属性的保存q程?br>例如
public class TUser implements Serializable {
private Set addresses = new HashSet();
......
}
然后创徏一个TUser实例后，可以ؓ其添加关联的address对象Q?br>TUser user = new TUser();
TAddress addr = new TAddress();
addr.setAddress("HongKong");
user.getAddress().add(addr);
session.save(user);
user对象在经qHibernate处理后发生了变化Q首先，׃insert操作Q生了id|q填充到user对象的id属性，另一斚wHibernate使用了自qcollection实现对user中的HashSet型addresses属性进行了替换Qƈ用数据对其进行了填充?/p>
均可以根据指定的实体cdid从数据库中读取记录，q返回与之对应的实体对象?br>区别Q?br>1.如果未能发现W合条g的记录，getҎ(gu)q回null,而loadҎ(gu)会抛Z个ObjectNotFoundException?br>2.LoadҎ(gu)可返回实体的代理cd例，而getҎ(gu)永远直接q回实体cR?br>3.loadҎ(gu)可以充分利用内部~存和二U缓存中的现有数据，而getҎ(gu)仅在内部~存中查找，如果没有发现对应的数据，越q二U缓存，直接调用SQL完成数据d?br>数据加蝲的过E：
1.在一U缓存中Q根据实体类型和idq行查找Q如果在W一U缓存中命中Q且数据状态合法，则直接返回?br>2.Session会在当前"NonExists"记录中进行查找，如果?NonExists"记录中存在同L条gQ返回null?br>3.对loadҎ(gu)而言Q如果内部缓存中没法现有效数据，查询二~存Q命中则q回?br>4.如果~存中无有效数据Q发h据库查询操作(Select SQL)Q如果经q查询未发现对应记录Q将此次查询的信息在"NonExists"中加以记录，q回null.
5.Ҏ(gu)映射配置和Select SQL查询得到的ResultSetQ创建对应的数据对象?br>6.对象纳入一U缓存?br>7.执行Interceptor.onLoadҎ(gu)(如果有对应的Interceptor)
8.数据纳入二U缓?br>9.如果数据对象实现了LifeCycle接口Q则调用数据对象的onLoadҎ(gu)?br>10.q回数据对象?/div>
扚w查询QSession.find/iterate
查询性能往往是系l性能表现的一个重要方面，查询机制的优劣很大程度上军_了系l的整体性能。这个领域往往也存在最大的性能调整I间?/p>
hibernate2中Session.find()对应?中的session.createQuery().list();
hibernate2中Session.iterate()对应?中的session.createQuery().iterate();
find和iterate区别Q?br>findҎ(gu)通过一条Select SQL实现了查询操作，而iterateҎ(gu)要执行多条Select SQL.
iterateW一ơ查询获取所有符合条件的记录的idQ然后再Ҏ(gu)各个id从库表中d对应的记录，q是一个典型的N+1ơ的查询问题Q如果符合条件记录有10000条，需要执?0001条Select SQLQ可x能会如何的差?/p>
那ؓ什么要提供iteratorҎ(gu)Q而不只是提供高效率的findҎ(gu)Q?/p>
原因1.与hibernate~存机制密切相关
findҎ(gu)实际上是无法利用~存的，它对~存只写不读?br>findҎ(gu)只执行一ơSQL查询Q它无法判断~存中什么样的数据是W合条g的，也无法保证查询结果的完整性。而iterateҎ(gu)Q会首先查询所有符合条件记录的idQ然后根据idȝ存中找，如果~存中有该idQ就q回Q没有可以根据id再去数据库查询?br>String hql = "from TUser where age > ?";
List userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
Iterator it = session.iterate(hql, new Integer(18), Hibernate.INTEGER);
序执行QiterateҎ(gu)只会执行一ơSQL查询Q就是查找idQ然后根据id可以从~存中获得数据?/p>
String hql = "from TUser where age > ?";
List userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
~存是不起作用的?br>如果目标数据d相对较ؓ频繁Q通过iterateq种机制Q会减少性能损耗?/p>
原因2.内存使用上的考虑
findҎ(gu)一ơ获得的所有记录ƈ其d内存。如果数据量太大Q可能会触发OutOfMemoryErrorQ从而导致系l异常。解x案之一是l合iterateҎ(gu)和evictҎ(gu)逐条对记录进行处理，内存消化保持在一个可以接受的范围之内。如Q?br>String hql = "from TUser where age > ?";
Iterator it = session.iterate(hql, new Integer(18), Hibernate.INTEGER);
while(it.hasNext()) {
TUser user = (TUser)it.next();
//对象从一U缓存中删除
session.evict(user);
//二~存可以讑֮最大缓存量,辑ֈ后自动对较老数据进行废?但也可以通过~?br> //码移?q样有助于保持数据有效性?br> sessionFactory.evict(TUser.class, user.getID());
}
扚w数据处理的缓存同步问?br>1.hibernate 2:
session.delete("from TUser");
会先查询出idQ然后逐个id执行 delete from T_User where id = ?;
q样造成效率低下?br>Z么不直接采用一条Delete SQLQ是因ؓORM要自动维持其内部状态属性，必须知道用户作了什么操作。必d从数据库中获得待删除对象Q然后根据这些对象对内部~存和二U缓存的数据q行整理Q以保持内存状态与数据库的一致性?br>单执行一条删除语句，删除了什么数据，只有数据库知道，ORM无法得知。下ơ用户从~存中读出的数据Q很可能是被删除的数据Q从而导致逻辑错误。当Ӟ如果ORM可以Ҏ(gu)DELETE SQL对缓存中数据q行处理Q将~存中符合条件的对象废除Q然后再执行DELETE SQL
Q但是这样导致缓存的理复杂性大大增?实际相当于实C一个支持SQL的内存数据库)Q这对于轻量U的ORM实现而言太苛M?br>2.hibernate 3
性能提高?br>但无法解决缓存同步上的问题，无法保证~存数据的一致有效性?br>Tuser user = (TUser)session.load(TUser.class, new Integer(1));
//通过Bulk delete/update 删除id=1的用戯?br>Transaction tx = session.beginTransaction();
String hql = "delete TUser where id=1";
Query query = session.createQuery(hql);
query.executeUpdate();
tx.commit();
//再次试加蝲
user = (TUser)session.load(TUser.class, new Integer(1));
可以看到W二ơ加载是成功的?/p>
ZJDBC的事务：
无疑是最单的实现方式Q?br>session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
tx.commit();
ZJTA的事务管理：
hibernate默认采用JDBC Transacion。可以通过配置文g指定采用JTA作ؓ事务理实现?br><hibernate-configuration>
<session-factory>
......
<property name="hibernate.transaction.factory_class">
org.hibernate.transaction.JTATransactionFactory
</property>
</session-factory>
</hibernate-configuration>
?locking)
支持两种锁：(zhn)观锁和乐观?/p>
(zhn)观?Pessimistic locking)Q?br>数据库的实现
select * from account where name='yyy' for update
通过for update子句Q这条语句锁定所有符合条件的记录Q在本次事务提交之前Q外界无法修改这些记录?/p>
hibernate的实玎ͼ也是Z数据库的锁机制实玎ͼ
加锁一般通过以下Ҏ(gu)实现Q?br>Criteria.setLockMode
Query.setLockMode
Session.lock
hibernate的加锁模式：
LockMode.NONE:无锁机制
LockMode.WRITE:hibernate在Insert和updateӞ会自动获?br>LockMode.READ:hibernate在读取记录的时候，会自动获?br>以上3U，由hibernate内部使用?/p>
LockMode.UPGRADE:利用数据库的for update子句加锁
LockMode.UPGRADE_NOWAITQoracle特定实现Q利用oracle的for update nowait子句实现加锁?/p>
乐观?Optimistic locking)Q?br>hibernate在其数据讉K引擎中内|了乐观锁实现。可以通过class描述W的optimistic-lock属性结合version描述W指定?/p>
<hibernate-mapping>
<class
name="org.hibernate.sample.TUser"
table="t_user"
dynamic-update="true"
dynamic-insert="true"
optimistic-lock="version"
>
<id>......
</id>
<version
column="version"
name="version"
type="java.lang.Integer"
/>
</class>
</hibernate-mapping>
注意,version节点要在ID节点之后?br>q里Q声明了一个version属性，用于存放用户的版本信息，保存在T_User表的version字段中?/p>
在Hibernate中，~存在以下情况中发挥作用：
1.通过id[主键]加蝲数据的时?br>2.延迟加蝲
一U缓存：
又称内部~存Q保存了与当前session相关联的数据对象Q伴随Session实例的创创建，消亡而消亡。因此又U此~存为Session level cache?/p>
一U缓存正常情况下又Hibernate自动l护Q如果需要手动干预，可以通过以下Ҏ(gu)完成?br>1.Session.evict
某个特定对象从内部~存中清除?br>2.Sessin.clear
清空内部~存
二~存Q?br>又称为SessionFactory Level Cache.
对什么样的数据用二U缓存？
Ҏ(gu)有数据都q行~存是最单的办法Q也是最常用的办法?br>但是某些情况下，反而会影响性能Q比如电(sh)话费查询pȝQ如果实行缓存，内存会被几乎不可能再被重用的数据充斥Q导致性能下降?br>如果数据满以下条gQ可以将其纳入缓存管理：
1.数据不会被第三方应用修改?br>2.data size在可以接受的范围之内
3.数据更新频率较低
4.同一数据可能会被pȝ频繁引用
5.非关键数?br>Hibernate本nq没提供二~存的品化实现(只提供了一个基于HashTable的简单缓存以供调?Q可以用第三方~存来实现?br>默认采用EHCache作ؓ二~存实现?br>EHCache org.ehcache.hibernate.Provider
]]>
例如Q一个用h两个部分l成Q姓名和联系方式。姓名和联系方式都可以作为用Ll成部分?br>
1.表结构如?br>
DROP TABLE t_user;
CREATE TABLE t_user (
id INT NOT NULL AUTO_INCREMENT
, age INT
, firstname VARCHAR(50)
, lastname VARCHAR(50)
, address VARCHAR(200)
, zipcode VARCHAR(10)
, tel VARCHAR(20)
, PRIMARY KEY (id)
);
2.配置文g
TUser.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--
Auto-generated mapping file from
the hibernate.org cfg2hbm engine
-->
<class name="cn.blogjava.component.TUser" table="t_user" catalog="sample">
<id name="id" type="integer">
<column name="id" />
<generator class="native" />
</id>
<property name="age" type="integer">
<column name="age" />
</property>
<component name="name" class="cn.blogjava.component.Name">
<property name="firstname" type="string">
<column name="firstname" length="50" />
</property>
<property name="lastname" type="string">
<column name="lastname" length="50" />
</property>
</component>
<component name="contact" class="cn.blogjava.component.Contact">
<property name="address" type="string">
<column name="address" length="200" />
</property>
<property name="zipcodes" type="string">
<column name="zipcode" length="10" />
</property>
<property name="tel" type="string">
<column name="tel" length="20" />
</property>
</component>
</class>
</hibernate-mapping>
3.POJOc?br>Contact.java
import java.io.Serializable;
public class Contact implements Serializable {
private String address;
private String zipcodes;
private String tel;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public String getZipcodes() {
return zipcodes;
}
public void setZipcodes(String zipcodes) {
this.zipcodes = zipcodes;
}
}
Name.java
import java.io.Serializable;
public class Name implements Serializable {
private String firstname;
private String lastname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}
TUser.java
public class TUser implements java.io.Serializable {
private Integer id;
private Integer age;
private Name name;
private Contact contact;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Contact getContact() {
return contact;
}
public void setContact(Contact contact) {
this.contact = contact;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Name getName() {
return name;
}
public void setName(Name name) {
this.name = name;
}
}
4.试c?br>
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import junit.framework.TestCase;
import junit.framework.Assert;
public class HibernateTest extends TestCase {
Session session = null;
protected void setUp(){
try {
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
session = sessionFactory.openSession();
// delete();
} catch (HibernateException e) {
// TODO: handle exception
e.printStackTrace();
}
}
protected void tearDown() {
try {
session.close();
} catch (HibernateException e) {
// TODO: handle exception
e.printStackTrace();
}
}
public void delete(){
Transaction tran = null;
String hql = " delete TUser";
try {
tran = session.beginTransaction();
Query query = session.createQuery(hql);
int ret = query.executeUpdate();
System.out.println("Delete records => " + ret);
tran.commit();
} catch (HibernateException e) {
// TODO: handle exception
e.printStackTrace();
Assert.fail(e.getMessage());
if(tran != null) {
try {
tran.rollback();
} catch(HibernateException e2) {
e2.printStackTrace();
}
}
}
}
public void testInsert(){
Transaction tran = null;
try {
System.out.println("session is " + session);
tran = session.beginTransaction();
//user1
TUser user = new TUser();
user.setAge(25);
Name name = new Name();
name.setFirstname("yu");
name.setLastname("yy");
user.setName(name);
Contact contact = new Contact();
contact.setAddress("dalian");
contact.setTel("42689334");
contact.setZipcodes("116023");
user.setContact(contact);
session.save(user);
//user2
TUser user2 = new TUser();
user2.setAge(26);
Name name2 = new Name();
name2.setFirstname("bai");
name2.setLastname("yf");
user2.setName(name2);
Contact contact2 = new Contact();
contact2.setAddress("beijing");
contact2.setTel("12345678");
contact2.setZipcodes("100010");
user2.setContact(contact2);
session.save(user2);
session.flush();
tran.commit();
Assert.assertEquals(user.getId().intValue() > 0, true);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
Assert.fail(e.getMessage());
if(tran != null) {
try {
tran.rollback();
} catch(HibernateException e2) {
e2.printStackTrace();
}
}
}
}
public void testSelect(){
String hql = " from TUser where age=25 ";
try {
List userList = session.createQuery(hql).list();
TUser user = (TUser)userList.get(0);
Contact contact = user.getContact();
Assert.assertEquals(contact.getAddress(), "dalian");
Assert.assertEquals(user.getName().getFirstname(), "yu");
} catch (HibernateException e) {
// TODO: handle exception
e.printStackTrace();
Assert.fail(e.getMessage());
}
}
}
]]>
2.在视图中的配|上Q点d键，~辑配置Q配|如?br>
3.在配|上Q点d键，选择HQL ScratchpadQ打开HQL语句~辑H口
4.可以通过Hibernate Dynamic Query TranslatorQ查看最l执行的SQL语句?br>
5.可以通过Query Parameters来设|查询参?br>
6.可以通过Hibernate Query Result来查看查询结?br>
7.l合property视图Q看得更清楚
]]>
]]>
]]>
一对一兌有两U类型：主键兌和唯一外键兌
一.主键兌Q?br>一对一主键兌形式Q即两张兌表通过主键形成一对一映射关系?br>例如Q一个中国公民只能有一份护照?br>
1.数据模型如下
2.表定义sql
DROP TABLE T_Passport;
CREATE TABLE T_Passport (
id INT NOT NULL
, serial VARCHAR ( 30 )
, expiry INT
, PRIMARY KEY (id)
);
CREATE TABLE T_User (
id INT NOT NULL AUTO_INCREMENT
, name VARCHAR ( 50 )
, age INT
, PRIMARY KEY (id)
, INDEX (id)
, CONSTRAINT FK_T_User_1 FOREIGN KEY (id)
REFERENCES T_Passport (id)
);
3.POJOc?br>TUser.java
public class TUser implements java.io.Serializable {
// Fields
private Integer id;
private Integer age;
private String name;
private TPassport passport;
// Constructors
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this .age = age;
}
public TPassport getPassport() {
return passport;
}
public void setPassport(TPassport passport) {
this .passport = passport;
}
/** default constructor */
public TUser() {
}
/** constructor with id */
public TUser(Integer id) {
this .id = id;
}
// Property accessors
public Integer getId() {
return this .id;
}
public void setId(Integer id) {
this .id = id;
}
public String getName() {
return this .name;
}
public void setName(String name) {
this .name = name;
}
}
TPassport.java
import java.io.Serializable;
public class TPassport implements Serializable {
private Integer id;
private String serial;
private Integer expiry;
private TUser user;
public Integer getExpiry() {
return expiry;
}
public void setExpiry(Integer expiry) {
this .expiry = expiry;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this .id = id;
}
public String getSerial() {
return serial;
}
public void setSerial(String serial) {
this .serial = serial;
}
public TUser getUser() {
return user;
}
public void setUser(TUser user) {
this .user = user;
}
}
3.配置文g
TUser.hbm.xml
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
< class name ="cn.blogjava.start.TUser" table ="T_User" catalog ="sample" >
< id name ="id" type ="integer" >
< column name ="id" />
< generator class ="native" />
</ id >
< property name ="name" type ="string" >
< column name ="name" length ="100" not-null ="true" />
</ property >
< property name ="age" type ="java.lang.Integer" column ="age" />
< one-to-one name ="passport"
class ="cn.blogjava.start.TPassport"
cascade ="all"
outer-join ="true"
/>
</ class >
</ hibernate-mapping >
TPassport.hbm.xml
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
< class name ="cn.blogjava.start.TPassport" table ="T_Passport" catalog ="sample" >
< id name ="id" type ="integer" column ="id" >
< generator class ="foreign" >
< param name ="property" > user </ param >
</ generator >
</ id >
< property name ="serial" type ="string" column ="serial" />
< property name ="expiry" type ="java.lang.Integer" column ="expiry" />
< one-to-one name ="user"
class ="cn.blogjava.start.TUser"
constrained ="true"
/>
</ class >
</ hibernate-mapping >
4.试代码
import java.util.List;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateTest extends TestCase {
Session session = null ;
protected void setUp() {
try {
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
session = sessionFactory.openSession();
} catch (HibernateException e) {
e.printStackTrace();
}
}
protected void tearDown() {
try {
session.close();
} catch (HibernateException e) {
e.printStackTrace();
}
}
public void testInsert() {
Transaction tran = null ;
try {
TUser user = new TUser();
user.setName( " byf " );
user.setAge( new Integer( 26 ));
TPassport passport = new TPassport();
passport.setSerial( " PCN123456 " );
passport.setExpiry( new Integer( 20081010 ));
// 讄怺兌
user.setPassport(passport);
passport.setUser(user);
tran = session.beginTransaction();
session.save(user);
session.flush();
tran.commit();
Assert.assertEquals(user.getId().intValue() > 0 , true );
} catch (HibernateException e) {
e.printStackTrace();
Assert.fail(e.getMessage());
if (tran != null ) {
try {
tran.rollback();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
}
/**
* 对象d试(SelectҎ(gu))
*/
public void testSelect(){
String hql = " from TUser where name='byf' " ;
try {
List userList = session.createQuery(hql).list();
TUser user = (TUser)userList.get( 0 );
System.out.println( " user name is " + user.getName());
System.out.println( " passport serial NO. is " + user.getPassport().getSerial());
Assert.assertEquals(user.getName(), " byf " );
} catch (Exception e) {
e.printStackTrace();
Assert.fail(e.getMessage());
}
}
}
]]>
1.实体查询
String hql = " from TUser";
执行q条语句会返回TUser以及TUser子类的纪录?br>
hql = "from java.lang.Object"
会返回数据库中所有库表的U录?br>
where 语句
hql = "from TUser as user where user.name='yyy'";
其中Qas可以省略也一?br>hql = "from TUser user where user.name='yyy'";
where子句中，我们可以通过比较q算W设定条Ӟ如：
=, <>, >, <, >=, <=, between, not between, in, not in, is, like{?br>
2.属性查?br>List list = session.createQuery("select user.name, user.age from TUser as user").list();
q可以在HQL中动态构造对象实例的Ҏ(gu)Q将数据装?br>List list = session.createQuery("select new TUser(user.name, user.age) from TUser as user").list();
Iterator it = list.iterator();
while(it.hasNext() ) {
TUser user = (TUser)it.next();
System.out.println(user.getName());
}
但是要注意这里的TUser对象只是对name和age属性的装Q其他状态均未赋|所以不能用它来q行更新操作?br>
也可以在HQL的Select子句中用统计函?br>"select count(*) ,min(user.age) from TUser as user"
也可以用distinct关键字来删除重复U录?br>select distinct user.name from TUser as user;
3.实体的更C删除
hibernate 2中需要先查询出实体，讄属性后再保存?br>
hibernate 3中，提供了更灉|的方?bulk delete/update)
更新Q?br> Query query = session.createQuery("update TUser set age=18 where id=1");
query.executeUpdate();
删除Q?br> session.createQuery("delete TUser where age>=18");
query.executeUpdate();
4.分组与排?br>Order by子句Q?br> from TUser user order by user.name, user.age desc
Group by子句和Having子句
"select count(user), user.age from TUser user group by user.age having count(user)>10"
5.参数邦定
通过序占位W?来填充参敎ͼ
1)hibernate 2 中通过session.findҎ(gu)来填?br> session.find("from TUser user where user.name=?", "Erica", Hibernate.STRING);
多个参数的情况：
Object[] args = new Object[] {"Erica", new Integer(20)};
Type[] types = new Type{Hibernate.STRING, Hibernate.INTEGER};
session.find("from TUser user where user.name=? and user.age=?", args, types);
2)通过Query接口q行参数填充Q?br> Query query = session.createQuery("from TUser user where user.name=? and user.age>?");
query.setString(0,"Erica");
query.setInteger(1, 20);
通过引用占位W来填充参数Q?br> String hql = "from TUser where name=:name";
Query query = session.createQuery(hql);
query.setParameter("name","Erica");
甚至可以查询条件封装ؓ一个JavaBean
class UserQuery {
private String name;
private Integer age;
//getter and setter
}
String hql = "from TUser where name=:name and age=:age";
Query query = session.createQuery(hql);
UserQuery uq = new UserQuery();
uq.setName("Erica");
uq.setAge(new Integer(20));
query.setProperties(uq); //会调用里面的getter?
query.iterate();
6.联合查询
也可以?inner join,left outer join, right out join, full join
排列l合Qform TUser, TAddress
]]>
]]>