Hibernate基于配置文件（2）内存中实体类对象的状态
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所管理
}
}
}