Hibernate---对象的三种状态
简而言之，hibernate本就是面向对象的基于ORM的框架，位于dao层，对数据进行操作的框架。我就谈谈hibernate的对象的三种状态。他们分别为：游离，持久和瞬时。通过代码来详解一下吧。
hibernate.cgf.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- property 元素用于配置Hibernate中的属性
键:值
-->
<!-- hibernate.connection.driver_class : 连接数据库的驱动 -->
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- hibernate.connection.username : 连接数据库的用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- hibernate.connection.password : 连接数据库的密码 -->
<property name="hibernate.connection.password">root</property>
<!-- hibernate.connection.url : 连接数据库的地址,路径 -->
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/Hibernate
</property>
<!-- show_sql: 操作数据库时,会 向控制台打印sql语句 -->
<property name="show_sql">true</property>
<!-- format_sql: 打印sql语句前,会将sql语句先格式化 -->
<property name="format_sql">true</property>
<!-- hbm2ddl.auto: 生成表结构的策略配置
update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构.
如果存在表结构,并且表结构与实体一致,那么不做修改
如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
-->
<property name="hbm2ddl.auto">update</property>
<!-- 数据库方言配置
org.hibernate.dialect.MySQLDialect (选择最短的)
-->
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- hibernate.connection.autocommit: 事务自动提交
<property name="hibernate.connection.autocommit">true</property>
-->
<!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession -->
<property name="hibernate.current_session_context_class">
thread
</property>
<!-- 引入ORM 映射文件
填写src之后的路径
-->
<mapping resource="resource/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
user.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- ORM元数据 表对象关系映射文件
package : 配置该配置文件中类所在的包. -->
<hibernate-mapping package="com.huhu.domain">
<!-- class: 配置实体与表的关系
name : 填写实体的完整类名
table: 与实体对应表的名称
dynamic-insert:动态插入 默认值是false
true=>如果字段值为null,不参与insert语句
dynamic-update:动态更新 默认值"false"
true=> 没改动过的属性,将不会生成到update语句中
-->
<class name="com.huhu.domain.User" table="t_user">
<!-- id: 配置实体与表中 id对应
name: user对象中标识主键的属性名称
column: 主键在表中的列名
length: 列的数据长度
unsaved-value(不常用): 指定主键为什么值时,当做null来处理.
access(强烈推荐不要用):field 那么在操作属性时,会直接操作对应的字段而不是get/set方法
-->
<id name="id" column="id">
<!-- generator:主键生成策略
1.increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
2.identity 依赖于数据的主键自增功能
3.sequence 序列,依赖于数据中的序列功能(Oracle).
4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
5.native 自动根据数据库判断,三选一. identity|sequence|hilo
6.uuid 生成32位的不重复随机字符串当做主键
7.assigned 自己指定主键值. 表的主键是自然主键时使用.
-->
<generator class="native"></generator>
</id>
<!-- property : 实体中属性与表中列的对应
name : 实体中属性名称
column : 表中列的名称
length : 数据长度
precision: 小数点后的精度
scale: 有效位数
insert(一般不用): 该属性是否加入insert语句.
update(一般不用): 该属性是否加入update语句.
not-null : 指定属性的约束是否使用 非空
unique : 指定属性的约束是否使用 唯一
-->
<!--
type: 表达该属性的类型
可以用三种方式指定属性
java类型 数据库类型指定 Hibernate类型指定
java.lang.String varchar string
-->
<property name="name" column="name"></property>
<property name="password" column="password"></property>
</class>
</hibernate-mapping>
User
package com.huhu.domain;
// Hibernate
public class User {
private Integer id;
private String name;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", password=" + password
+ "]";
}
}
HibernateUtils
package com.huhu.utils;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
//完成Hibernate工具类
//封装配置文件读取操作
//封装Sessionfactroy创建操作
//封装session获得操作
public class HibernateUtils {
private static SessionFactory sf;
static{
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
sf = conf.buildSessionFactory();
//
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
System.out.println("虚拟机关闭!释放资源");
sf.close();
}
}));
}
public static org.hibernate.Session openSession(){
//3 获得session
Session session = sf.openSession();
return session;
}
public static org.hibernate.Session getCurrentSession(){
//3 获得session
Session session = sf.getCurrentSession();
return session;
}
public static void main(String[] args) {
System.out.println(openSession());
}
}
HibernateDemo1
package com.huhu.a_state;
import com.huhu.domain.User;
import com.huhu.utils.HibernateUtils;
import org.hibernate.Session;
/**
* 对象的三种状态
*/
public class HibernateDemo1 {
//三种状态
public void fun1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------
User u = new User(); //status : 瞬时状态
u.setName("tom"); //status : 瞬时状态
u.setPassword("1234"); //status : 瞬时状态
//保存
session.save(u); //status : 持久状态
//调用save方法时,数据库有没有对应记录
//没有记录，但最终会被同步到数据库中，仍时持久状态
//--------------------------------------
session.getTransaction().commit(); //status : 持久状态
session.close(); //status : 游离状态
}
// 三种状态的转换 瞬时=》持久
public void fun2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------
User u = new User(); //status : 瞬时状态
u.setName("he"); //status : 瞬时状态
u.setPassword("123456"); //status : 瞬时状态
session.save(u); //status : 持久状态
//--------------------------------------
session.getTransaction().commit(); //status : 持久状态
//事务提交时会把持久对象保存到数据库
//increment=>hibernate 自动查询最大id，然后生成主键
//assigned =>自动生成主键
session.close();
}
// 瞬时=》游离 瞬时：没有关联没有id 游离：没有关联有id(与数据库对应的id)
public void fun3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
User u = new User();
u.setId(2); //此时为游离状态
//--------------------------------------
session.getTransaction().commit(); //status : 持久状态
//事务提交时会把持久对象保存到数据库
session.close();
}
//持久=》瞬时1 持久：有关联，有id，瞬时：无关联无id
public void fun4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 2); //持久状态
//--------------------------------------
session.getTransaction().commit();
//事务提交时会把持久对象保存到数据库
session.close(); //游离状态
u.setId(null);
}
//持久=》瞬时1 持久：有关联，有id，瞬时：无关联无id
public void fun5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 4); //持久状态
session.evict(u); //将User对象和session的关联移除
u.setId(null); //瞬时对象
//--------------------------------------
session.getTransaction().commit();
session.save(u);
//事务提交时会把持久对象保存到数据库
session.close(); //游离状态
}
// 持久=》游离 持久：有关联，有id
public void fun6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 4); //持久状态
session.evict(u); //将User对象和session的关联移除
//--------------------------------------
session.getTransaction().commit(); //游离
session.close(); //游离状态
}
// 游离=》瞬时 瞬时：无关联无id
public void fun7() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 4); //持久状态
session.evict(u); //瞬时
u.setId(null); //瞬时
//--------------------------------------
session.getTransaction().commit(); //瞬时
session.close(); //瞬时状态
}
// 游离=》持久 是否与session关联
public void fun8() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久状态
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 4); //持久状态
session.evict(u); //游离
session.update(u); //持久
//--------------------------------------
session.getTransaction().commit(); //持久 打印updata语句
session.close(); //瞬时状态
}
public void fun9() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//
//通过get方法，得到持久状态对象
User u = (User) session.get(User.class, 4);
u.setName("nenen");
//--------------------------------------
session.getTransaction().commit();
session.close(); //瞬时状态
}
public static void main(String[] args) {
HibernateDemo1 d = new HibernateDemo1();
//d.fun1();
d.fun9();
}
}
代码显而易见。如果觉得不明显再来一个图吧。
总结下吧：
三种状态有什么用：
1.持久状态：我们使用hibernate主要时为了持久化数据
2.对于对象的状态： 我们期望我们现需要同步到数据库的数据，都被转化为持久化
持久话对象的特点:
hibernate会自动将持久话对象的变化同步到数据库.
所以说hibernate是一个面向对象的框架，利用对象的操作数据。