Hibernate中的不同主键生成策略下flush()方法的妙用

依旧让代码站出来说话。。这是一个Java Project。。

首先是位于src下的Hibernate核心配置文件hibernate.cfg.xml

<?xmlversion='1.0'encoding='UTF-8'?>
<!DOCTYPEhibernate-configurationPUBLIC
"-//Hibernate/HibernateConfigurationDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
<propertyname="connection.url">jdbc:mysql://localhost:3306/jadyer?characterEncoding=UTF-8</property>
<propertyname="connection.username">root</property>
<propertyname="connection.password">jadyer</property>
<propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>

<propertyname="hibernate.show_sql">true</property>
<propertyname="hibernate.format_sql">true</property>

<!--批量读取数据。建议值50。需要JDBC和底层数据库的支持-->
<propertyname="hibernate.jdbc.fetch_size">50</property>
<!--批量更新数据。建议值30-->
<propertyname="hibernate.jdbc.batch_size">30</property>
<!--配置完这两个属性后，当我们向数据库提交SQL时，就不会一次性把全部数据读入内存-->
<!--而是按照一定的数量来批量读取相应的数据，但最终是否会生效还取决于底层数据库的支持-->
<!--有些数据库就不支持这些参数。其中Oracle和SQLServer都支持，而MySQL貌似就不支持-->

<!--也可以通过以下方式编写映射文件-->
<mappingresource="com/jadyer/hibernate/all.hbm.xml"/>
<!--
<mappingresource="com/jadyer/hibernate/User11.hbm.xml"/>
<mappingresource="com/jadyer/hibernate/User22.hbm.xml"/>
<mappingresource="com/jadyer/hibernate/User33.hbm.xml"/>
-->
</session-factory>
</hibernate-configuration>

接下来是我们用到的三个实体类

packagecom.jadyer.hibernate;
importjava.util.Date;
publicclassUser11{
privateStringid;
privateStringname;
privateStringpassword;
privateDatecreateTime;
/*--三个属性对应的setter和getter略--*/
}


packagecom.jadyer.hibernate;
importjava.util.Date;
publicclassUser22{
privateintid;
privateStringname;
privateStringpassword;
privateDatecreateTime;
/*--三个属性对应的setter和getter略--*/
}


packagecom.jadyer.hibernate;
importjava.util.Date;
publicclassUser33{
privateStringid;
privateStringname;
privateStringpassword;
privateDatecreateTime;
/*--三个属性对应的setter和getter略--*/
}

下面是这三个实体类所对应的Hibernate映射文件all.hbm.xml

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mappingPUBLIC
"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mappingpackage="com.jadyer.hibernate">
<classname="User11"table="t_user11">
<idname="id"column="user_id"length="32">
<generatorclass="uuid"/>
</id>
<propertyname="name"unique="true"not-null="true"length="20"/>
<propertyname="password"not-null="true"length="10"/>
<propertyname="createTime"column="create_time"/>
</class>

<classname="User22"table="t_user22">
<idname="id"column="user_id">
<generatorclass="native"/>
</id>
<propertyname="name"unique="true"not-null="true"length="20"/>
<propertyname="password"/>
<propertyname="createTime"column="createtime"/>
</class>

<classname="User33"table="t_user33">
<idname="id"column="user_id"length="32">
<generatorclass="assigned"/>
</id>
<propertyname="name"/>
<propertyname="password"/>
<propertyname="createTime"column="create_time"/>
</class>
</hibernate-mapping>

然后是利用Hibernate映射文件生成数据库表的ExportDB.java

packagecom.jadyer.hibernate;

importorg.hibernate.cfg.Configuration;
importorg.hibernate.tool.hbm2ddl.SchemaExport;

/**
*利用Hibernate映射文件生成数据库表
*/
publicclassExportDB{
publicstaticvoidmain(String[]args){

//读取hibernate.cfg.xml文件
Configurationcfg=newConfiguration().configure();

//创建SchemaExport对象
SchemaExportexport=newSchemaExport(cfg);

//创建数据库表
export.create(true,true);
}
}

接下来是自定义的用于生成Session的工具类HibernateSessionUtils.java

packagecom.jadyer.hibernate;

importorg.hibernate.Session;
importorg.hibernate.SessionFactory;
importorg.hibernate.cfg.Configuration;

publicclassHibernateSessionUtils{
privatestaticSessionFactoryfactory;

static{
try{
Configurationcfg=newConfiguration().configure();
factory=cfg.buildSessionFactory();
}catch(Exceptione){
e.printStackTrace();
}
}

publicstaticSessiongetSession(){
returnfactory.openSession();
}

publicstaticvoidcloseSession(Sessionsession){
if(null!=session&&session.isOpen()){
session.close();
}
}
}

最后是借助了JUnit3.8实现的单元测试类SessionFlushTest.java

packagecom.jadyer.hibernate;

importjava.util.Date;

importorg.hibernate.Session;
importorg.hibernate.Transaction;

importcom.jadyer.hibernate.HibernateSessionUtils;
importcom.jadyer.hibernate.User11;
importcom.jadyer.hibernate.User22;
importcom.jadyer.hibernate.User33;

importjunit.framework.TestCase;

publicclassSessionFlushTestextendsTestCase{
/**
*向数据库中批量录入1000条数据
*@see执行save()方法时，同样会向一级缓存中存放数据
*@see所以要考虑到一次性大量的实体数据入库导致内存溢出
*@see这时便可使用到session的flush()和clear()方法
*/
publicvoidtestCachea(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();//开启事务
for(inti=0;i<1000;i++){
User22user=newUser22();
user.setName("u_"+i);
session.save(user);
if(0==i%20){
session.flush();//每20条数据就强制session持久化数据
session.clear();//同时清空缓存，避免大量数据造成内存溢出
}
}
//如果数据量特别大，最好不要再使用Hibernate录入数据了，可以考虑采用JDBC实现
//如果JDBC也不能满足要求，那么还可以考虑采用数据库本身的特定导入工具
//比如相对于Oracle来说，就可以使用它的特定工具【SQL*Loader】
session.getTransaction().commit();//提交事务
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();//发生异常则将事务回滚
}finally{
HibernateSessionUtils.closeSession(session);//最终不要忘记关闭org.hibernate.Session
}
}

/**
*测试主键生成策略为uuid时
*监测：执行save()之后以及再显式执行flush()时的SQL语句发送情况
*结果：调用save()后，不会立即发出insert语句。调用flush()后，才会发送并执行SQL语句
*@see【以下是关于session中的existsInDatebase属性的说明】
*@see重点关注Debug透视图中的右上角的Variables视图中数据的变化
*@see首先以DebugAs---JUnitTest方式执行单元测试方法，然后当执行完save()而未执行到flush()之前
*@see在Variables视图中展开到session---actionQueue---insertions---elementData---[0]里面
*@see我们可以把[0]里面的数据理解为形成insert的对象的集合，以后就遍历该集合，用以生成insert语句
*@see在Variables视图中session下面的actionQueue是一个临时的集合，用来形成insert或其它的语句
*@see在Variables视图中session下面的persistenceContext就可以理解成是它的缓存
*@see展开到persistenceContext---entityEntries---map---entries---table---[0]---value---value
*@see注意：展开到table中时，未必每次都是[0]，而此时我们应该展开的是存在HashMap$Entry<K,V>值的[i]就对了
*@see接着在第二层value下面，发现这里面还有一份数据。我们可以粗略的理解成是它缓存里的数据
*@see这时我们就会发现existsInDatebase属性，该属性就是用来判断当前数据在数据库中是否存在，值为false或true
*@see在执行完save()而没有执行flush()之前，existsInDatebase属性的值是false
*@see在执行完flush()而没有执行commit()之前，existsInDatebase的值就变为true，并且会马上发出SQL语句
*@see当existsInDatebase的值就变为true时，就说明数据库里面已经存在这条数据了
*@see这时再回到elementData---[0]临时集合查找，发现临时集合里面的数据已经没有了
*@see因为它要遍历该临时集合，再把临时集合里的数据拿出来形成insert语句。在执行insert后，临时集合就被清掉了
*@see所以说该临时集合是用来做临时交换的。当清掉临时集合之后，就会更新缓存中existsInDatebase的状态为true
*@see这时是在执行完flush()之后而没有执行commit()之前，此时还没有提交事务，但是已经执行了SQL语句
*@see而此时在MySQLCommandLineClient中执行select查询的话，是查看不到数据的，这涉及到数据库的隔离级别
*@see我们可以使用select@@tx_isolation;命令查看MySQL默认隔离级别，结果为REPEATABLE-READ：即可重复读
*@see如果我们执行settransactionisolationlevelreaduncommitted;命令，此时的隔离级别就是未提交读
*/
publicvoidtestSave11(){
Sessionsession=null;
Transactiontx=null;
try{
session=HibernateSessionUtils.getSession();
tx=session.beginTransaction();
User11user=newUser11();
user.setName("张三");
user.setPassword("123");
user.setCreateTime(newDate());
//由于User11采用的是uuid的主键生成策略
//所以调用save()后，不会发出insert语句，而只是将user纳入了session的管理中
//但此时id已经生成。而且这个时候session中的existsInDatebase的状态为false
session.save(user);
//调用flush()后，Hibernate会清理缓存，并执行SQL语句，会将user对象保存到数据库中
//如果数据库的隔离级别设置为READ-UNCOMMITTED的话，即未提交读，那么我们就可以看到flush()过的数据
//并且将session中insertions临时集合里user对象清除，此时session中existsInDatebase也被设置为true
//session.flush();
//默认情况下commit()操作会先执行flush()清理缓存，所以不需要显式的调用flush()方法
tx.commit();
}catch(Exceptione){
e.printStackTrace();
tx.rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}

/**
*测试主键生成策略为native时
*@see监测：执行save()之后的SQL语句发送情况
*@see结果：调用save()之后，将立即发送并执行insert语句。因为需要返回由数据库生成的id值
*/
publicvoidtestSave22(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User22user=newUser22();
user.setName("李四");
user.setPassword("123");
user.setCreateTime(newDate());
//由于User22采用的是native的主键生成策略
//所以调用save()方法之后，将发送并执行insert语句，然后返回由数据库生成的id值
//并纳入了session的管理，也修改了session中的existsInDatebase的状态为true
//如果数据库的隔离级别设置为未提交读，那么我们就可以看到save()过的数据
session.save(user);
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}


/**
*测试主键生成策略为uuid时
*@see监测：执行save()和evict()之后，缓存中数据的变化
*@see结果：执行commit()后无法成功提交，并报告possiblenonthreadsafeaccesstosession
*/
publicvoidtestSave33(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User11user=newUser11();
user.setName("王五");
user.setPassword("123");
user.setCreateTime(newDate());
session.save(user);
//执行evict()后，会将user对象从session中逐出。即从session的entityEntries属性中逐出user对象
session.evict(user);
//执行commit()后无法成功提交
//因为hibernate在清理缓存时，会在session的临时集合insertions中取出user对象进行insert操作
//接下来就会去更新persistenceContext里面entityEntries中的existsInDatabase属性的值为true
//而我们已经采用evict()将user对象从session的entityEntries中逐出了，故找不到相关数据，无法更新
//抛出异常：org.hibernate.AssertionFailure:possiblenonthreadsafeaccesstosession
//翻译结果：该线程不安全。也就是说当清除user对象，回来更新数据的时候，它认为是其它线程把这个数据删掉了
//其实给我们的理解：应该说不会出现这个问题。而网上有的人说这可能是Hibernate的一个BUG，其实不然
//通过这些可以看到：Hibernate在缓存方面确实下足了一番功夫
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}

/**
*测试主键生成策略为uuid时
*@see监测：在evict()之前先执行flush()方法，用以解决调用evict()之后无法提交数据的问题
*@see结果：执行commit()后成功提交
*/
publicvoidtestSave44(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User11user=newUser11();
user.setName("赵六");
user.setPassword("123");
user.setCreateTime(newDate());
session.save(user);
session.flush();//此时会发出insert语句
session.evict(user);
//执行commit()后可以成功提交
//因为hibernate在清理缓存时，在session的insertions临时集合中无法找到user对象
//所以就不会发出insert语句，也就不会更新session中的existsInDatabase属性的状态
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}

/**
*测试主键生成策略为native时
*@ses监测：执行save()和evict()之后，缓存中数据的变化
*@ses结果：执行commit()后成功提交
*/
publicvoidtestSave55(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User22user=newUser22();
user.setName("马七");
user.setPassword("123");
user.setCreateTime(newDate());
session.save(user);//此时会发送insert语句
session.evict(user);
//执行commit()后可以成功提交
//因为hibernate在清理缓存时，在session的insertions临时集合中无法找到user对象
//所以就不会发出insert语句，也就不会更新session中的existsInDatabase属性的状态
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}

/**
*测试主键生成策略为assigned时
*@see监测：批量执行save、update、delete操作的顺序
*@see结果：Hibernate会按照save、update、delete顺序提交相关操作
*/
publicvoidtestSave66(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User33user=newUser33();
user.setId("001");
user.setName("王八");
session.save(user);
user.setName("夙瑶");
//session.update(user);//也可以不显式的调用update()。此时的user正处于持久态，它会自动更新的
User33user3=newUser33();
user3.setId("002");
user3.setName("玄宵");
session.save(user3);
//Hibernate:insertintot_user33(name,password,create_time,user_id)values(?,?,?,?)
//Hibernate:insertintot_user33(name,password,create_time,user_id)values(?,?,?,?)
//Hibernate:updatet_user33setname=?,password=?,create_time=?whereuser_id=?
//Hibernate会按照save、update、delete顺序提交相关操作
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}

/**
*测试主键生成策略为assigned时
*@see监测：利用flush()实现自定义的save、update、delete执行顺序
*@see结果：SQL会按照我们的意愿执行
*/
publicvoidtestSave77(){
Sessionsession=null;
try{
session=HibernateSessionUtils.getSession();
session.beginTransaction();
User33user=newUser33();
user.setId("003");
user.setName("蔡依林");
session.save(user);
user.setName("菜10");
//session.update(user);//也可以不显式的调用update()。此时的user正处于持久态，它会自动更新的
session.flush();//利用flush()实现自定义的save、update、delete执行顺序
User33user33=newUser33();
user33.setId("004");
user33.setName("郑伊健");
session.save(user33);
//Hibernate:insertintot_user33(name,password,create_time,user_id)values(?,?,?,?)
//Hibernate:updatet_user33setname=?,password=?,create_time=?whereuser_id=?
//Hibernate:insertintot_user33(name,password,create_time,user_id)values(?,?,?,?)
//由于在udpate()后面执行了flush()方法，所以在commit()清理缓存时，只会生成session.save(user33)的SQL语句
session.getTransaction().commit();
}catch(Exceptione){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateSessionUtils.closeSession(session);
}
}
}