持久化对象的三种状态
*瞬时状态
-刚被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所管理
}
}
}
相关推荐
3. 编写实体类：表示数据库中的表，使用注解或XML映射文件定义其与数据库表的对应关系。 4. 创建SessionFactory：根据配置文件创建SessionFactory实例，它是线程安全的，整个应用程序中一般只有一个。 5. 获取...
一级缓存是每个会话内的内存缓存，自动管理对象状态；二级缓存则跨越多个会话，可以配置第三方缓存提供商如 Ehcache 或 Infinispan。 八、事务管理 Hibernate 支持JTA和JDBC两种事务管理方式。在Java EE环境中，...
这包括定义数据源、实体类映射文件（.hbm.xml或注解）、Hibernate配置文件（hibernate.cfg.xml）。配置文件中包含了数据库连接信息、缓存设置、方言选择等关键参数。 三、实体类和映射 实体类是业务逻辑中的对象，...
- **代码生成**：能够自动生成基于数据库表的Java实体类和对应的Hibernate配置文件，节省手动编码的时间。 - **对象关系映射（ORM）支持**：在设计阶段，插件可以帮助可视化数据库模式，并将其转换为对象模型。 -...
通过定义对应的Java实体类，并使用Hibernate的注解或者XML配置文件建立对象与数据库表的映射，可以轻松地进行数据的增删改查。 5. 开发流程：项目开发中，首先需要设计数据库模型，然后创建对应的Java实体类，接着...
1. 创建SessionFactory：通过Configuration类加载hibernate.cfg.xml配置文件，然后调用configure()方法，最后buildSessionFactory()生成SessionFactory实例。 2. SessionFactory是线程不安全的，通常在应用启动时...
SessionFactory用于创建Session实例，其配置信息来自hibernate.cfg.xml配置文件。 4. **Entity（实体）**：在Hibernate中，业务对象被称为实体，它们代表数据库中的表。实体需要使用@Entity注解标记，并通过@Id注解...
3. **配置文件**：Hibernate使用hibernate.cfg.xml文件进行配置，包括数据库连接信息、缓存策略等。 **二、实体类与数据表映射** 1. **注解映射**：在Hibernate 3.2中，除了XML映射文件，还可以使用Java注解来描述...
通过调用Configuration的buildSessionFactory()方法，会读取配置文件（如hibernate.cfg.xml），解析数据库连接信息、实体类映射信息，并生成SessionFactory实例。这个过程涉及了类加载、元数据解析等多个环节。 三...
2. **持久化模型**：Hibernate的核心是持久化模型，它将Java对象映射到数据库表，通过注解或XML配置文件定义这些映射关系。 3. **Session**：在Hibernate中，Session是对象与数据库交互的主要接口，负责管理对象的...
-SessionFactory：基于配置文件创建，是线程安全的，负责创建Session实例。 四、对象状态 -瞬时态（Transient）：对象刚被创建，尚未与Session关联。 -持久态（Persistent）：对象已与Session关联，其变更会自动...
Hibernate的配置文件通常是指`hibernate.cfg.xml`，它用于指定数据库连接信息、指定使用哪个方言（dialect）、设置缓存策略等。正确配置这些参数是Hibernate应用成功运行的基础。 #### 提供JDBC连接 为了使...
2. **配置文件**：`hibernate.cfg.xml`是Hibernate的主要配置文件，包含数据库连接信息、SessionFactory的配置等，它是启动Hibernate的第一步。 3. **实体类（Entity）**：在Hibernate中，Java类对应数据库中的表，...
2. **配置与初始化**：在使用 Hibernate 之前，需要进行必要的配置，包括数据库连接信息、实体类的映射文件（如 hbm.xml）以及 Hibernate 的配置文件（hibernate.cfg.xml）。这些配置文件定义了 Hibernate 如何与...
对象状态指实体在内存中的状态，如瞬时、持久和脱管。会话是Hibernate与数据库交互的主要接口，负责管理实体的状态和执行SQL语句。 **2. Hibernate配置** 配置Hibernate涉及到XML配置文件（hibernate.cfg.xml）或...
3. **序列化接口**：实现`Serializable`接口，以支持序列化操作，这对于Hibernate来说是非常重要的，因为它会在内存中缓存对象的状态。 4. **无参构造器**：默认情况下，Hibernate会寻找一个无参数的构造器来实例化...
持久化是指将内存中的数据保存到磁盘上的过程，在 Hibernate 中主要指将 Java 对象的状态保存到数据库中。 - **Session API**：提供了操作持久化对象的方法，如 save()、update() 和 delete() 等。 - **事务管理**...
3. **持久化（Persistence）**：持久化是将内存中的对象状态保存到持久存储介质的过程。在Hibernate中，我们可以使用EntityManager进行对象的创建、更新和删除操作。 4. **关系映射（Relationship Mapping）**：...
为了解决对象只能存在于内存中的问题，即如何将对象状态持久化至特定的数据存储库中，通常会将三层体系结构扩展为四层：表示层、业务层、持久层和数据库层。随着技术的发展，多种数据持久化解决方案应运而生，包括...
Hibernate提供了持久化机制，使对象能够在内存和数据库之间进行状态转换。通过Session接口，我们可以实现对象的保存、更新、删除和查询等操作。 4. **会话（Session）** Session是Hibernate的主要工作单元，它...