Hibernate学习笔记2

 

Hibernate学习笔记2

学习内容:

使用JUnit来测试方法

对持久化对象的生命周期的理解

测试实体对象的生命周期

了解get和load的区别

查询所有User对象的记录,并且设置分页

详细内容:

 1.如何使用JUnit,以及使用JUnit的注意事项:

建立单独建立一个存放测试代码的文件夹,在项目名上单击右键,选择

New”——“Source Folder

建立的测试类要继承 TestCase

建立的类名格式: ****Test,例如:HibernateTest

建立的方法名格式: test**** 例如: testSave()

注:建立的方法不要带参数以及返回值

 

 2.对持久化对象的生命周期的理解

对象名及描述

特征

瞬时对象(Transient Objects): 使用new操作符初始化的对象不是立刻就持久的,它们的状态是瞬时的,也就是说他们没有任何跟数据库表相关联的行为,只要应用不再引用这些对象(不再被任何其他对象所引用),它们的状态将会丢失,并由垃圾回收机制回收。

在数据库中没有与之匹配的数据

没有纳入session的管理

持久化对系那个(Presistent Objects)

持久实例是任何具有数据库标识的实例。它由持久化管理器Session同意管理,持久实例是在事务中进行操作的——他们的状态在事务结束同时同数据库进行同步。当事务提交时,通过实行SQL的Insert、Update和Delete语句吧内存中的状态同步到数据库中。在数据库中有与之匹配的数据

纳入了session的管理

在清理缓存的时候会与数据库进行同步

离线对象(Detached Objects): Session关闭后,持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步,他们不再受Hibernate管理。

在数据库中有与之匹配的数据

没有纳入session的管理

下面附加上三种状态之间的转化方式:

 3.测试实体对象的生命周期

进行测试的源代码:

  1. public void testSave() {
  2. Session session = null;
  3. Transaction ts = null;
  4. User user = new User();
  5. try {
  6. session = HibernateUtils.getSession();
  7.  //New出来的对象为Transient状态
  8. //Transient状态
  9. ts = session.beginTransaction();
  10. user = new User();
  11. user.setName("李四");
  12. user.setAge(20);
  13. user.setCreateTime(new Date());
  14. user.setExpireTime(new Date());
  15. //Presistent状态,当属性发生改变的时候,Hibernate会自动和数据库进行同步
  16. //调用save方法之后为Presistent状态
  17. session.save(user);
  18. user.setName("o(∩_∩)o...哈哈");
  19. ts.commit();//commit的时候清理缓存
  20. catch (Exception e) {
  21. e.printStackTrace();
  22. ts.rollback();
  23. finally {
  24. HibernateUtils.closeSession( session );
  25. }
  26. //提交过事务之后为Detached状态
  27. //Detached状态
  28. user.setName( "(*^__^*) 嘻嘻……" );
  29. try {
  30. session = HibernateUtils.getSession();
  31. session.beginTransaction();
  32. //调用update方法是对象由Detached状态转变为Presistent状态
  33. //Persistent状态
  34. session.update( user );
  35. session.getTransaction().commit();
  36. catch (Exception e) {
  37. e.printStackTrace();
  38. session.getTransaction().rollback();
  39. finally {
  40. HibernateUtils.closeSession( session );
  41. }
  42. }

 4.了解get和load的区别

get

Load

session.get( User.class , id ); id实现序列化,实现序列化才能保存到磁盘上采用get加载数据,如果数据库中不存在相应的数据,返回null。如果使用该对象的引用则抛出NullPointerException,JUnit也会抛出异常

session.load( User.class , id );不会马上发出查询sql,采用继承的方式,返回一个代理对象,当真正使用这个类的时候才加载这个类,这个方法为懒加载或延迟加载如果数据库中不存在相应的数据,使用代理的时候会抛出异常ObjectNotFoundExceptiond查询,JUnit也会抛出异常

下面带上测试get和load区别的源代码:

  1. //get查询
  2. //session.get( User.class , id ); id实现序列化,实现序列化才能保存到磁盘上
  3. //采用get加载数据,如果数据库中不存在相应的数据,返回null
  4. //如果使用该对象的引用则抛出NullPointerException,JUnit也会抛出异常
  5. //get查询数据库中存在的数据
  6. public void testReadByGetMethod1(){
  7. Session session = null;
  8. try {
  9. session = HibernateUtils.getSession();
  10. session.beginTransaction();
  11. User user = (User) session.get( User.class ,  "2c92a8d81cf13a4f011cf13a78280001" );
  12. //当执行过get()语句之后,马上就执行查询
  13. System.out.println( user.getName() );
  14. user.setName( "流行" );
  15. session.getTransaction().commit();
  16. catch (Exception e) {
  17. e.printStackTrace();
  18. session.getTransaction().rollback();
  19. finally {
  20. HibernateUtils.closeSession( session );
  21. }
  22. }
  23. //get()查询数据库中不存在的数据,如果使用该引用则会抛出NullPointerException
  24. public void testReadByGetMethod2(){
  25. Session session = null;
  26. try {
  27. session = HibernateUtils.getSession();
  28. session.beginTransaction();
  29. User user = (User) session.get( User.class ,  "abcd" );
  30. //当执行过get()语句之后,马上就执行查询
  31. System.out.println( user.getName() );
  32. //user.setName( "河图" );
  33. session.getTransaction().commit();
  34. catch (Exception e) {
  35. e.printStackTrace();
  36. session.getTransaction().rollback();
  37. finally {
  38. HibernateUtils.closeSession( session );
  39. }
  40. }
  41. //load查询
  42. //session.load( User.class , id );不会马上发出查询sql,采用继承的方式,返回一个代理对象,当真
  43. //正使用这个类的时候才加载这个类,这个方法为懒加载或延迟加载
  44. //如果数据库中不存在相应的数据,使用代理的时候会抛出异常ObjectNotFoundException
  45. //load查询数据库中存在的数据
  46. public void testReadByLoadMethod1(){
  47. Session session = null;
  48. try {
  49. session = HibernateUtils.getSession();
  50. session.beginTransaction();
  51. User user = (User) session.get( User.class ,  "2c92a8d81cf13a4f011cf13a78280001" );
  52. //当执行过get()语句之后,马上就执行查询
  53. System.out.println( user.getName() );
  54. user.setName( "流行" );
  55. session.getTransaction().commit();
  56. catch (Exception e) {
  57. e.printStackTrace();
  58. session.getTransaction().rollback();
  59. finally {
  60. HibernateUtils.closeSession( session );
  61. }
  62. }
  63. //load查询数据库中存在的数据,如果使用该对象的代理,则会抛出ObjectNotFoundException
  64. public void testReadByLoadMethod2(){
  65. Session session = null;
  66. try {
  67. session = HibernateUtils.getSession();
  68. session.beginTransaction();
  69. User user = (User) session.get( User.class ,  "abcd" );
  70. //当执行过get()语句之后,马上就执行查询
  71. System.out.println( user.getName() );
  72. user.setName( "活动" );
  73. session.getTransaction().commit();
  74. catch (Exception e) {
  75. e.printStackTrace();
  76. session.getTransaction().rollback();
  77. finally {
  78. HibernateUtils.closeSession( session );
  79. }
  80. }

使用Hibernate删除数据库中的数据

  1. //delete方法
  2. public void testDeleteMethod(){
  3. Session session = null;
  4. try {
  5. session = HibernateUtils.getSession();
  6. session.beginTransaction();
  7. //Presistent状态的对象
  8. User user = (User) session.get( User.class ,  "2c92a8d81cf138c5011cf138c98e0001" );
  9. session.delete( user );
  10. session.getTransaction().commit();
  11. catch (Exception e) {
  12. e.printStackTrace();
  13. session.getTransaction().rollback();
  14. throw new java.lang.RuntimeException();//手动设置抛出异常,则JUnit运行后状态条显示为红色
  15. finally {
  16. HibernateUtils.closeSession( session );
  17. }
  18. //之后user为Transient状态的对象,垃圾对象,要被垃圾回收器回收
  19. //可以手动设置为null
  20. }

提示:

进行JUnit测试方法的时候,抛出了异常但是JUnit的状态条,仍然是绿色的,如果要让JUnit捕获到异常则,向上抛出异常:

 

  1. catch (Exception e) {
  2. e.printStackTrace();
  3. session.getTransaction().rollback();
  4. throw new java.lang.RuntimeException();
  5.             //手动设置抛出异常,则JUnit运行后状态条显示为红色

 

  5.查询数据库中所有的User对象的数据,并且设置分页

比较简单,仅写上源代码:

  1. //查询数据库中所有的User对象的数据,并且设置分页
  2. @SuppressWarnings("unchecked")
  3. public void testQuery(){
  4. Session session = null;
  5. try {
  6. session = HibernateUtils.getSession();
  7. session.beginTransaction();
  8. Query query = session.createQuery( "from User" );  //create HQL query
  9. query.setFirstResult( 5 );  
  10. //Set the first row to retrieve
  11. query.setMaxResults( 3 );  
  12. //Set the maximum number of rows to retrieve
  13. List<User> queryList = query.list();
  14. for ( User user: queryList ){
  15. System.out.println( "name:" + user.getName() );
  16. }
  17. session.getTransaction().commit();
  18. catch (Exception e) {
  19. e.printStackTrace();
  20. session.getTransaction().rollback();
  21. finally {
  22. if ( session != null ){
  23. if ( session.isOpen() ){
  24. session.close();
  25. }
  26. session = null;
  27. }
  28. }
  29. }

你可能感兴趣的:(Hibernate学习笔记2)