2021-06-04 Java对象在Hibernate下的4种状态和Session相关方法以及对象识别

注：集成开发环境软件：MyEclipse（2017破解版）和mySQL（MySQL Server 8.0）

一、Query（查询）

（1）Query（查询）接口允许你在数据库上执行查询并控制查询如何执行。查询语句使用HQL或者本地数据库的SQL方言编写。

（2）调用代码： Query query = session.createQuery(“from User”);

二、Java对象在Hibernate下的状态（临时/瞬间，持久，托管）

(1)瞬时对象

瞬时对象(Transient Objects)：由new操作符创建，且尚未与Session 关联的对象被认定为瞬时(Transient)的，不和数据库的数据有任何关联关系。
瞬时(Transient)对象没有被持久化到数据库中，也不会被赋予持久化标识(identifier)。
如果瞬时(Transient)对象在程序中没有被引用，它会被垃圾回收器(garbage collector)销毁。
由于此对象没有纳入Session的管理，那么此时该对象的任何变化都不会发出SQL语句。
可以通过调用Session的持久方法(save(),saveOrUpdate()等)进行持久化操作时才会转变为持久对象,并拥有和数据库记录相同的id标识。
持久对象(Persist Objects)：持久(Persistent)对象在数据库中有对应的记录，并拥有一个持久化标识(identifier)。

(2)持久对象

持久对象可能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的Session作用范围内。
它有持久化管理器Session统一管理，持久对象是在事务中进行操作的——Transaction实例执行commit()之后，与数据库进行同步。当事务提交时，通过执行SQL的INSERT、UPDATE和DELETE语句把内存中的状态同步到数据库中。
持久化对象任何变化都会自动地发出SQL语句，也就是说该对象和数据库是实时联动(同步的)。

（3）托管对象

托管对象(Detached Objects)：与持久(Persistent)对象关联的Session被关闭后，对象就变为脱管(Detached)的。托管表示这个对象不能再与数据库保持同步，它们不再受Session管理。
对脱管(Detached)对象的引用依然有效，对象可继续被修改。脱管(Detached)对象如果重新关联到某个新的Session上，会再次转变为持久(Persistent)的(在Detached期间的改动将被持久化到数据库)。
本质和瞬时对象相同，都没有纳入Session管理，自身的状态变化，不会自动地发出SQL语句，区别是：在数据库中有与之对应的记录；比瞬时对象多了一个数据库标识id。

三、Session相关方法

save()方法：把Java对象保存数据库中，把一个瞬时对象变成持久对象。
update()方法：更新数据库中的Java对象，把一个托管对象变成持久对象。
delete()方法：把Java对象从数据库中删除，把一个持久对象变成临时对象。
load()/get()方法：根据对象标识从数据库中加载Java对象，返回的对象都是处于持久化状态。
saveOrUpdate()方法同时包含了save() 和 update() 两个功能。如果传入的参数是瞬时对象，就调用save()方法。如果传入的对象是托管对象，就调用update()方法。
close()方法，session缓存被清空，缓存中的所有持久化对象都变为游离状态。
evict(): 能够从缓存中删除一个持久化对象，使它变为托管状态。
clear()：清除Session中所有缓存对象。

（注：装载对象——get 方法和 load 方法的区别：

1.Session的load()方法和get()方法都能够根据给定的OID(Object ID对象唯一标示符)从数据库中加载一个持久化对象到Session缓存中。

（1）如果没有符合条件的纪录，get返回一个null，load会抛出一个ObjectNotFoundException。

（2）get方法立即加载对象， load返回一个代理对象，延迟装载对象，只有在对象第一次被应用程序访问时，Hibernate才会从数据库中加载该对象。

2.在无法确认持久对象是否存在于数据库中时，开发者应当使用get()方法来获取持久对象，通过判断返回值时候为null来确认持久对象的存在与否。

3.load、get方法或其它查询方法返回的对象都在session的缓存中。所以如修改对象的属性，那么事务提交后，会将数据同步到数据库。）

四、session的缓存

每个Session实例可以看作为一个容器，具有缓存，每一个持久化对象都被纳入Session的缓存中。数据库中的一条记录在一个Session中只能对应一个对象，不同的Session可以有不同的对象对应数据库中的同一个记录。

1.Session有如下两个作用：

充当蓄水池的作用，减少程序访问数据库的次数。
保证缓存中的数据与数据库同步。缓存毕竟不是数据库，它的数据有可能和数据库不一致，这时Hibernate会负责将缓存中的数据同步到数据库。

五、一个Session中不能同时存在两个ID相同的持久化对象

六、与数据库的同步

脏数据：数据仅仅在内存中更新而没有同步到数据库中称为脏数据。
hibernate会监测脏数据，在尽可能迟的时候做同步的动作。（transparent transaction-level write-behind）
hibernate可以做到仅仅更新有变动的属性，但是需要在映射文件中设置dynamic-update=“true”，默认是false。这个功能用手工很难完成。

七、对象识别

对数据库而言，其识别一条记录唯一性的方式是根据主键值，如果手上有两条记录，它们拥有同样的主键值，则它们在数据库中代表同一个字段的记录。

对Java而言，要识别两个对象是否为同一个对象有两种方式

内存地址识别(“= =”号识别)
根据equals()、hasCode()中的定义 (默认Object类中定义的equals(Object o)方法也是按内存地址来比较的),源码如下： public boolean equals(Object obj){ return (this==obj); }

一、Query（查询）

拷贝工程Hibernate2，修改工程名为hibernate3ManageObjects.
单独测试一些方法（不使用main函数）:单元测试
扩展一个类TestCase,导包import TestCase（junit.framework）

单独写一个方法testSaveUser() ，拷贝如下代码到方法里面

SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}

测试Save()方法，右键-RunAs -JUnit Test

再插入一条

testSaveUser()

package cn.hrbust.dao;import java.sql.Date;import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;import cn.hrbust.pojo.User;
import junit.framework.TestCase;public class manageUser extends TestCase{//保存用户对象public void testSaveUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//      u.setName("李四");
//      u.setGender("男");
//      u.setAge(21);
//      u.setBirthday(Date.valueOf("2001-1-1"));
//
//      u.setName("赵楠");
//      u.setGender("女");
//      u.setAge(2);
//      u.setBirthday(Date.valueOf("2002-6-17"));
//  u.setName("李洋洋");u.setGender("女");u.setAge(20);u.setBirthday(Date.valueOf("1999-8-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}public static void main (String[] args){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}}

测试query方法，右键testQueryUser()，RunAs -JUnit Test;

//面向对象的方式去获取集合元素
       for(int i=0; i<users.size(); i++){
               User u=users.get(i);
               System.out.println(u.getName()+" "+u.getAge());
}

testQueryUser()

package cn.hrbust.dao;
import java.sql.Date;
import java.util.List;import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;import cn.hrbust.pojo.User;
import junit.framework.TestCase;public class manageUser extends TestCase{//查询用户对象public void testQueryUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例    ts=session.beginTransaction(); //开启事务Query query=session.createQuery("from User");List<User> users=query.list();     for(int i=0; i<users.size(); i++){User u=users.get(i);System.out.println(u.getName()+" "+u.getAge());}ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//保存用户对象public void testSaveUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//      u.setName("李四");
//      u.setGender("男");
//      u.setAge(21);
//      u.setBirthday(Date.valueOf("2001-1-1"));
//
//      u.setName("赵楠");
//      u.setGender("女");
//      u.setAge(2);
//      u.setBirthday(Date.valueOf("2002-6-17"));
//  u.setName("李洋洋");u.setGender("女");u.setAge(20);u.setBirthday(Date.valueOf("1999-8-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}public static void main (String[] args){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}}

//访问集合元素，还可以用以下的方式： users集合
       for(User u :users){
           System.out.println(u.getName()+" "+u.getAge());
       }

测试 query方法

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;import cn.hrbust.pojo.User;
import junit.framework.TestCase;public class manageUser extends TestCase{//查询用户对象public void testQueryUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例    ts=session.beginTransaction(); //开启事务Query query=session.createQuery("from User");List<User> users=query.list(); //访问集合元素，还可以用以下的方式         ： users集合for(User u :users){System.out.println(u.getName()+" "+u.getAge());}//面向对象的方式去获取    /*for(int i=0; i<users.size(); i++){ User u=users.get(i);System.out.println(u.getName()+" "+u.getAge());}*/ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//保存用户对象public void testSaveUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//      u.setName("李四");
//      u.setGender("男");
//      u.setAge(21);
//      u.setBirthday(Date.valueOf("2001-1-1"));
//
//      u.setName("赵楠");
//      u.setGender("女");
//      u.setAge(2);
//      u.setBirthday(Date.valueOf("2002-6-17"));
//  u.setName("李洋洋");u.setGender("女");u.setAge(20);u.setBirthday(Date.valueOf("1999-8-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}public static void main (String[] args){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}}

二、Java对象在Hibernate下的状态（临时/瞬间，持久，托管）

（1）u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送 SQL 语句

u.setName("周青山"); //只有insert，不会update

测试Save()方法，右键-RunAs -JUnit Test

（2）u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句

u.setName("董慧堂木");

事务提交后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句

（3）托管对象，testDetachedObjectUser()，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录

测试 testDetachedObjectUser()

testQueryUser()查看

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;import cn.hrbust.pojo.User;
import junit.framework.TestCase;public class manageUser extends TestCase{//查询用户对象public void testQueryUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例    ts=session.beginTransaction(); //开启事务Query query=session.createQuery("from User");List<User> users=query.list(); //访问集合元素，还可以用以下的方式         ： users集合for(User u :users){System.out.println(u.getName()+" "+u.getAge());}//面向对象的方式去获取    /*for(int i=0; i<users.size(); i++){ User u=users.get(i);System.out.println(u.getName()+" "+u.getAge());}*/ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//托管对象public void testDetachedObjectUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//          u.setName("李四");
//          u.setGender("男");
//          u.setAge(21);
//          u.setBirthday(Date.valueOf("2001-1-1"));
//
//          u.setName("赵楠");
//          u.setGender("女");
//          u.setAge(2);
//          u.setBirthday(Date.valueOf("2002-6-17"));//           u.setName("李洋洋");
//          u.setGender("女");
//          u.setAge(20);
//          u.setBirthday(Date.valueOf("1999-8-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}//此时为托管对象，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录u.setName("谭苏"); //事务提交 后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句u.setAge(90);try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//                session.update(u);session.saveOrUpdate(u);ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//保存用户对象public void testSaveUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//      u.setName("李四");
//      u.setGender("男");
//      u.setAge(21);
//      u.setBirthday(Date.valueOf("2001-1-1"));
//
//      u.setName("赵楠");
//      u.setGender("女");
//      u.setAge(2);
//      u.setBirthday(Date.valueOf("2002-6-17"));
//  u.setName("李洋洋");u.setGender("女");u.setAge(20);u.setBirthday(Date.valueOf("1999-8-27"));//u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送SQL语句u.setName("周青山"); //只有insert，不会updatetry {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库//u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句//u.setName("董慧堂木");  //属性改变，持久化对象的属性变化会发送update语句ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user updateu.setName("董慧堂木");} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}public static void main (String[] args){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}}

三、Session相关方法

（1）get方法：查询一个对象

测试testGetUser()，对象标识是1的可以得到

User u=session.get(User.class, 1);
System.out.println(u.getName()+" "+u.getAge());

当前线程全部会更新

查询

//查询一个对象public void testGetUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 2);System.out.println(u.getName()+" "+u.getAge());u.setName("穆婷婷");u.setAge(29);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

（2）方法：删除一个对象

User u=session.get(User.class, 3);
       //get之后，u:是持久化对象。

       session.delete(u);
       //u:瞬时对象，准确来说是删除对象

       u.setName("方婷婷");
       u.setAge(20);

未删除前查询（刚才测试已经删除了第一个：蒋依依，这一步自行操作getUser 把第二个：赵楠变成穆婷婷）

删除第三个：方婷婷

查询

testQueryUser()这里稍作更改可以看到序号

for(User u :users){
System.out.println(u.getId()+" "+u.getName()+" "+u.getAge());
}

删除完成。

//删除一个对象public void testDeleteUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 3);//get之后，u:是持久化对象。session.delete(u);//u:瞬时对象，准确来说是删除对象u.setName("方婷婷");u.setAge(20);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{//sf.close();}}

(3)evict

调用evict

session.evict(u); //把对象脱离当前session的管理

//evict对象public void testEvictUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 2);System.out.println(u.getName()+" "+u.getAge());session.evict(u); //把对象脱离当前session的管理u.setName("赵汉涵");u.setAge(28);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

四、session的缓存

充当蓄水池的作用，减少程序访问数据库的次数。

getUser（）

User u=session.get(User.class, 2);

User u1=session.get(User.class, 2);

可以直接从session获得，不用再次访问数据库

User u=session.get(User.class, 2);
User u1=session.get(User.class, 4);

//查询一个对象public void testGetUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 2);User u1=session.get(User.class, 4);System.out.println(u.getName()+" "+u.getAge());u.setName("穆婷婷");u.setAge(29);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

Session相关方法

（4）update（）方法

testUpdateUser()

u.setName("李洋洋");
u.setName("杨丽丽");
u.setAge(40);

只发送一次update语句

查询

更新一个持久化对象，名字不发生变化，不会发送update() 。

//更新一个持久化对象public void testUpdateUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 6);System.out.println(u.getName()+" "+u.getAge());//          u.setName("李洋洋");u.setName("杨丽丽");
//
//          u.setAge(40);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

更新一个托管对象

查看

 //更新一个托管对象public void testUpdateDetachedUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; User u=null;try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u=session.get(User.class, 6);System.out.println(u.getName()+" "+u.getAge());session.update(u);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}//u:托管对象u.setName("杨力");try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.update(u);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}}

托管时不进行操作，还是会update

user.hbm.xml 里面添加 select-before-update="true"

<class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true">

user.hbm.xml


<?xml version="1.0"?>
<!--~ Hibernate, Relational Persistence for Idiomatic Java~~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.-->
<!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping><class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true"><id name="id"  column="id"><generator class="identity"/>          </id><property name="name" column="username"/><property name="gender" column="sex"/><property name="age" /> <property name="birthday" column="borndate"/></class></hibernate-mapping>

再次执行 testUpdateDetachedUser(),不再发送update；

（5）Get(）方法和Load（）方法

testGetAndLoadUser()： get和load的区别；

先查询一下

get方法立即加载

数据库里面没有id值为1的对象了；

get方法，找一个没有的对象，run as->JUnit Test,报错：NullPointerException 空指针异常；

判断一下是否为空，再执行；

Load方法延时加载

断点标记如图

testGetAndLoadUser()->Debug As ->2 JUnit Test

点击上边框run->Step Over(重复此操作可以看得到get 和 load 出现）

点击上边框run->Step Over

点击run-> terminate结束;

get返回具体对象；load返回代理对象，使用时才把u1相关值给出来；

load方法，找一个没有的对象，run as->JUnit Test,报错：ObjectNotFoundException

//get和load的区别
public void testGetAndLoadUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式       session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); System.out.println("get方法加载对象");if(u!=null){//u:持久化对象     System.out.println(u.getName()+" "+u.getAge());//NullPointerException：对象不存在，不能再调用对象的方法}//          Load方法延时加载User u1=session.load(User.class, 1); System.out.println("load方法加载对象");System.out.println(u1.getName()+" "+u1.getAge());ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

五、一个Session中不能同时存在两个ID相同的持久化对象

testTwoObjectsWithSameIdInOneSession()

创建 u1,纳入session管理，报错：NonUniqueObjectException: A different object with the same identifier value was already associated with the session

解决方法：

先清除 session之前的对象u，实际上就是session不在管理这个u了再执行 runas ->JUnit Test

session.evict(u);

第二个select：因为配置了select-before-update

不是insert，而是update：u1是瞬时对象一定发insert，托管对象一定要发update；

因为有ID而且和数据库里面的主键是对应的，而且在数据库里面有记录，这两点保证u1是托管对象，所以发update

//session中不能同时存在两个有相同持久化标识的对象public void testTwoObjectsWithSameIdInOneSession(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); //session中存在了oid是2的对象session.evict(u);  //先把u从session中清除User u1=new User(); //u1是托管对象u1.setId(2);u1.setAge(30);u1.setName("赵兵");session.saveOrUpdate(u1);ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

六、与数据库的同步

1.动态更新

testUpdateObjectsWithDynamicUpdate()

testUpdateObjectsWithDynamicUpdate()->runas->JUnit Test; 更改名字的同时，所有属性都在发生改变

查看

只更改改变的属性，需要在ORM映射文件user.hbm.xml里面设置dynamic-update=“true”

user.hbm.xml

<?xml version="1.0"?>
<!--~ Hibernate, Relational Persistence for Idiomatic Java~~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.-->
<!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping><class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true" dynamic-update="true"><id name="id"  column="id"><generator class="identity"/>          </id><property name="name" column="username"/><property name="gender" column="sex"/><property name="age" /> <property name="birthday" column="borndate"/></class></hibernate-mapping>

再 testUpdateObjectsWithDynamicUpdate()->runas->JUnit Test;

查看

//动态更新public void testUpdateObjectsWithDynamicUpdate(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); System.out.println(u.getName()+" "+u.getAge());u.setName("徐福记");ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

七、对象识别

例子1：

Session session = sessions.openSession();

Person p1 = (Person)session.get(Person.class,1);

Person p2 =(Person)session.get(Person.class,1);

session.close(); System.out.println(p1 = = p2);

显示：true

例子2：

Session session1 = sessions.openSession();

Person p1 = (Person)session.get(Person.class,1);

session1.close(); Session session2 = sessions.openSession();

Person p2 = (Person)session.get(Person.class,1); 、

session2.close();

System.out.println(p1 == p2);

显示：false

1.String对象识别testStringObjectIndentify()

User u1=session.get(User.class, 2);
User u2=session.get(User.class, 2);
System.out.println(u1==u2); //同一个session引用相同

//String对象识别public void testStringObjectIndentify(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u1=session.get(User.class, 2);User u2=session.get(User.class, 2);System.out.println(u1==u2);//同一个session引用相同ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}

2.User对象识别testUserObjectIndentify()

//User对象识别public void testUserObjectIndentify(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; User u1=null,u2=null;try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u1=session.get(User.class, 2);
//                  User u2=session.get(User.class, 2);
//                  System.out.println(u1==u2);ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u2=session.get(User.class, 2); ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}System.out.println(u1==u2);System.out.println(u1.equals(u2));}

使用==来比较两个对象的记录是否代表数据库中的同一条记录是不可行的。如果您要有必要比较通过查询后两个对象的内容是否相同，必须重写 equals()与hashCode()。

重写方法之一，equals()与hashCode()的方法是根据数据库的identity，就是透过getId()方法取得对象的id值并加以比较。

添加如下代码到User.java

public boolean equals(Object obj){
       if(this==obj){
           return true;
       }
       if(obj==null){
           return false;
       }
       if(!(obj instanceof User)){
           return false;
       }

       User other=(User)obj; //强制转换
       if(id!=other.id){
           return false;
       }
       if(age!=other.age){
           return false;
       }

       if(!name.equals(other.name)){
           return false;
       }
  if(gender!=null && (other.gender!=null)){
           if(!gender.equals(other.birthday)){
               return false;
           }
       }
       if(!birthday.equals(other.birthday)){
           return false;
       }
       return true;
   }

public int hashCode() {
       int result;
       result = getName ().hashCode();
       result = 29 * result + getBirthday().hashCode();
       result = 29 * result + getAge();
       return result;
       }

User.java

package cn.hrbust.pojo;import java.sql.Date;public class User {private int id;   private String name;private String gender;int age;Date birthday;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getGender() {return gender;}if(gender!=null && (other.gender!=null)){if(!gender.equals(other.birthday)){return false;}}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}public boolean equals(Object obj){if(this==obj){return true;}if(obj==null){return false;}if(!(obj instanceof User)){return false;}User other=(User)obj;  //强制转换if(id!=other.id){return false;}if(age!=other.age){return false;}if(!name.equals(other.name)){return false;}if(!gender.equals(other.gender)){return false;}if(!birthday.equals(other.birthday)){return false;}return true;}public int hashCode() {        int result;        result = getName ().hashCode();        result = 29 * result + getBirthday().hashCode();    result = 29 * result + getAge();return result;    }}

再执行testUserObjectIndentify

//User对象识别public void testUserObjectIndentify(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; User u1=null,u2=null;try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u1=session.get(User.class, 4);
//                  User u2=session.get(User.class, 2);
//                  System.out.println(u1==u2);ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u2=session.get(User.class, 4); ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}System.out.println(u1==u2);System.out.println(u1.equals(u2));}

manageUser.java

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;import cn.hrbust.pojo.User;
import junit.framework.TestCase;public class manageUser extends TestCase{//User对象识别public void testUserObjectIndentify(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; User u1=null,u2=null;try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u1=session.get(User.class, 4);
//                  User u2=session.get(User.class, 2);
//                  System.out.println(u1==u2);ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u2=session.get(User.class, 4); ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//                  sf.close();}System.out.println(u1==u2);System.out.println(u1.equals(u2));}//String对象识别public void testStringObjectIndentify(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u1=session.get(User.class, 2);User u2=session.get(User.class, 2);System.out.println(u1==u2);//同一个session引用相同ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//动态更新public void testUpdateObjectsWithDynamicUpdate(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); System.out.println(u.getName()+" "+u.getAge());u.setName("徐福记");ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//session中不能同时存在两个有相同持久化标识的对象public void testTwoObjectsWithSameIdInOneSession(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); //session中存在了oid是2的对象session.evict(u);  //先把u从session中清除User u1=new User(); //u1是托管对象u1.setId(2);u1.setAge(30);u1.setName("赵兵");session.saveOrUpdate(u1);ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//get和load的区别public void testGetAndLoadUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//get立即加载User u=session.get(User.class, 2); System.out.println("get方法加载对象");if(u!=null){//u:持久化对象     System.out.println(u.getName()+" "+u.getAge());//NullPointerException：对象不存在，不能再调用对象的方法}//          Load方法延时加载User u1=session.load(User.class, 1); System.out.println("load方法加载对象");System.out.println(u1.getName()+" "+u1.getAge());ts.commit();} catch (Exception e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//删除一个对象public void testDeleteUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 3);//get之后，u:是持久化对象。session.delete(u);//u:瞬时对象，准确来说是删除对象u.setName("方婷婷");u.setAge(20);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{//sf.close();}}//evict对象public void testEvictUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 2);System.out.println(u.getName()+" "+u.getAge());session.evict(u); //把对象脱离当前session的管理u.setName("赵汉涵");u.setAge(28);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//更新一个持久化对象public void testUpdateUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 6);System.out.println(u.getName()+" "+u.getAge());//          u.setName("李洋洋");u.setName("杨丽丽");
//
//          u.setAge(40);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//更新一个托管对象public void testUpdateDetachedUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; User u=null;try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式        session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务u=session.get(User.class, 6);System.out.println(u.getName()+" "+u.getAge());session.update(u);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}//u:托管对象
//          u.setName("杨力");try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.update(u);   //当托管对象在托管期间没有变化//由于配置了select-before-update属性，所以hibernate会先发一条sql语句，//然后看一下对象状态是否真的发生变化，再决定是否更新ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}}//查询一个对象public void testGetUser(){Configuration cfg=null;SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务User u=session.get(User.class, 2);User u1=session.get(User.class, 4);//u:持久化对象      System.out.println(u.getName()+" "+u.getAge());u.setName("穆婷婷");u.setAge(29);ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//查询用户对象public void testQueryUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例    ts=session.beginTransaction(); //开启事务Query query=session.createQuery("from User");List<User> users=query.list(); //访问集合元素，还可以用以下的方式         ： users集合for(User u :users){System.out.println(u.getId()+" "+u.getName()+" "+u.getAge());}//面向对象的方式去获取    /*for(int i=0; i<users.size(); i++){ User u=users.get(i);System.out.println(u.getName()+" "+u.getAge());}*/ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//托管对象public void testDetachedObjectUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//          u.setName("李四");
//          u.setGender("男");
//          u.setAge(21);
//          u.setBirthday(Date.valueOf("2001-1-1"));
//
//          u.setName("赵楠");
//          u.setGender("女");
//          u.setAge(2);
//          u.setBirthday(Date.valueOf("2002-6-17"));//           u.setName("李洋洋");
//          u.setGender("女");
//          u.setAge(20);
//          u.setBirthday(Date.valueOf("1999-8-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{
//              sf.close();}//此时为托管对象，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录u.setName("谭苏"); //事务提交 后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句u.setAge(90);try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务//                session.update(u);session.saveOrUpdate(u);ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}//保存用户对象public void testSaveUser(){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();
//      u.setName("李四");
//      u.setGender("男");
//      u.setAge(21);
//      u.setBirthday(Date.valueOf("2001-1-1"));
//
//      u.setName("赵楠");
//      u.setGender("女");
//      u.setAge(2);
//      u.setBirthday(Date.valueOf("2002-6-17"));
//  u.setName("李洋洋");u.setGender("女");u.setAge(20);u.setBirthday(Date.valueOf("1999-8-27"));//u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送SQL语句u.setName("周青山"); //只有insert，不会updatetry {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式      session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库//u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句//u.setName("董慧堂木");  //属性改变，持久化对象的属性变化会发送update语句ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user updateu.setName("董慧堂木");} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}public static void main (String[] args){SessionFactory sf=null;Session session=null;Transaction ts=null; User u=new User();u.setName("李四");u.setGender("男");u.setAge(21);u.setBirthday(Date.valueOf("2001-1-1"));u.setName("赵楠");u.setGender("女");u.setAge(2);u.setBirthday(Date.valueOf("2002-6-17"));
//
//      u.setName("方婷婷");
//      u.setGender("女");
//      u.setAge(20);
//      u.setBirthday(Date.valueOf("2002-9-27"));try {sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式     session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例ts=session.beginTransaction(); //开启事务session.save(u);//不开事务，不能保存到数据库ts.commit();} catch (HibernateException e) {  //捕获异常// TODO Auto-generated catch blocke.printStackTrace();//异常：回滚if(ts!=null){ts.rollback();}}finally{sf.close();}}}

至此，完成。

2021-06-04 Java对象在Hibernate下的4种状态和Session相关方法以及对象识别相关推荐

对象在Hibernate中的三种状态
Hibernate中的对象有3种状态:Transient(瞬时),Persistent(持久)和Detached(托管). 1 瞬时状态: 由new命令开辟内存空间的java对象,例如Student ...
hibernate实体的几种状态
http://fojian.iteye.com/blog/420141 hibernate实体的几种状态: 实体的生命周期中,实体主要经过瞬时(Transient),托管(Attatched或Mana ...
hibernate实体的几种状态:
hibernate实体的几种状态: 实体的生命周期中,实体主要经过瞬时(Transient),托管(Attatched或Managed),游离(Detached)和销毁(Removed)四个状态. 瞬 ...
对象头、锁的四种状态、Java和处理器实现原子操作的方式（CAS、锁机制；总线锁定、缓存锁定）
1.对象头 Java对象头里的Mark Word里默认存储对象的HashCode.分代年龄和锁标记位. 32位JVM的Mark Word的默认存储结构如下图所示: 在运行期间,Mark Word里存储 ...
JAVA线程的生命周期以及5种状态转换
一:线程的生命周期新建状态(NEW):新创建一个线程对象. 就绪状态(RUNNABLE):线程对象创建后,调用该对象的start()方法.该状态的线程等待被线程调度选中,获取CPU的使用权. 运行状 ...
Java线程池--线程池的五种状态
线程池的5种状态:Running.ShutDown.Stop.Tidying.Terminated. 线程池各个状态切换框架图: 1.RUNNING (1) 状态说明:线程池处在RUNNING状态时, ...
图解Hibernate中的三种状态(瞬时态,持久态,游离态|托管态)
注: 1. 瞬时态转化为持久态时,调用save()方法主要是给瞬时态对象赋值id并把该对象保存到session缓存中 2. 持久态转换为游离态主要是把在session缓存中的对象从session ...
2021最新整理JAVA常见面试题附答案
包含的模块: 本文分为十九个模块,分别是:Java 基础.容器.多线程.反射.对象拷贝.Java Web .异常.网络.设计模式.Spring/Spring MVC.Spring Boot/Sprin ...
java泛型怎么用反射生成_Java 之使用反射生成并操作对象
一.使用反射创建对象通过反射来生成对象有如下两种方式: 方式一: 使用 Class 对象的 newInstance() 方法来创建 Class 对象对应类的实例,这种方法要求该 Class 对象的对 ...

2021-06-04 Java对象在Hibernate下的4种状态和Session相关方法以及对象识别

2021-06-04 Java对象在Hibernate下的4种状态和Session相关方法以及对象识别相关推荐

最新文章

热门文章