`
peizhiinfo
  • 浏览: 1417250 次
文章分类
社区版块
存档分类
最新评论

Hiberante3学习之路第一节 原创

 
阅读更多

最近在忙于Hibernate3授课的讲解,闲来之余对每一次授课的内容做个总结,供正在或将要学习Hibernate3框架技术的学员参考,愿从中有所收获......

一、Hibernate环境搭建
1、建立一个普通的java项目,首先进行数据库连接,选择myeclipse Database Explorer 界面,在空白处右键new新建连接,连接的驱动模型Driver template选择MySQL Connector,加载驱动,下一步选择你要加载的数据库,连接后台成功后回到java界面。
2、安装配置的三项准备工作
1、添加hibernate库

Java代码 复制代码
  1. 将下载目录/hibernate3.jar和/lib下的hibernate运行时必须的包加入classpath中:antlr.jar,cglib.jar,asm.jar,commons-collections.jar,commons-logging.jar,jta.jar,dom4j.jar
  2. 将hibernatejar包文件添加到java项目中

2、添加hibernate配置文件
配置文件hibernate.cfg.xml和hibernate.properties,XML和properties两种,这两个文件的作用一样,提供一个即可,推荐XML格式,下载目录/etc下是示例配置文件。
可以在配置文件指定:数据库的URL、用户名、密码、JDBC驱动类、方言等。
启动时Hibernate会在CLASSPATH里找这个配置文件。
命名的语法格式,名字是固定的并且位于src目录下
Java代码 复制代码
  1. hibernate.cfg.xml
  2. <hibernate-configuration>
  3. <session-factory>
  4. <!--连接数据库名称是在myeclipse中设置的-->
  5. <propertyname="myeclipse.connection.profile">localhost</property>
  6. <!--数据库连接的URL-->
  7. <propertyname="connection.url">
  8. jdbc:mysql://localhost:3306/houtai
  9. </property>
  10. <!--数据库的用户名和密码-->
  11. <propertyname="connection.username">root</property>
  12. <propertyname="connection.password">root</property>
  13. <!--数据库的驱动-->
  14. <propertyname="connection.driver_class">
  15. com.mysql.jdbc.Driver
  16. </property>
  17. <!--数据库的方言-->
  18. <propertyname="dialect">
  19. org.hibernate.dialect.MySQLDialect
  20. </property>
  21. <!--显示sql语句的操作-->
  22. <propertyname="show_sql">true</property>
  23. <!--创建表
  24. <propertyname="hibernate.hbm2ddl.auto">create</property>
  25. -->
  26. <!--添加映射文件-->
  27. <mappingresource="edu/hiber/User.hbm.xml"/>
  28. </session-factory>
  29. </hibernate-configuration>

3、添加对应表的实体类和映射文件
映射文件(hbm.xml,对象模型和关系模型的映射)。在/eg目录下有完整的hibernate示例。
实体类和数据库表是通过hbm.xml配置文件来完成
命名语法格式:
Java代码 复制代码
  1. 类名.hbm.xml与实体类在同一个包中
  2. User.hbm.xml
  3. <hibernate-mappingpackage="hiber">
  4. <!—name实体类名,table对应数据库表的表名-->
  5. <classname="User"table="user"catalog="hoteldb">
  6. <idname="id"><!—user表中有一个id的属性-->
  7. <!—generator引用native代表主键自动增长-->
  8. <generatorclass="native"/>
  9. </id>
  10. <!—property成员属性-->
  11. <propertyname="name"length="40"/>
  12. <propertyname="pass"/>
  13. <propertyname="birthday"/>
  14. </class>
  15. </hibernate-mapping>

在这里有一个面试常考的题就是数据库的主键生成策略
数据库的主键:
代理主键: 没有业务逻辑含义
自然主键: 有业务逻辑含义
主键生成策略:
Hibernate 提供的内置标识符生成器OID
Java代码 复制代码
  1. increment:适用于代理主键,由Hibernate自动以递增的方式生成标识符,每次递增为1
  2. identity:适用于代理主键,由底层数据库生成标识符.前提是底层数据库支持自动增长字段类型
  3. sequence:适用于代理主键,Hibernate根据底层数据库的序列生成标识符.前提是底层数据库支持序列
  4. hilo:适用于代理主键,Hibernate根据hi/low算法生成标识符.Hibernate把特定的字段作为"high".默认情况下选用hibernate_unique_key表的next_hi字段
  5. native:适用于代理主键,根据底层数据库对自动生成标识符的支持能力,来选择identify,sequence,或hilo
  6. uuid.hex:适用于代理主键,Hibernate采用128位的UUID(UniversalIdentification)算法生成标识符.UUID算法能够在网络环境中生成唯一的字符串标识符.这种标识符生成策略并不流行,因为字符串类型的主键比整数类型的主键占用更大的数据库空间
  7. assigned:适用于自然主键,由Java应用程序生成标识符.为了能让Java应用程序设置OID,不要把方法声明为private类型.

二、创建数据库
1、在hibernate.cfg.xml配置文件中写创建数据库命令
Java代码 复制代码
  1. <!—创建表-->
  2. <propertyname="hibernate.hbm2ddl.auto">create</property>
  3. 它有4个属性:
  4. create:会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变
  5. create-drop:根据model类生成表,但是sessionFactory一关闭,表就自动删除
  6. update:最常用的属性,也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行
  7. validate:只会和数据库中的表进行比较,不会创建新表,但是会插入新值

2、添加实体类和数据库表的映射
Java代码 复制代码
  1. <!--添加映射文件-->
  2. <mappingresource="edu/hiber/User.hbm.xml"/>
  3. 同时添加show_sql属性
  4. <!--显示sql语句的操作-->
  5. <propertyname="show_sql">true</property>

3、创建表
Java代码 复制代码
  1. /**解析配置文件configure()默认解析hibernate.cfg.xml文件并返回Configuration的对象*/
  2. Configurationcfg=newConfiguration().configure();
  3. /**根据cfg对象创建一个SchemaExport的对象*/
  4. SchemaExportse=newSchemaExport(cfg);
  5. /**创建表的操作*/
  6. se.create(true,true);

三、操作数据库
操作表(增删改查)
Java代码 复制代码
  1. packagehiber;
  2. importjava.util.Date;
  3. importorg.hibernate.SessionFactory;
  4. importorg.hibernate.Transaction;
  5. importorg.hibernate.cfg.Configuration;
  6. importorg.hibernate.Session;
  7. publicclassTestHiber{
  8. /**插入的方法*/
  9. publicbooleaninsert(){
  10. booleanflag=false;
  11. /**
  12. *采用Configuration对象configure方法解析hibernate.cfg.
  13. *xml文件并返回一个Configuration的对象
  14. */
  15. Configurationcfg=newConfiguration().configure();
  16. /**根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂*/
  17. SessionFactorysf=cfg.buildSessionFactory();
  18. /**采用sf对象中的openSession的方法创建连接并打开操作的session*/
  19. Sessionsession=sf.openSession();
  20. /**定义个事务对象*/
  21. Transactiontx=null;
  22. try{
  23. //开始事务
  24. tx=session.beginTransaction();
  25. Userentity=newUser("sha","123",newDate());
  26. //执行事务
  27. session.save(entity);
  28. //提交事务
  29. tx.commit();
  30. flag=true;
  31. }catch(Exceptione){
  32. //如果出现导常则回滚事务
  33. if(tx!=null){
  34. tx.rollback();
  35. }
  36. e.printStackTrace();
  37. }finally{
  38. //不管事务执行成功与否都要关闭session
  39. session.close();
  40. }
  41. returnflag;
  42. }
  43. /**查询的方法*/
  44. publicUserfindById(intid){
  45. Useruser=newUser();
  46. /**
  47. *采用Configuration
  48. *对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
  49. */
  50. Configurationcfg=newConfiguration().configure();
  51. /**根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂*/
  52. SessionFactorysf=cfg.buildSessionFactory();
  53. /**采用sf对象中的openSession的方法创建连接并打开操作的session*/
  54. Sessionsession=sf.openSession();
  55. try{
  56. user=(User)session.load(User.class,id);
  57. }catch(Exceptionex){
  58. ex.printStackTrace();
  59. }
  60. returnuser;
  61. }
  62. /**查询的方法*/
  63. publicUserfindByGId(intid){
  64. Useruser=newUser();
  65. /**
  66. *采用Configuration
  67. *对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
  68. */
  69. Configurationcfg=newConfiguration().configure();
  70. /**根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂*/
  71. SessionFactorysf=cfg.buildSessionFactory();
  72. /**采用sf对象中的openSession的方法创建连接并打开操作的session*/
  73. Sessionsession=sf.openSession();
  74. try{
  75. user=(User)session.get(User.class,id);
  76. }catch(Exceptionex){
  77. ex.printStackTrace();
  78. }finally{
  79. session.close();
  80. }
  81. returnuser;
  82. }
  83. /**更新的方法*/
  84. publicbooleanupdate(Userentity){
  85. booleanflag=false;
  86. /**
  87. *采用Configuration
  88. *对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
  89. */
  90. Configurationcfg=newConfiguration().configure();
  91. /**根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂*/
  92. SessionFactorysf=cfg.buildSessionFactory();
  93. /**采用sf对象中的openSession的方法创建连接并打开操作的session*/
  94. Sessionsession=sf.openSession();
  95. /**定义个事务对象*/
  96. Transactiontx=null;
  97. try{
  98. //开始事务
  99. tx=session.beginTransaction();
  100. entity.setName("lihui");
  101. //执行事务
  102. session.update(entity);
  103. //提交事务
  104. tx.commit();
  105. flag=true;
  106. }catch(Exceptionex){
  107. /**如果出现异常则回滚事务*/
  108. if(tx!=null){
  109. tx.rollback();
  110. }
  111. ex.printStackTrace();
  112. }finally{
  113. /**不管事务执行成功与否都要关闭session*/
  114. session.close();
  115. }
  116. returnflag;
  117. }
  118. /**删除操作*/
  119. publicbooleandelete(Userentity){
  120. booleanflag=false;
  121. /**
  122. *采用Configuration
  123. *对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
  124. */
  125. Configurationcfg=newConfiguration().configure();
  126. /**根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂*/
  127. SessionFactorysf=cfg.buildSessionFactory();
  128. /**采用sf对象中的openSession的方法创建连接并打开操作的session*/
  129. Sessionsession=sf.openSession();
  130. /**定义个事务对象*/
  131. Transactiontx=null;
  132. try{
  133. //开始事务
  134. tx=session.beginTransaction();
  135. //执行事务
  136. session.delete(entity);
  137. //提交事务
  138. tx.commit();
  139. flag=true;
  140. }catch(Exceptionex){
  141. /**如果出现异常则回滚事务*/
  142. if(tx!=null){
  143. tx.rollback();
  144. }
  145. ex.printStackTrace();
  146. }finally{
  147. /**不管事务执行成功与否都要关闭session*/
  148. session.close();
  149. }
  150. returnflag;
  151. }
  152. publicstaticvoidmain(String[]args){
  153. TestHiberth=newTestHiber();
  154. booleaninsert=th.insert();
  155. if(insert){
  156. System.out.println("插入成功");
  157. }
  158. Userentity=th.findById(1);
  159. booleanflag=th.delete(entity);
  160. if(flag){
  161. System.out.println("删除成功");
  162. }else{
  163. System.out.println("删除失败");
  164. }
  165. }
  166. }


三、通过Myeclipse工具自动添加hibernate类库文件,利用Myeclipse工具反向生成配置文件与Domain Class
1、项目右键,添加类库文Myeclipse,选择Add HibernateCapabilites,选择hibernate核心文件,自动在src目录下创建hibernate的默认配置文件,在DBDriver选择自己配置的链接地址,会自动创建一个hibernateSessionFactroy,我们只需添加一个路径(包)完成。就会自动创建一个hibernate.cfg.xml配置文件,里面自动配置好数据库链接的属性,还会自动创建一个hibernateSessionFactroy的类。
2、反向生产Domain Class和User.hbm.xml文件
首先到myeclipse Database Explorer窗口,选择uesr表右键选择hibernateReverseEngineering反向工程,选择反向的项目,选择创建user对应的javabean,下一步选择主键生成策略Id Generator这里选择native,完成,切换到java窗口。
3、操作表(增删改查)
Java代码 复制代码
  1. packagehiber.test;
  2. importjava.sql.Timestamp;
  3. importjava.util.Date;
  4. importorg.hibernate.Session;
  5. importorg.hibernate.Transaction;
  6. importhiber.bean.User;
  7. importhiber.sf.HibernateSessionFactory;
  8. publicclassTestUser{
  9. /**插入方法*/
  10. publicvoidinsert(){
  11. /**直接利用HibernateSessionFactory得到session对象*/
  12. Sessionsession=HibernateSessionFactory.getSession();
  13. Transactiontx=null;
  14. try{
  15. /**获取当前session的事务*/
  16. tx=session.getTransaction();
  17. /**开始事务*/
  18. tx.begin();
  19. /**瞬时状态对象*/
  20. Userentity=newUser("yq","123",newTimestamp(System
  21. .currentTimeMillis()));
  22. /**执行插入操作*/
  23. session.save(entity);
  24. /**持久状态对象*/
  25. /**事务提交*/
  26. tx.commit();
  27. }catch(Exceptionex){
  28. if(tx!=null)
  29. tx.rollback();/**事务回滚*/
  30. ex.printStackTrace();
  31. }finally{
  32. /**关闭session*/
  33. session.close();
  34. }
  35. /**脱管状态对象.....*/
  36. }
  37. /**查询的方法*/
  38. publicUserfindByLId(intid){
  39. Userentity=newUser();
  40. /**获取session对象*/
  41. Sessionsession=HibernateSessionFactory.getSession();
  42. try{
  43. /**执行操作*/
  44. entity=(User)session.load(User.class,id);
  45. }catch(Exceptionex){
  46. ex.printStackTrace();
  47. }finally{
  48. /**关闭session*/
  49. session.close();
  50. }
  51. returnentity;
  52. }
  53. /**查询的方法*/
  54. publicUserfindByGId(intid){
  55. Userentity=newUser();
  56. /**获取session对象*/
  57. Sessionsession=HibernateSessionFactory.getSession();
  58. try{
  59. /**执行操作*/
  60. entity=(User)session.get(User.class,id);
  61. }catch(Exceptionex){
  62. ex.printStackTrace();
  63. }finally{
  64. /**关闭session*/
  65. session.close();
  66. }
  67. returnentity;
  68. }
  69. /**更新方法*/
  70. publicvoidupdate(Userentity){
  71. /**直接利用HibernateSessionFactory得到session对象*/
  72. Sessionsession=HibernateSessionFactory.getSession();
  73. Transactiontx=null;
  74. try{
  75. /**获取当前session的事务*/
  76. tx=session.getTransaction();
  77. /**开始事务*/
  78. tx.begin();
  79. /**执行更新操作*/
  80. session.update(entity);
  81. /**持久状态对象*/
  82. /**事务提交*/
  83. tx.commit();
  84. }catch(Exceptionex){
  85. if(tx!=null)
  86. tx.rollback();/**事务回滚*/
  87. ex.printStackTrace();
  88. }finally{
  89. /**关闭session*/
  90. session.close();
  91. }
  92. /**脱管状态对象.....*/
  93. }
  94. /**删除的方法*/
  95. publicvoiddelete(Userentity){
  96. /**直接利用HibernateSessionFactory得到session对象*/
  97. Sessionsession=HibernateSessionFactory.getSession();
  98. Transactiontx=null;
  99. try{
  100. /**获取当前session的事务*/
  101. tx=session.getTransaction();
  102. /**开始事务*/
  103. tx.begin();
  104. /**执行更新操作*/
  105. session.delete(entity);
  106. /**持久状态对象*/
  107. /**事务提交*/
  108. tx.commit();
  109. }catch(Exceptionex){
  110. if(tx!=null)
  111. tx.rollback();/**事务回滚*/
  112. ex.printStackTrace();
  113. }finally{
  114. /**关闭session*/
  115. session.close();
  116. }
  117. /**脱管状态对象.....*/
  118. }
  119. publicstaticvoidmain(String[]args){
  120. TestUsertu=newTestUser();
  121. Userentity=tu.findByLId(2);
  122. entity.setName("redarmy");
  123. tu.delete(entity);
  124. }
  125. }
*

这里也有一个面试常考的问题就是对象的状态
Java代码 复制代码
  1. 对象的状态有三种:
  2. 1、瞬时(transient):数据库中没有数据与之对应,超过作用域会被JVM垃圾回收器回收,一般是new出来且与session没有关联的对象。
  3. 2、持久(persistent):数据库中有数据与之对应,当前与session有关联,并且相关联的session没有关闭,事务没有提交;持久对象状态发生改变,在事务提交时会影响到数据库(hibernate能检测到)。
  4. 3、脱管(detached):也称游离,数据库中有数据与之对应,但当前没有session与之关联;脱管对象状态发生改变,hibernate不能检测到。
  5. 瞬时对象可以通过sava或savaorupdate方法转换成持久化对象,对象可以通过get,load,find,iterate方法转换成持久化对象。
  6. 持久化对象可以通过delete方法转换成瞬时对象,可以通过evict,close,clear方法转换成脱管对象。
  7. 脱管对象可以通过savaorupdate,update,lock方法转换成持久化对象。


希望以上内容对学员学习hibernate有所帮助,以上内容属redarmy_chen版权所有,如要转发请注明出处。愿你有所收获!
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics