hibernate持久化类以及相互转化

持久化类的三种状态

持久化类：
定义： 持久化类： javaBean + 和底层数据库表创建了映射关系：
特点：
(1)无参数构造器： 底层通过反射， 创建实体bean
(2)提供属性， 属性提供get set方法：
(3)必须Serializable接口：
(4)实体类当中必须同一个OID ：
总结： java 当中通过地址值：
数据库：主键：
Hibernate： OID
(5) 不能使用final修饰：
(6) 属性尽量使用包装字段：

Hibernate是持久层框架， 通过持久化类完成ORM操作。 Hibernate为了更好的管理持久化类， 将持久化类分为三个状态。
持久化类 = java类 + 映射：

1：瞬时态
一般对象刚创建出来的时候的状态
这种对象没有唯一的OID，没有被session管理， 称之为瞬时态对象。
2：持久态
对象被保存后的状态
这种对象有唯一的表示OID，被session管理，称之为持久化对象。
持久化类的持久态的对象， 可以自动更新数据库。
3：托管态
session关闭之后的对象的状态
这种对象具有唯一的OID，没有被session管理，称之为托管态对象。
1.4.1.4：代码演示对象的几个状态
/*

• 测试持久化类对象的三个状态：
  */
  public class TestDemo02 {

  public static void main(String[] args) {
  Session session = HibernateUtils.openSession();
  Transaction tx = session.beginTransaction();

   Customer cus = new Customer();//瞬时状态， 没有唯一的OID， 没有被session管理：
   cus.setCust_name("毕从明");
   
   Serializable save = session.save(cus);//持久态对象， 具有唯一的表示OID， 同时也被session管理：
   System.out.println(save);//添加操作： 返回是当前对象的id的值： 
   
   tx.commit();
   
   session.close();
   System.out.println(cus.getCust_name());// 托管状态， 有唯一的OID，没有被session管理。  session已经被关闭了
  

  }

}

package com.yidongxueyuan;

import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yidongxueyuan.domain.Customer;
import com.yidongxueyuan.utils.HibernateUtils;

public class TestSession {
	// session.sava();
	//保存： 
	
	
	//展示对象的三个状态： 
	@Test
	public void testName() throws Exception {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		//演示三个状态：
		/*
		 * 
		 * 1: 改对象刚刚被初始化： 
		 *  没有oid ： 
		 *  没有被session管理： 
		 */
		
		//瞬时态： 
		Customer customer = new Customer();	
		customer.setCust_name("王导演");
		
		
		//持久态： 
		/*
		 *  oid ： 
		 *  已经被session管理： 
		 *  能够自动更新数据库：  
		 */
		Serializable id = session.save(customer);
		
		
		/*
		 * 托管：游离态
		 * 
		 * 具有oid ：
		 * 但是不被session管理：  
		 */
		Customer cust02 = new Customer(); 
		cust02.setCust_id(1002);//具有oid  没有被session 管理： 托管态： 
		
		
	
		
		tx.commit();
		session.close();
		
		System.out.println(customer.getCust_name());//customer 这个对象是一个游离态： 
	}
	
	// 持久态没有调用update 能够自动更新数据库： 
	@Test
	public void testName2() throws Exception {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		//演示三个状态：
	    Customer customer = session.get(Customer.class, 1L);
	    customer.getCust_id();
	    customer.setCust_name("fghdj");
	
	    
	    /*
	     * 只有事务的提交， 没有使用session.update方法， 同样对象能够被修改。 
	     * 特点： 持久态对象能够自动更新数据库：  
	     * 原因： 
	     *  1： Session 的以及缓存： 
	     *  2： 快照区： 
	     */
	
		
		tx.commit();
		session.close();
	}
	
	
	/*
	 * 持久态转换成其他的状态： 
	 */
	@Test
	public void testName3() throws Exception {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		

		 /*
		  * 获得持久态的方法;  通过session对象从数据库当中查询出来的对象就是一个持久态对象： 
		  * get();   
		  * load(); 
		  * find(); 
		  * iterator()... 
		  * 
		  */
		
		//获得了了持久态： 
		Customer customer = session.get(Customer.class, 2L);
		
		
		//转换成瞬时态： 
//		session.delete(customer);	
		
	
		/*
		 * 转换成游离态： 
		 * 方式一： session.close方法： 
		 * 方式二： session.evict(obj); 
		 * 方式三; session.clear(); 
		 */
		session.clear();
		
		session.evict(customer);
		System.out.println(customer.getCust_name());//游离态： 
		
	
		tx.commit();
		session.close();
		
		
		//方式一： session关闭： 
//		System.out.println(customer.getCust_name());//游离态： 
		
	}
	
	
	/*
	 * 游离态转换成 持久态： 
	 */
	@Test
	public void testName4() throws Exception {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		

		
		//获得了了持久态： 
		Customer customer = session.get(Customer.class, 2L);
		session.clear();
		System.out.println(customer.getCust_name());//游离态： 
		
		
		//将游离态转换成持久态： 
		session.update(customer);
		session.saveOrUpdate(customer);
//		session.lock(customer, lockmodel );
	
		tx.commit();
		session.close();
		
		
		
	}

	
	
}

各个时态之间的获得以及转换（了解）：

（代码在上面那个里面）
瞬时态对象
获得： Customer cust = new Customer();
状态转换：
瞬时—>持久： sava(Object obj) savaOrUpdate(Object obj)
瞬时—>托管： cus.setCust_id(1);
持久态对象
获得： get() , load() find(), iterate();
状态转换：
持久---->瞬时： delete
持久---->托管： close() ， clear(), evict(Object obj);
托管态对象
获得： Customer cus =new Customer();
Cus.setCus_Id();
状态转换：

托管---->持久： update() savaOrUpdate(); 在第一天的修改方法。和保存方法当中可以解释，从对象的角度来分析：
托管—>瞬时： cus.setCst_id(null);
1.4.3：持久态对象的特征：
1.4.3.1：持久化类持久态对象自动更新数据库：
/*
* 演示： 持久化类持久态对象能够自动更新数据库：
*/
@Test
public void testName() throws Exception {
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();

	//===========
	//1；获得一个持久态对象： get();
	Customer customer = session.get(Customer.class, 1L);
	customer.setCust_name("haha");
	
	//2：之前需要调用update();更新数据库当中的内容：
	//现在不需要调用update，数据库当中数据也会被我修改：在这儿加断点， 测试效果。
	//原因： 持久化状态，会自动修改数据库。 当修改的语句和数据库完全一致， 不发送sql 语句，很智能。 
	//底层： 依赖了Hibernate底层的一级缓存。 
	tx.commit();
	session.close();
}