(3)hibernate的三种状态

刺骨的言语ヽ痛彻心扉 2022-05-09 09:24 243阅读 0赞

瞬时状态(transient):刚new出来的对象就属于瞬时状态

持久化状态(persistent):对象存进数据库，被session所管理就是持久化状态

离线状态(detached):数据库有，但是没有被session管理就是离线状态

**1.test01:**

void test01() {
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			User u=new User();
    			u.setNickname("李四");
    			u.setBorn(new Date());
    			u.setPassword("123");
    			u.setUsername("ls");
    			session.save(u);
    			u.setUsername("ls-test");
    			session.getTransaction().commit();//
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当执行save后,u就是持久化状态了，同时存在session的缓存中，当执行commit时，会把当前对象与缓存对象进行比较，如果不同则自动update

**2.test02:**

void test02() {
    		Session session=null;
    		try {
    			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			User u=new User();
    			u.setNickname("李四");
    			u.setBorn(new Date());
    			u.setPassword("123");
    			u.setUsername("ls");
    			session.save(u);
    			u.setUsername("ls-test");
    			session.save(u);//该语句没有意义
    			u.setPassword("1234");
    			session.update(u);//该语句没有意义
    			u.setBorn(sdf.parse("1977-01-14"));
    			session.update(u);//该语句没有意义
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当对象是持久化状态时，进行save或update都无效，都不会发sql语句，只有当commit时，才会把session中缓存的对象与当前对象比较，不同则更新

**3.test03:**

void test03() {
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			User u=(User)session.load(User.class, 7);
    			u.setPassword("12345");
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当执行load时，如果数据库有该对象，则该对象变为持久化状态（因为执行load后，对象就被session所管理）

**4.test04:**

void test04() {
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			User u=(User)session.load(User.class, 7);
    			u.setPassword("12345");
    			session.clear();
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当使用clear后，session中缓存的对象就没了，此时commit就不会自动更新对象了，所以该代码只发一条select的sql语句

**5.test05:**

void test05() {
    		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    			User u=new User();
    			u.setId(7);//数据库有id为7的对象,但是没有被session管理,所以是该对象属于离线状态
    			//怎么把该对象变为持久化状态呢,我们可以用save或者update，但是用save的话，数据库会多一条id不同对象相同的数据，所以用update比较合适
    			session.update(u);
    			u.setNickname("test-nick"); //补全对象属性
    			u.setBorn(sdf.parse("1980-05-05")); //补全对象属性
    			u.setPassword("123456"); //补全对象属性
    			u.setUsername("TEST"); //补全对象属性
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当数据库用，但是没有被session管理（离线状态）,可以使用update使它成为持久化状态，此时缓存的对象就只有id，如果不把其他属性进行set，则数据不全

**6.test06:**

void test06() {
    		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    			User u=new User();
    			u.setId(7);//数据库有id为7的对象,但是没有被session管理,所以是该对象属于离线状态
    			//怎么把该对象变为持久化状态呢,我们可以用save或者update，都是用save的话，数据库会多一条id不同对象相同的数据，所以用update比较合适
    			session.update(u);
    			u.setNickname("test-nick"); 
    			u.setBorn(sdf.parse("1980-05-05"));
    			u.setPassword("123456");
    			u.setUsername("TEST");
    			u.setId(88);
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.当使用update使对象成为持久化状态时，不能再修改id，否则会报错

**7.test07:**

void test07() {
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    			User u=new User();
    			u.setId(7);
    			session.delete(u);//此时u没有被数据库管理,就是瞬时状态，此时进行set无效，所以只有一条删除的sql语句
    			u.setNickname("TEST");
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

**8.test08:**

@Test
    	void test08() {
    		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    			User u=new User();
    			
    			u.setNickname("test-nick"); 
    			u.setBorn(sdf.parse("1980-05-05"));
    			u.setPassword("123456");
    			u.setUsername("TEST");
    			session.saveOrUpdate(u);/*如果对象有设置id,则该对象会假设为离线状态，就会使用update进行持久化，
    			如果对象没有设置id,则该对象会假设为瞬时状态，就会使用save进行持久化
    			*/
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

**9.test09:**

void test09() {
    		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    		User u1=session.load(User.class, 3);
    		System.out.println(u1.toString());//u1已经是持久化状态了
    		User u2=new User();
    		u2.setBorn(sdf.parse("1888-04-04"));
    		u2.setId(3);//u2是离线状态
    		
    		session.saveOrUpdate(u2);//u2是持久化状态了
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}

注意:（1）.u1的id为3，u2的id也是3，session中不能存在对一个持久化对象的双重copy，否则会报错

**10.test10:**

@Test
    	void test07() {
    		Session session=null;
    		try {
    			session=HibernateUtil.getSession();
    			session.beginTransaction();
    			
    		User u1=session.load(User.class, 3);
    
    		User u2=new User();
    		u2.setBorn(sdf.parse("1888-04-04"));
    		u2.setId(3);
    		
    		session.merge(u2);//merge之前会判断session中是否有同一对象,如果存在将两个对象合并
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    			session.getTransaction().rollback();
    		}finally {
    			HibernateUtil.closeSession(session);
    		}
    	}