(3)hibernate的三种状态

瞬时状态(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);
		}
	}