[关闭]
@chy282 2017-12-01T06:46:58.000000Z 字数 8903 阅读 2877

Hibernate二次学习二----------session.flush、session.doWork

Hibernate

© 版权声明：本文为博主原创文章，转载请注明出处

1. session

Hibernate是对JDBC的轻量级封装，将JDBC的Connection封装到了Session中，因此Hibernate对数据库的操作大多都是通过session实现的。

2. session.flush

在获取Session对象时，Hibernate默认关闭了自动提交事务。
Hibernate执行SQL时，会将所有SQL存入Session的缓存中，提交事务时，再在数据库中执行SQL

  1. private SessionFactory sessionFactory;
  2. private Session session;
  3. private Transaction transaction;
  5. @Test
  6. public void testSaveStudent() {
  8.     // 生成学生对象
  9.     Student s = new Student(3, "张三丰", "男", new Date(), "武当山");
  10.     session.save(s);
  12. }
  14. Before
  15. public void init() {
  17.     // 创建会话工厂对象
  18.     sessionFactory = new Configuration().configure().buildSessionFactory();
  19.     // 创建会话对象
  20.     session = sessionFactory.openSession();
  21.     // 开始事务
  22.     transaction = session.beginTransaction();
  24. }
  26. @After
  27. public void destory () {
  29.     // 提交事务
  30.     transaction.commit();
  31.     // 关闭会话
  32.     session.close();
  33.     // 关闭会话工厂
  34.     sessionFactory.close();
  36. }
若不开启事务或开启事务不提交，则SQL语句就不能在数据库中执行，此时可以通过session.flush()方法，强制将缓存中的SQL语句刷新到数据库

  1. private SessionFactory sessionFactory;
  2. private Session session;
  4. /**
  5.  * 不开启事务，数据无法保存到数据库
  6.  */
  7. @Test
  8. public void testSaveStudentNoTransaction() {
  10.     // 生成学生对象
  11.     Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
  12.     session.save(s);
  14. }
  16. /**
  17.  * 不开启事务，使用session.flush()强制同步数据到数据库
  18.  */
  19. @Test
  20. public void testSaveStudentByflush() {
  22.     // 生成学生对象
  23.     Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
  24.     session.save(s);
  25.     session.flush();// 当不使用事务时，需使用flush方法，强制提交
  27. }
  29. /**
  30.  * 开启事务，但不使用commit提交，而是使用session.flush()强制提交
  31.  */
  32. @Test
  33. public void testSaveStudentTransaction() {
  35.     // 开启事务
  36.     session.beginTransaction();
  37.     // 生成学生对象
  38.     Student s = new Student(6, "张三丰", "男", new Date(), "武当山");
  39.     session.save(s);
  40.     session.flush();// 不提交事务时，直接使用flush方法，也可强制提交
  42. }
  44. Before
  45. public void init() {
  47.     // 创建会话工厂对象
  48.     sessionFactory = new Configuration().configure().buildSessionFactory();
  49.     // 创建会话对象
  50.     session = sessionFactory.openSession();
  52. }
  54. @After
  55. public void destory () {
  57.     // 关闭会话
  58.     session.close();
  59.     // 关闭会话工厂
  60.     sessionFactory.close();
  62. }

3. session.doWork

Hibernate使用面向对象的思想来进行数据库操作，推荐使用的也是封装的HQL语句，但有时项目需要进行jdbc操作，此时可以使用session.doWork()，在匿名内部类中获取Connection，进行jdbc操作。

  1. /**
  2.  * 使用session.doWork()实现jdbc操作
  3.  */
  4. @Test
  5. public void testSessionDowork() {
  7.     final List<String> list = new ArrayList<String>();
  9.     session.doWork(new Work() { // 使用dowork方法进行jdbc操作
  11.         @Override
  12.         public void execute(Connection connection) throws SQLException {
  14.             String sql = "select sname from student";
  15.             PreparedStatement ps = (PreparedStatement) connection.prepareStatement(sql);
  16.             ResultSet rs = ps.executeQuery();
  17.             try {
  18.                 while (rs.next()) {
  19.                     String name = rs.getString(1);
  20.                     list.add(name);
  21.                 }
  22.             } finally {
  23.                 if (rs != null) {
  24.                     rs.close();
  25.                 }
  26.                 if (ps != null) {
  27.                     ps.close();
  28.                 } 
  29.                 // 此时connection被session管理，不能手动关闭
  30.                 /*if (connection != null) {
  31.                     connection.close();
  32.                 }*/
  33.             }
  35.         }
  36.     });
  38.     for (int i = 0; i < list.size(); i++) {
  39.         System.out.println(list.get(i));
  40.     }
  42. }
  44. Before
  45. public void init() {
  47.     // 创建会话工厂对象
  48.     sessionFactory = new Configuration().configure().buildSessionFactory();
  49.     // 创建会话对象
  50.     session = sessionFactory.openSession();
  52. }
  54. @After
  55. public void destory () {
  57.     // 关闭会话
  58.     session.close();
  59.     // 关闭会话工厂
  60.     sessionFactory.close();
  62. }

4. 完整代码

pom.xml

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>org.imooc</groupId>
  6.     <artifactId>Hibernate_001</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <packaging>jar</packaging>
  10.     <properties>
  11.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12.     </properties>
  14.     <dependencies>
  15.         <!-- junit -->
  16.         <dependency>
  17.             <groupId>junit</groupId>
  18.             <artifactId>junit</artifactId>
  19.             <version>4.12</version>
  20.             <scope>test</scope>
  21.         </dependency>
  22.         <!-- Hibernate -->
  23.         <dependency>
  24.             <groupId>org.hibernate</groupId>
  25.             <artifactId>hibernate-core</artifactId>
  26.             <version>5.1.5.Final</version>
  27.         </dependency>
  28.         <!-- mysql-connector-java -->
  29.         <dependency>
  30.             <groupId>mysql</groupId>
  31.             <artifactId>mysql-connector-java</artifactId>
  32.             <version>5.1.22</version>
  33.         </dependency>
  34.     </dependencies>
  36.     <build>
  37.         <plugins>
  38.             <plugin>
  39.                 <groupId>org.apache.maven.plugins</groupId>
  40.                 <artifactId>maven-compiler-plugin</artifactId>
  41.                 <version>3.6.1</version>
  42.                 <configuration>
  43.                     <target>1.7</target>
  44.                     <source>1.7</source>
  45.                     <encoding>UTF-8</encoding>
  46.                 </configuration>
  47.             </plugin>
  48.         </plugins>
  49.     </build>
  51. </project>
Student.java

  1. package com.imooc.hibernate.model;
  3. import java.util.Date;
  5. public class Student {
  7.     private int sid; // 学号
  8.     private String sname; // 姓名
  9.     private String gender; // 性别
  10.     private Date birthday; // 出生日期
  11.     private String address; // 地址
  13.     public Student() {
  14.     }
  16.     public Student(int sid, String sname, String gender, Date birthday, String address) {
  17.         this.sid = sid;
  18.         this.sname = sname;
  19.         this.gender = gender;
  20.         this.birthday = birthday;
  21.         this.address = address;
  22.     }
  24.     public int getSid() {
  25.         return sid;
  26.     }
  28.     public void setSid(int sid) {
  29.         this.sid = sid;
  30.     }
  32.     public String getSname() {
  33.         return sname;
  34.     }
  36.     public void setSname(String sname) {
  37.         this.sname = sname;
  38.     }
  40.     public String getGender() {
  41.         return gender;
  42.     }
  44.     public void setGender(String gender) {
  45.         this.gender = gender;
  46.     }
  48.     public Date getBirthday() {
  49.         return birthday;
  50.     }
  52.     public void setBirthday(Date birthday) {
  53.         this.birthday = birthday;
  54.     }
  56.     public String getAddress() {
  57.         return address;
  58.     }
  60.     public void setAddress(String address) {
  61.         this.address = address;
  62.     }
  64.     @Override
  65.     public String toString() {
  66.         return "Student [sid=" + sid + ", sname=" + sname + ", gender=" 
  67.                 + gender + ", birthday=" + birthday + ", address=" + address + "]";
  68.     }
  70. }
student.hbm.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  7.     <class name="com.imooc.hibernate.model.Student">
  8.         <id name="sid" type="int">
  9.             <column name="SID"/>
  10.             <generator class="assigned"/> <!-- 主键生成策略 -->
  11.         </id>
  12.         <property name="sname" type="java.lang.String">
  13.             <column name="SNAME"/>
  14.         </property>
  15.         <property name="gender" type="java.lang.String">
  16.             <column name="GENDER"></column>
  17.         </property>
  18.         <property name="birthday" type="java.util.Date">
  19.             <column name="BIRTHDAY"/>
  20.         </property>
  21.         <property name="address" type="java.lang.String">
  22.             <column name="ADDRESS"></column>
  23.         </property>
  24.     </class>
  26. </hibernate-mapping>
hibernate.cfg.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC 
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
  4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  7.     <session-factory>
  8.         <!-- 数据库连接名 -->
  9.         <property name="connection.username">root</property>
  10.         <!-- 数据库连接密码 -->
  11.         <property name="connection.password">20121221</property>
  12.         <!-- 数据库驱动 -->
  13.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  14.         <!-- 数据库连接url -->
  15.         <property name="connection.url">
  16.             jdbc:mysql://localhost:3306/hibernate?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8
  17.         </property>
  19.         <!-- 方言 -->
  20.         <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
  21.         <!-- 展示SQL -->
  22.         <property name="show_sql">true</property>
  23.         <!-- 格式化SQL -->
  24.         <property name="format_sql">false</property>
  25.         <!-- 建表策略 -->
  26.         <property name="hbm2ddl.auto">update</property>
  28.         <!-- 指定映射文件 -->
  29.         <mapping resource="hbm/student.hbm.xml"/>
  30.     </session-factory>
  32. </hibernate-configuration>
StudentTest.java

  1. package com.imooc.hibernate.test;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.util.ArrayList;
  7. import java.util.Date;
  8. import java.util.List;
  10. import org.hibernate.Session;
  11. import org.hibernate.SessionFactory;
  12. import org.hibernate.cfg.Configuration;
  13. import org.hibernate.jdbc.Work;
  14. import org.junit.After;
  15. import org.junit.Before;
  16. import org.junit.Test;
  18. import com.imooc.hibernate.model.Student;
  19. import com.mysql.jdbc.PreparedStatement;
  21. public class StudentTest {
  23.     private SessionFactory sessionFactory;
  24.     private Session session;
  26.     /**
  27.      * 不开启事务，数据无法保存到数据库
  28.      */
  29.     @Test
  30.     public void testSaveStudentNoTransaction() {
  32.         // 生成学生对象
  33.         Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
  34.         session.save(s);
  36.     }
  38.     /**
  39.      * 不开启事务，使用session.flush()强制同步数据到数据库
  40.      */
  41.     @Test
  42.     public void testSaveStudentByflush() {
  44.         // 生成学生对象
  45.         Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
  46.         session.save(s);
  47.         session.flush();// 当不使用事务时，需使用flush方法，强制提交
  49.     }
  51.     /**
  52.      * 开启事务，但不使用commit提交，而是使用session.flush()强制提交
  53.      */
  54.     @Test
  55.     public void testSaveStudentTransaction() {
  57.         // 开启事务
  58.         session.beginTransaction();
  59.         // 生成学生对象
  60.         Student s = new Student(6, "张三丰", "男", new Date(), "武当山");
  61.         session.save(s);
  62.         session.flush();// 不提交事务时，直接使用flush方法，也可强制提交
  64.     }
  66.     /**
  67.      * 使用session.doWork()实现jdbc操作
  68.      */
  69.     @Test
  70.     public void testSessionDowork() {
  72.         final List<String> list = new ArrayList<String>();
  74.         session.doWork(new Work() { // 使用dowork方法进行jdbc操作
  76.             @Override
  77.             public void execute(Connection connection) throws SQLException {
  79.                 String sql = "select sname from student";
  80.                 PreparedStatement ps = (PreparedStatement) connection.prepareStatement(sql);
  81.                 ResultSet rs = ps.executeQuery();
  82.                 try {
  83.                     while (rs.next()) {
  84.                         String name = rs.getString(1);
  85.                         list.add(name);
  86.                     }
  87.                 } finally {
  88.                     if (rs != null) {
  89.                         rs.close();
  90.                     }
  91.                     if (ps != null) {
  92.                         ps.close();
  93.                     } 
  94.                     // 此时connection被session管理，不能手动关闭
  95.                     /*if (connection != null) {
  96.                         connection.close();
  97.                     }*/
  98.                 }
  100.             }
  101.         });
  103.         for (int i = 0; i < list.size(); i++) {
  104.             System.out.println(list.get(i));
  105.         }
  107.     }
  109.     @Before
  110.     public void init() {
  112.         // 创建会话工厂对象
  113.         sessionFactory = new Configuration().configure().buildSessionFactory();
  114.         // 创建会话对象
  115.         session = sessionFactory.openSession();
  117.     }
  119.     @After
  120.     public void destory () {
  122.         // 关闭会话
  123.         session.close();
  124.         // 关闭会话工厂
  125.         sessionFactory.close();
  127.     }
  129. }

5. 总结

使用Hibernate时，若需使用jdbc进行操作，则使用session.doWork()
若需提前提交session缓存中的SQL，则使用session.flush()
eg:

  1.     Transaction tx = session.beginTransaction();
  2.     for (int i = 0; i < 100000; i++) {
  3.         Student s = new Student(...);
  4.         session.save(s);
  5.         if (i % 20 == 0) { // 防止session内存溢出
  6.             session.flush();
  7.             session.clear();
  8.         }
  9.     }
  10.     tx.commit();
  11.     session.close();

参考：Hibernate初探之单表映射

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注