Hibernate基于配置文件（二）内存中实体类对象的状态

持久化对象的三种状态

*瞬时状态
  -刚被new出来，尚未session.save()
 
*持久化状态
  -必定会有数据库标识值
  -被session所管理的对象就是持久化对象，也就是处于持久化状态
  -处于持久化状态的对象，其状态值(被映射的那些属性值)将自动与数据库同步
      -(对象状态值有改变，则hibernate自动发出update语句，没有变化，即使显示调用session.update()，也不会发出update语句)

*离线状态
  -必定会有数据库标识值
  -不被session管理
  -当一个持久化对象对应的session被关闭之后，就变为了离线对象
 
*save方法用于将对象从瞬时状态转为持久化状态！save方法只用于转变瞬时状态到持久化状态！
*update方法的作用：将离线状态-->持久化状态

 

Hibernate的save()被调用，保存1个对象，发出insert语句，不代表数据此时能被查询到！

当且仅当commit()成功执行后，save()所保存的对象才会被查询到！！！

防止脏读！

 

===========================================================================

 

Hibernate配置文件

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>

		<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		

		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		
	
		<property name="show_sql">true</property>
		
		<!-- create-drop 测试用，用完即删 -->
		<!-- create 如果没有则创建，有则替换 -->
		<!-- validate 校验，如果没有表，则报错 -->
		<!-- update，没有则创建，有且数据有变化，则更新，没有则什么都不做 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		
		<mapping resource="org/leadfar/hibernate/model/User.hbm.xml"></mapping>
		
	</session-factory>
</hibernate-configuration>

 

实体类

package org.leadfar.hibernate.model;
import java.util.Date;


public class User {
	private int id;
	private String name;
	private int age;
	private boolean sex;
	private Date birthday;
	private double money;
	

	User() {}

	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 int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public boolean isSex() {
		return sex;
	}

	public void setSex(boolean sex) {
		this.sex = sex;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public double getMoney() {
		return money;
	}

	public void setMoney(double money) {
		this.money = money;
	}
	
	
}

 

实体类配置文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping 
	package="org.hibernate.auction">

	<class name="org.leadfar.hibernate.model.User" table="t_user" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		<property name="age"/>
		<property name="sex"/>
		<property name="birthday"/>
		<property name="money"/>
		
		
	</class>
	
</hibernate-mapping>

 

测试

package org.leadfar.hibernate.model;

import java.util.Date;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class UserTest02 extends TestCase {
	
	//对象的三种状态/////////////////////
	public void testUser_01() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			//创建实体对象
			User user = new User();//此时User对象处于Transient(瞬时)状态
			user.setName("张三");
			user.setAge(20);
			user.setSex(false);
			user.setBirthday(new Date());
			user.setMoney(99999.99);
			
			//保存对象
			session.save(user);//user对象在session.save()调用后,就处于Persistent(持久)状态,虽然发出了insert语句，但此时无法查询到数据
			
			//提交事务
			session.getTransaction().commit();//只有commit成功后，数据才会被查询到！防止脏读！
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	
	//持久化对象，只要状态有变化，不用显示update/save，只要commit，就会与数据库同步
	//已经是持久化对象了，save用不用没关系！因为save的作用是将瞬时对象转换为持久化对象
	public void testUser_02() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			User u = (User)session.get(User.class, 100);//离线状态被get出来，变为持久化状态
			u.setName("张三");//user的状态只要发生变化，在事务提交的时候，hibernate将自动将状态同步到数据库
			
			//session.save(u);// 对于持久化状态，无需save
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//处于持久化状态的对象，状态值的改变会在commit之后由hibernate自动发出update语句！
	public void testUser_03() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			User u = (User)session.get(User.class, 205);
			u.setMoney(10.0);//user状态没有变化，即使update，hibernate也不会发出update语句
			
			//因为user对象处于持久化状态，在属性值改变之后，会自动同步到数据库
			//在没有commit之前，其它事务中是无法观察到变化后的值--防止脏读
			//只有commit之后，数据才会真正存储到数据库
			
			//提交事务
			session.getTransaction().commit();//update语句在commit之后才会被hibernate发出！！！
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//状态值没改变，即使调用了update，hibernate也不会发出update语句！
	public void testUser_04() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			//创建实体对象
			User user = (User)session.get(User.class, 100);//hibernate发出select语句
			user.setName("李四");
			
			//显示调用update，但是session.update()不等于update语句！因为不一定会发出！
			session.update(user);//持久化之后，没有发生状态变化，不会发出update语句
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//session.save()不一定会发出insert语句
	public void testUser_05() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			//创建实体对象
			User user = new User();//此时User对象处于Transient(瞬时)状态
			user.setName("王五");
			user.setAge(20);
			user.setSex(false);
			user.setBirthday(new Date());
			user.setMoney(99999.99);
			
			//保存对象
			session.save(user);//发出insert语句
			
			session.save(user);//此条save，hibernate不会发出insert语句！！！
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//瞬时状态被转换为持久状态后，属性值发生改变，则hibernate在事务提交后会自动发出update语句！
	public void testUser_06() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			//创建实体对象
			User user = new User();//此时User对象处于Transient(瞬时)状态
			user.setName("赵六");
			user.setAge(20);
			user.setSex(false);
			user.setBirthday(new Date());
			user.setMoney(99999.99);
			
			//保存对象
			session.save(user);//user对象在session.save()调用后,就处于Persistent(持久)状态，此时hibernate会发出insert语句
			
			
			user.setName("赵六2");
			
			//提交事务
			session.getTransaction().commit();//持久化之后，发生状态变化，事务提交后hibernate会自动发出update语句
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//使用update方法将离线状态对象转变为持久化状态
	public void testUser_07() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		//创建实体对象
		User user = new User();//此时User对象处于Transient(瞬时)状态
		user.setName("abc");
		user.setAge(20);
		user.setSex(false);
		user.setBirthday(new Date());
		user.setMoney(99999.99);
		
		try {
			//开启事务
			session.beginTransaction();
			
			//保存对象
			session.save(user);//user对象在session.save()调用后,就处于Persistent(持久)状态，此时hibernate会发出insert语句
			
			//提交事务
			session.getTransaction().commit();//持久化之后，发生状态变化，事务提交后hibernate会自动发出update语句
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();
			//session关闭之后，user对象处于离线Detached状态
			//user对象用户数据库标识，同时，不被session所管理
		}
		
		//上面的user对象已经处于离线状态
		Session session2 = sfactory.openSession();
		try {
			//开启事务
			session2.beginTransaction();
			
			//改变离线状态对象的属性值，不会发出update
			user.setName("xxx");
			
			//使用session.update()将离线对象转变为持久化状态的对象
			session2.update(user);
			user.setName("yyy");
			
			
			//提交事务
			session2.getTransaction().commit();//持久化之后，发生状态变化，事务提交后hibernate会自动发出update语句
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session2.getTransaction().rollback();
		} finally {
			//关闭session
			session2.close();
			//session关闭之后，user对象处于离线Detached状态
			//user对象用户数据库标识，同时，不被session所管理
		}
		
		
	}
}