【SSH之旅】一步步学习Hibernate框架（一）：关于持久化

在不引用不论什么框架下，我们会通过平庸的代码不停的对数据库进行操作，产生了非常多冗余的可是又有规律的底层代码，这样频繁的操作数据库和大量的底层代码的反复书写极大的浪费了程序人员的书写。就在这样一种情况下，Hibernate框架应运而生了。

事实上Hibernate封装的就是Model模型中的model，封装的这部分又叫持久层。在这层中对对象进行加入、删除、更新、查询等操作就叫做持久化。

持久化的对象有三种状态：Transient Objects、Persist Objects、Detached Objects。

Transient Objects：

使用new操作初始化的对象不会被立马持久化。其状态时瞬时的，不被Session管理，此时，也没有不论什么跟数据库相关联的行为，即数据库中没有这个记录，仅仅要不被其它对象引用，他们的状态将会丢失，并由垃圾回收机制回收。

在下面情况下对象处于此状态：

(1) 当通过new语句刚创建了一个对象，不和数据库中的不论什么记录相应。

               (2) Session的delete()方法能使一个持久化对象或游离对象转变为暂时对象。对于游离对象，delete()方法从数据库中删除与它相应的记录；对于持久化对象。delete()方法从数据库中删除与它相应的记录。而且把它从Session的缓存中删除。

Persist Objects：

持久实例是不论什么具有数据库标识的实例。它有持久化管理器Session统一管理。持久化实例在事务中进行操作的。其状态在事务结束时同数据库进行同步。

当事务提交时。通过运行SQL的insert、update、delete语句把内存中的状态同步到数据库中。

Session的很多方法都可以触发Java对象进入持久化状态，比方说Session的save()把暂时对象转变为持久化对象。load()或get()返回的对象处于持久化状态。find()返回的List集合中存放的都是持久化对象。update()、saveOrUpdate()和lock()使游离对象转变为持久化对象。

Detached Objects：

Session被关闭后，持久化对象就变成离线对象。离线表示这个对象不再与数据库保持同步，不再受管理。

当调用Session的close()时，Session的缓存被清，缓存中的全部持久化对象都变为游离对象。evict()可以从缓存中删除一个持久化对象，使它变为游离状态。

实例分析：

项目结构：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFuZGFuem1j/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

hibernate.cfg.xml文件：

配置数据库信息和生成的表的

<!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.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
		<property name="hibernate.connection.username">zhudan</property>
		<property name="hibernate.connection.password">1221</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.show_sql">true</property>
	<mapping resource="zhudan/hibernate/User.hbm.xml"></mapping>
	</session-factory>
</hibernate-configuration>

User.hbm.xml文件：

须要映射的表的配置。

<?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 >
	<class name="zhudan.hibernate.User" table="T_User">
		<id name="id" column="UserID">
			<generator class="uuid"/>
		</id>
		<property name="name" column="UserName"></property>
		<property name="password" column="PassWord"></property>
		<property name="createTime" column="CreateTime"></property>
		<property name="expireTime" column="ExpireTime"></property>
	</class>
</hibernate-mapping>

HibernateUtils类：

读取前面配置的hibernate.cfg.xml，建立SessionFactory、Session，关闭Session等。

package zhudan.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class HibernateUtils {

	private static SessionFactory factory;

	static{
		try{
			//读取hibernate.cfg.xml
			Configuration cfg=new Configuration().configure();
			//建立SessionFactory
			factory=cfg.buildSessionFactory();
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	//获取Session
	public static Session getSession(){
		return factory.openSession();
	}

	//关闭Session
	public static void closeSession(Session session){
		if(session!=null){
			if(session.isOpen()){
				session.close();
			}
		}
	}

	//SessionFactory
	public static SessionFactory getSessionFactory(){
		return factory;
	}
}

ExportDB类：映射表。将hbm.xml生成相应的ddl。

package zhudan.hibernate;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class ExportDB {
	public static void main(String[] args){
		//读取hibernate.cfg.xml文件
		Configuration cfg=new Configuration().configure();
		SchemaExport export=new SchemaExport(cfg);
		export.create(true, true);
	}
}

SessionTest类：

package zhudan.hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.Transaction;

import junit.framework.TestCase;

public class SessionTest extends TestCase {
	public void testSave1(){
		Session session=null;
		//开启事务
		Transaction tx=null;
		try{
			session=HibernateUtils.getSession();
			tx=session.beginTransaction();
			//Transient状态
			User user=new User();
			user.setName("zhudan");
			user.setPassword("zhudan");
			user.setCreateTime(new Date());
			user.setExpireTime(new Date());
			//被session管理。persistent状态。当对象属性改变的时候
			//清理缓存（脏数据）的时候，会和数据库同步
			session.save(user);
			//更新上一条数据
			user.setName("fanglin1");
			session.update(user);
			//提交事务
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			if(tx!=null){
				tx.rollback();
			}
		}finally{
			HibernateUtils.closeSession(session);
		}
		//detached状态
	}
} 

在这个样例中，当New一个User对象时，状态是Transient Objects，此时数据库中没有这条数据，不被Session管理，当在运行保存时。状态改变为Persist Objects，此时，数据中存在当前数据，被Session管理，一旦事务被提交。运行完此语句后。状态更改为Detached
Objects，此时数据库中存在此数据。被Session管理。

总结：

持久化封装了数据訪问细节。为大部分业务逻辑提供了面向对象的接口，降低了数据库訪问次数，添加了应用程序的运行速度，使其不依赖于底层数据库和上层业务逻辑实现，更换数据库时也仅仅是改动配置文件而不用改动代码。重用性大大提高。