一个简单的hibernate的实例

一、下载hibernate-3.2 core版本，解压。
二、打开eclipse，建立一个用户库，命名为:hibernate3.2，导入刚解压的hibernate目录下的hibernate3.jar
并/lib目录下的所有jar文件。在Builder path的source and output fold中选择Folder,并默认给出的文件夹名。
在as JRE library use中选择JRE_LIB variable。
三、新建一个java工程。在其属性的Java Build Path中引入刚建立的hibernate3.2用户库并mysql的java驱动（
视你所用的数据库而定，在这我用的是mysql数据库）。
四、在src中建立一个包，设为px.malijun,并在其中建立以下几个Java Class:

User.java

1. packagepx.malijun;
3. publicclassUser{
4. privateintid;
5. privateStringname;
6. privateStringpassword;
7. privateStringemail;
8. publicStringgetEmail(){
9. returnemail;
10. }
11. publicvoidsetEmail(Stringemail){
12. this.email=email;
13. }
14. publicStringgetName(){
15. returnname;
16. }
17. publicvoidsetName(Stringname){
18. this.name=name;
19. }
20. publicStringgetPassword(){
21. returnpassword;
22. }
23. publicvoidsetPassword(Stringpassword){
24. this.password=password;
25. }
26. publicintgetId(){
27. returnid;
28. }
29. publicvoidsetId(intid){
30. this.id=id;
31. }
33. }

建立相应的xml映射文件：

User.hbm.xml

1. <?xmlversion="1.0"encoding='utf-8'?>
2. <!DOCTYPEhibernate-mappingPUBLIC
3. "-//Hibernate/HibernateMappingDTD3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
6. <hibernate-mapping>
7. <classname="px.malijun.User"table="users">
8. <idname="id">
9. <generatorclass="identity"/>
10. </id>
11. <propertyname="name"/>
12. <propertyname="password"/>
13. <propertyname="email"/>
14. </class>
15. </hibernate-mapping>

在数据库中建立一个myproject(按你的意思定名)数据库，在其中建立一个users表（向RoR学习）：

1. CREATETABLE`users`(
2. `id`int(11)NOTNULLauto_increment,
3. `name`varchar(255)defaultNULL,
4. `password`varchar(255)defaultNULL,
5. `email`varchar(255)defaultNULL,
6. PRIMARYKEY(`id`)
7. )
   

注：我是用phpmyadmin对mysql数据库进行管理的，在建立的时候我特意为其选择了utf-8编码。


在src的根目录下（以上的user.hbm.xml映射文件与User.java在同一目录下）建立hibernate的配置文件：

hibernate.cfg.xml

1. <?xmlversion="1.0"encoding="utf-8"?>
3. <!DOCTYPEhibernate-configurationPUBLIC
5. "-//Hibernate/HibernateConfigurationDTD3.0//EN"
7. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
9. <hibernate-configuration>
11. <session-factory>
13. <!--显示实际操作数据库时的SQL-->
15. <propertyname="show_sql">true</property>
17. <!--SQL方言，这边设定的是MySQL-->
19. <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
21. <!--JDBC驱动程序-->
23. <propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>
25. <!--JDBCURL　注意这边我设定的所使用的编码 -->
27. <propertyname="connection.url">jdbc:mysql://localhost:3306/myproject?useUnicode=true&amp;characterEncoding=utf8</property>
29. <!--数据库使用者-->
31. <propertyname="connection.username">root</property>
33. <!--数据库密码-->
35. <propertyname="connection.password"></property>
37. <!--以下设置对象与数据库表格映像文件-->
38. <mappingresource="px/malijun/User.hbm.xml"/>
40. </session-factory>
42. </hibernate-configuration>

ok 了，下面我们就进入我们的实际使用阶段了：


由于常规操作都类似，我们建立了一个抽象类：

HibernateBase.java

1. packagepx.malijun;
3. importorg.hibernate.*;
4. importorg.hibernate.cfg.*;
5. importjava.util.*;
6. importjava.io.IOException;
7. importjava.io.PrintWriter;
9. publicabstractclassHibernateBase
10. {
11. protectedSessionFactorysessionFactory;//会话工厂，用于创建会话
12. protectedSessionsession;//hibernate会话
13. protectedTransactiontransaction;//hiberante事务
15. publicHibernateBase()throwsHibernateException
16. {
17. this.initHibernate();
18. }
19. //帮助方法
20. protectedvoidinitHibernate()
21. throwsHibernateException{
23. //装载配置，构造SessionFactory对象
24. sessionFactory=newConfiguration().configure().buildSessionFactory();
25. }
27. /**
28. *开始一个hibernate事务
29. */
30. protectedvoidbeginTransaction()
31. throwsHibernateException{
33. session=sessionFactory.openSession();
34. transaction=session.beginTransaction();
35. }
37. /**
38. *结束一个hibernate事务。
39. */
40. protectedvoidendTransaction(booleancommit)
41. throwsHibernateException{
43. if(commit){
44. transaction.commit();
45. }else{
46. //如果是只读的操作，不需要commit这个事务。
47. transaction.rollback();
48. }
49. session.close();
50. }
51. }

然后建立一个具体针对User操作的一个类：

UserBean.java

1. packagepx.malijun;
3. importorg.hibernate.*;
4. importorg.hibernate.cfg.*;
5. importjava.util.*;
7. /**
8. *和course相关的业务逻辑
9. */
10. publicclassUserBeanextendsHibernateBase{
11. publicUserBean()throwsHibernateException{
12. super();
13. }
15. /**
16. *增加一个Course
17. */
18. publicvoidaddUser(Useruser)throwsHibernateException{
19. beginTransaction();
20. session.save(user);
21. endTransaction(true);
22. }
24. /**
25. *查询系统中所有的Course，返回的是包含有Course持久对象的Iterator。
26. */
27. publicIteratorgetAllUsers()throwsHibernateException{
28. StringqueryString="selectusersfromUserasuser";
29. beginTransaction();
30. Queryquery=session.createQuery(queryString);
31. Iteratorit=query.iterate();
32. returnit;
33. }
35. /**
36. *删除给定ID的course
37. */
38. publicvoiddeleteUser(Stringid)throwsHibernateException{
39. beginTransaction();
40. Useruser=(User)session.load(User.class,id);
41. session.delete(user);
42. endTransaction(true);
43. }
45. /**
46. *按course的名字进行模糊查找，返回的是包含有Course持久对象的Iterator。
47. */
48. publicIteratorgetSomeUser(Stringname)throwsHibernateException{
49. StringqueryString="selectufromUserasuwhereu.namelike:name";
50. beginTransaction();
51. Queryquery=session.createQuery(queryString);
52. query.setString("name","%"+name+"%");
53. Iteratorit=query.iterate();
54. returnit;
55. }
56. }

万事大吉，所欠的事情就是调用UerBean中定义的操作进行我们实际所要针对User所做的事情了。我们写一个简单的
测试：

Test.java

1. packagepx.malijun;
3. publicclassTest {
5. /**
6. *@paramargs
7. */
8. publicstaticvoidmain(String[]args){
9. //TODOAuto-generatedmethodstub
10. UserBeanub=newUserBean();
11. Useruser=newUser();
12. user.setName("你好，世界！");
13. user.setPassword("123456");
14. user.setEmail("ok@ujs.edu.cn");
15. ub.addUser(user);
17. }
19. }

这个测试在执行以后，你查看一下数据库中的users表，你就会发现，我们真的add一个user了，其它的
操作，我们就略了。