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

最新推荐文章于 2021-06-09 15:23:42 发布
最新推荐文章于 2021-06-09 15:23:42 发布
阅读量329 收藏
点赞数
文章标签： java 数据库 markdown
原文链接：http://www.cnblogs.com/jinjiyese153/p/7976360.html
版权

目录

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

1. session

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

2. session.flush

在获取Session对象时，Hibernate默认关闭了自动提交事务。
Hibernate执行SQL时，会将所有SQL存入Session的缓存中，提交事务时，再在数据库中执行SQL
private SessionFactory sessionFactory;
private Session session;
private Transaction transaction;
    
@Test
public void testSaveStudent() {
        
    // 生成学生对象
    Student s = new Student(3, "张三丰", "男", new Date(), "武当山");
    session.save(s);
        
}

Before
public void init() {
        
    // 创建会话工厂对象
    sessionFactory = new Configuration().configure().buildSessionFactory();
    // 创建会话对象
    session = sessionFactory.openSession();
    // 开始事务
    transaction = session.beginTransaction();
        
}
    
@After
public void destory () {
        
    // 提交事务
    transaction.commit();
    // 关闭会话
    session.close();
    // 关闭会话工厂
    sessionFactory.close();
        
}
若不开启事务或开启事务不提交，则SQL语句就不能在数据库中执行，此时可以通过session.flush()方法，强制将缓存中的SQL语句刷新到数据库
private SessionFactory sessionFactory;
private Session session;
    
/**
 * 不开启事务，数据无法保存到数据库
 */
@Test
public void testSaveStudentNoTransaction() {
    
    // 生成学生对象
    Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
    session.save(s);
    
}

/**
 * 不开启事务，使用session.flush()强制同步数据到数据库
 */
@Test
public void testSaveStudentByflush() {
    
    // 生成学生对象
    Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
    session.save(s);
    session.flush();// 当不使用事务时，需使用flush方法，强制提交
    
}

/**
 * 开启事务，但不使用commit提交，而是使用session.flush()强制提交
 */
@Test
public void testSaveStudentTransaction() {
    
    // 开启事务
    session.beginTransaction();
    // 生成学生对象
    Student s = new Student(6, "张三丰", "男", new Date(), "武当山");
    session.save(s);
    session.flush();// 不提交事务时，直接使用flush方法，也可强制提交
    
}

Before
public void init() {
        
    // 创建会话工厂对象
    sessionFactory = new Configuration().configure().buildSessionFactory();
    // 创建会话对象
    session = sessionFactory.openSession();
        
}
    
@After
public void destory () {
        
    // 关闭会话
    session.close();
    // 关闭会话工厂
    sessionFactory.close();
        
}

3. session.doWork

Hibernate使用面向对象的思想来进行数据库操作，推荐使用的也是封装的HQL语句，但有时项目需要进行jdbc操作，此时可以使用session.doWork()，在匿名内部类中获取Connection，进行jdbc操作。
/**
 * 使用session.doWork()实现jdbc操作
 */
@Test
public void testSessionDowork() {
    
    final List<String> list = new ArrayList<String>();
    
    session.doWork(new Work() { // 使用dowork方法进行jdbc操作
        
        @Override
        public void execute(Connection connection) throws SQLException {
            
            String sql = "select sname from student";
            PreparedStatement ps = (PreparedStatement) connection.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            try {
                while (rs.next()) {
                    String name = rs.getString(1);
                    list.add(name);
                }
            } finally {
                if (rs != null) {
                    rs.close();
                }
                if (ps != null) {
                    ps.close();
                } 
                // 此时connection被session管理，不能手动关闭
                /*if (connection != null) {
                    connection.close();
                }*/
            }
            
        }
    });
    
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    
}

Before
public void init() {
        
    // 创建会话工厂对象
    sessionFactory = new Configuration().configure().buildSessionFactory();
    // 创建会话对象
    session = sessionFactory.openSession();
        
}
    
@After
public void destory () {
        
    // 关闭会话
    session.close();
    // 关闭会话工厂
    sessionFactory.close();
        
}

4. 完整代码

pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.imooc</groupId>
    <artifactId>Hibernate_001</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.1.5.Final</version>
        </dependency>
        <!-- mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.22</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <target>1.7</target>
                    <source>1.7</source>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>
Student.java
package com.imooc.hibernate.model;

import java.util.Date;

public class Student {
    
    private int sid; // 学号
    private String sname; // 姓名
    private String gender; // 性别
    private Date birthday; // 出生日期
    private String address; // 地址
    
    public Student() {
    }

    public Student(int sid, String sname, String gender, Date birthday, String address) {
        this.sid = sid;
        this.sname = sname;
        this.gender = gender;
        this.birthday = birthday;
        this.address = address;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student [sid=" + sid + ", sname=" + sname + ", gender=" 
                + gender + ", birthday=" + birthday + ", address=" + address + "]";
    }
    
}
student.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">
<hibernate-mapping>

    <class name="com.imooc.hibernate.model.Student">
        <id name="sid" type="int">
            <column name="SID"/>
            <generator class="assigned"/> <!-- 主键生成策略 -->
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME"/>
        </property>
        <property name="gender" type="java.lang.String">
            <column name="GENDER"></column>
        </property>
        <property name="birthday" type="java.util.Date">
            <column name="BIRTHDAY"/>
        </property>
        <property name="address" type="java.lang.String">
            <column name="ADDRESS"></column>
        </property>
    </class>

</hibernate-mapping>
hibernate.cfg.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 name="connection.username">root</property>
        <!-- 数据库连接密码 -->
        <property name="connection.password">20121221</property>
        <!-- 数据库驱动 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库连接url -->
        <property name="connection.url">
            jdbc:mysql://localhost:3306/hibernate?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8
        </property>
        
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 展示SQL -->
        <property name="show_sql">true</property>
        <!-- 格式化SQL -->
        <property name="format_sql">false</property>
        <!-- 建表策略 -->
        <property name="hbm2ddl.auto">update</property>
        
        <!-- 指定映射文件 -->
        <mapping resource="hbm/student.hbm.xml"/>
    </session-factory>

</hibernate-configuration>
StudentTest.java
package com.imooc.hibernate.test;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.imooc.hibernate.model.Student;
import com.mysql.jdbc.PreparedStatement;

public class StudentTest {
    
    private SessionFactory sessionFactory;
    private Session session;
    
    /**
     * 不开启事务，数据无法保存到数据库
     */
    @Test
    public void testSaveStudentNoTransaction() {
        
        // 生成学生对象
        Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
        session.save(s);
        
    }
    
    /**
     * 不开启事务，使用session.flush()强制同步数据到数据库
     */
    @Test
    public void testSaveStudentByflush() {
        
        // 生成学生对象
        Student s = new Student(5, "张三丰", "男", new Date(), "武当山");
        session.save(s);
        session.flush();// 当不使用事务时，需使用flush方法，强制提交
        
    }
    
    /**
     * 开启事务，但不使用commit提交，而是使用session.flush()强制提交
     */
    @Test
    public void testSaveStudentTransaction() {
        
        // 开启事务
        session.beginTransaction();
        // 生成学生对象
        Student s = new Student(6, "张三丰", "男", new Date(), "武当山");
        session.save(s);
        session.flush();// 不提交事务时，直接使用flush方法，也可强制提交
        
    }
    
    /**
     * 使用session.doWork()实现jdbc操作
     */
    @Test
    public void testSessionDowork() {
        
        final List<String> list = new ArrayList<String>();
        
        session.doWork(new Work() { // 使用dowork方法进行jdbc操作
            
            @Override
            public void execute(Connection connection) throws SQLException {
                
                String sql = "select sname from student";
                PreparedStatement ps = (PreparedStatement) connection.prepareStatement(sql);
                ResultSet rs = ps.executeQuery();
                try {
                    while (rs.next()) {
                        String name = rs.getString(1);
                        list.add(name);
                    }
                } finally {
                    if (rs != null) {
                        rs.close();
                    }
                    if (ps != null) {
                        ps.close();
                    } 
                    // 此时connection被session管理，不能手动关闭
                    /*if (connection != null) {
                        connection.close();
                    }*/
                }
                
            }
        });
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
    }
    
    @Before
    public void init() {
        
        // 创建会话工厂对象
        sessionFactory = new Configuration().configure().buildSessionFactory();
        // 创建会话对象
        session = sessionFactory.openSession();
        
    }
    
    @After
    public void destory () {
        
        // 关闭会话
        session.close();
        // 关闭会话工厂
        sessionFactory.close();
        
    }
    
}

5. 总结

使用Hibernate时，若需使用jdbc进行操作，则使用session.doWork()
若需提前提交session缓存中的SQL，则使用session.flush()
eg:
    Transaction tx = session.beginTransaction();
    for (int i = 0; i < 100000; i++) {
        Student s = new Student(...);
        session.save(s);
        if (i % 20 == 0) { // 防止session内存溢出
            session.flush();
            session.clear();
        }
    }
    tx.commit();
    session.close();

参考：Hibernate初探之单表映射

更好的markdown体验：https://www.zybuluo.com/chy282/note/970752

转载于:https://www.cnblogs.com/jinjiyese153/p/7976360.html

weixin_30883311
关注
hibernate-transaction(提交事务)
qq_31027159的博客
09-10 6954
transtraction对数据库的操作都是封装到事务当中，并且默认是非自动提交的方式。所以用session保存对象时，如果不开启事务，并且手工提交事务，对象并不会真正保存在数据库中； 如 @Before public void init() { Configuration config=new Configuration().configure(); ...
Hibernate的详细入门
javaprogramme的博客
07-22 591
Hibernate 什么是hibernate Hibernate是一个开放源代码的对象关系映射框架，他对JDBC进行了非常轻量级的对象封装，他对POJO（简单java对象）与数据库表建立映射关系， 是一个全自动的ORM框架，hibernate可以自动生成SQL语句，自动执行，使得java程序员可以随心所欲的使用对象编程思想来操作数据库，hibernate 可以应用在任何使用JDBC的场合，既可以...
hibernate4中使用Session doWork()方法进行jdbc操作(代码)
weixin_34380948的博客
11-06 313
Hibernate3.3.2版本中getSession().connection()已被弃用，hibernate4中官方推荐使用Session doWork()方法进行jdbc操作 首先看看Work接口类的定义 public interface Work { //Execute the discrete work encapsulated by this work instance usin...
hibernate4中使用Session doWork()方法进行jdbc操作
yefeng
01-15 472
import org.hibernate.jdbc.Work; public class TestDoWork(){ public void testSessionDowork() throws Exception { Session session = getSession(); final String sql="select * from t_cp_u...
hibernate的session.connection被session.dowork()顶替
qq804702802的专栏
10-06 2195
原文：http://www.imooo.com/zonghe/open-source/239398.htm Hibernate3.3.2版本中getSession().connection()已被弃用，替代方法SessionFactoryUtils.getDataSource(getSessionFactory()).getConnection() 来自类org.springframewo
Hibernate的坑
浪子天涯行世录
06-09 205
遇到Hibernate的坑，总会浪费不少时间，记一下。 1.同一个事务中，先更新(增/删/改)表，再从之前更新的表查询，默认返回的是更新之前的内容。 2.执行HQL和SQL时返回的数据类型是不一样的，现在遇到的有： select count(id) from table1; --HQL时返回的Long,SQL时返回的不是Long,保险起见可以按Number接收，再number.longValue(); select idfrom table1; ...
Hibernate(5)session的方法
T_P_F的博客
01-23 995
1. Session缓存 Session缓存（Hibernate一级缓存），在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存。只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期。 Session 缓存可减少 Hibernate 应用程序访问数据库的频率。 两次获取同一个对象： ①
Hibernate学习笔记(二)
Augus6的点点滴滴
02-07 1069
一、修改一条记录     更新数据库中的一条记录有两种方式：     ① 加载持久化对象，修改对象属性，然后session清理缓存的时候会自动同步更新数据库中的数据。     ② 更新游离对象，通过session的update方法更新数据库中的相应数据。 二、Hibernate与数据库触发器协同工作的问题及解决办法     问题1：触发器使session缓存中的持久化对象与数据库
hibernate处理批量新增更新和删除
z773171880
10-12 502
9.4 批量处理数据 通常，在一个Session对象的缓存中只存放数量有限的持久化对象，等到Session对象处理事务完毕，还要关闭Session对象，从而及时释放Session的缓存占用的内存。批量处理数据是指在一个事务中处理大量数据。以下程序在一个事务中批量更新CUSTOMERS表中年龄大于零的所有记录的AGE字段：Transaction tx = session.beginTr...
hibernate中session对象的状态详解
06-25
hibernate中session对象的状态详解
Hibernate 遇到的坑
技术无止境
03-22 486
在传统的java开发中,通常分领域模型，model。在对数据进行保存的时候通常一般会保存到vo中,显示数据到页面的时候通常是dto,前几天遇到个坑,在dto中封装实体对象，到控制器调用service进行相关业务操作的时候报错500,错误如下 com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer f...
hibernate_transaction事务
qq_38140644的博客
02-26 294
transaction简介 hibernate对于数据的操作都是封装在事务当中，并且是默认非自动提交的方式。所以session保存对象时，如果不开启事务，并切手工提交事务，对象不会真正的保存在数据库中。 如果想要hibernate像jdbc那样自动提交事务，必须调用session对象的dowork（）方法，获得jdbc的connection后，设置其自动提价事务模式。（不推荐）   pa...
Hibernate学习笔记----session核心方法
太匆匆
07-20 1108
需求：演示session核心方法，要点都在注释中 其他文件就不写了，配置和我之前笔记里面的都一样，我就把test里面的代码粘进来 junitTest.java package cn.limbo.hibernate.entity; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hi
hibernate关于事务和sqlsession的几个坑
凯哥Java的博客
09-06 1760
我们知道hibernate是ORM关系型数据库。和数据库交互的时候需要sqlsession，如果是保存、更新、删除操作的时候，还需要有事务。 在spring和hibernate整合的时候，事务都是有spring来处理。有的时候会遇到坑。 异常一： Could not obtain transaction-synchronized Session for current threa
吐槽hibernate的各种坑
Tina的博客
05-12 1360
这是近期我一边踩坑一边困惑的问题。 第一，Hibernate的级联批量保存超级超级慢，有没有人有同感？没错你的代码量是减少了，用个jpa的save方法就搞定了，但是性能呢？分析日志就可以看出来慢在哪里。 1. 如果你使用数据库的sequence做主键，它会先select sequnece.nextval from dual，list有多少条数据它就会select多少次，即使你只想update数...
4.1 Session方法核心
yiguang_820的博客
01-16 233
持久化对象的状态 站在持久化的角度，Hibernate把对象分为4种状态：持久化状态（比作公司的职员），临时状态（比作公司未正式入职的职员），游离状态（比作公司请假的职员），删除状态（比作公式开除的职员）。 Session的特定方法能使对象从一个状态转换到另一个状态。 1.临时对象（Transient）: 在使用代理主键的情况下，OID通常为null不处于Session的缓存中在数
hibernate的session对象
Wanger_tt的博客
03-08 563
hibernate中 session对象与connection对象是多对一得关系 即 一个session对应一个connection； 一个connection对应N个session对象。在hibernate中，session对象有以下方法： save（）； update（）； delete（）； createquery（）；
批量修改或批量删除 session.clear()和session.flush()
小樓東風的专栏
08-28 3886
在javaEey坛子上有人提到“robbin提到Hibernate3的缺点，一级缓存的强引用的问题，所以在做批量查询和插入操作的时候需要执行session.flush和session.clear两个操作。” 如批量插入时可以这么做：先在循环里面调用session.save()来保存，然后当到达指定的批处理数目的时候（比如20个），执行 session.flush()和session.c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值