Hibernate批量操作

321re · 发表于 2016-3-16 12:35:29

批量处理数据：指的是在一个事务场景中需要处理大量数据。
Hibernate进行批量处理数据的方式：
1.使用HQL进行批量操作:HQL是跨数据库的，面向对象，但具有局限性，只能用于单个持久化类，不支持连接，不能使用子查询
2.使用JDBC API进行批量操作：操作方式简单，可以在sql中使用不同数据库的特性
3.使用Session进行批量操作：把关系数据加载到内存中操作，需要通过代码处理复杂的业务逻辑
使用HQL进行批量操作：
  1.HQL可以查询数据，批量插入和更新以及删除数据，实际在数据库中完成，处理的数据不用加载到Session缓存中。
使用Query接口的executeUpdate()方法用于插入，更新和删除操作的hql语句
首先需要SessionUtil.java:
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import db.HibernateSessionFactory;
public class SessionUtil {
protected Session session=null;
protected Query query = null;
protected Transaction tx= null;
public Session getSession(){
      return HibernateSessionFactory.getSession();
}
public void closeSession(){
      HibernateSessionFactory.closeSession();
}
}
ps:SessionUtil需要包含HibernateSessionFactory.java，其在Hibernate导入jar包自动生成。
  a.批量添加操作：addManyEntity(List<Entity> list)
主要代码：
/**
   * [addManyEntity :批量添加,Entity属于实体类]
   getSession()：获取session
   beginTransaction()：事务开始
   commit()：事务提交
   rollback()：失误回滚
   * @param {[利用List集合进行遍历]} List<Entity> list
   */
public void addManyEntity(List<Entity> list) {
      try {
         session=getSession();
         tx=session.beginTransaction();
         for (Entity entity: list) {
            session.save(entity);
         }
         tx.commit();
         System.out.println("操作成功！");
      } catch (Exception e) {
         e.printStackTrace();
         tx.rollback();
         System.out.println("操作失败！");
      }
      finally{
         closeSession();
      }
}
b.批量修改：updateManyEntity(数据类型属性1,数据类型属性2)
  主要代码：
/**
* [updateManyEntity 批量修改]
* @param  {[实体类的属性的数据类型决定]} 数据类型属性1 [实体类的属性]
* @param  {[实体类的属性的数据类型决定]} 数据类型属性2 [实体类的属性]
*/
  public void updateManyEntity(数据类型属性1,数据类型属性2) {
         String hql="update 实体类名 set 属性名=:属性名 where 属性名=:属性名";
         try {
            session=getSession();
            tx=session.beginTransaction();
            query=session.createQuery(hql);
            query.setParameter("属性1", 属性1);
            query.setParameter("属性2", 属性2);
            int num=query.executeUpdate();
            System.out.print("修改的数据为："+num);
            tx.commit();
            System.out.println("操作成功！");
         } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
            System.out.println("操作失败！");
         }
         finally{
            closeSession();
         }
      }
c.批量删除:deleteManyEntity(数据类型属性1)
主要代码：
/**
* [deleteManyEntity 批量删除]
* @param  {[有实体类的属性的数据类型决定]} 数据类型属性 [一般都是根据主键来删除]
*/
public void deleteManyEntity(数据类型属性) {
String hql="delete  from 实体类名 where 属性名=:属性名";
try {
      session=getSession();
      tx=session.beginTransaction();
      query=session.createQuery(hql);
      query.setParameter("属性", 属性);
      int num=query.executeUpdate();
      System.out.print("删除的数据为："+num);
      tx.commit();
      System.out.println("操作成功！");
      } catch (Exception e) {
         e.printStackTrace();
         tx.rollback();
         System.out.println("操作失败！");
      }
      finally{
      closeSession();
      }
}
使用JDBC API进行批量操作：
1.批量更新：
  /**
* [updateEntity 批量更新]
* 1.需要使用session的doWork(Work work)方法执行Work对象指定的操作，就是调用execute()的方法
* 2.Session把当前的数据库连接传给execute()方法
*
*/
public void updateEntity(数据类型属性1,数据类型属性2) {
   final String sql="update 表名 set 属性=? where 属性=?";
   try {
         session=getSession();
         tx=session.beginTransaction();
         Work work=new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                  PreparedStatement preparedStatement=connection.prepareStatement(sql);
                  preparedStatement.setString(1, 属性);
                  preparedStatement.setInt(2, 属性);
                  preparedStatement.executeUpdate();
            }
         };
         session.doWork(work);
         tx.commit();
         System.out.println("操作成功！");
      } catch (Exception e) {
         e.printStackTrace();
         tx.rollback();
         System.out.println("操作失败！");
      }
      finally{
         closeSession();
      }
}
2. 批量删除
/**
* [deleteEntity 批量删除]
* 1.需要使用session的doWork(Work work)方法执行Work对象指定的操作，就是调用execute()的方法
* 2.Session把当前的数据库连接传给execute()方法
*
*/
public void deleteEntity(数据类型属性1,数据类型属性2) {
   final String sql="delete 表名 where 属性=?";
   try {
         session=getSession();
         tx=session.beginTransaction();
         Work work=new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                  PreparedStatement preparedStatement=connection.prepareStatement(sql);
                  preparedStatement.setString(1, 属性);
                  preparedStatement.executeUpdate();
            }
         };
         session.doWork(work);
         tx.commit();
         System.out.println("操作成功！");
      } catch (Exception e) {
         e.printStackTrace();
         tx.rollback();
         System.out.println("操作失败！");
      }
      finally{
         closeSession();
      }
}
3.批量查询：findAllEntity()
主要代码：
  /**
* [findAllEntity 批量查询]
* 2种遍历集合的方式：
* 1.Object[]数组：List<Object[]>list=query.list();
   query=session.createSQLQuery(sql);
            List<Object[]>list=query.list();
            for (Object[] objects : list) {
            for (Object object : objects) {
                  System.out.print(object+"\t");
            }
            System.out.println("");
         }
* 2.实体类的形式：List<Entity>list=query.list();
*  query=session.createSQLQuery(sql).addEntity(Entity.class);
            List<Entity>list=query.list();
            for (Entity entity : list) {
            System.out.println(entity.getXX());
         }
*
*
*/
public void findAllEntity() {
      String sql="select *from student";
      try {
            session=getSession();
            //第一种：Object[]
            /*query=session.createSQLQuery(sql);
            List<Object[]>list=query.list();
            for (Object[] objects : list) {
            for (Object object : objects) {
                  System.out.print(object+"\t");
            }
            System.out.println("");
         }*/
            //第二种：实体类
            query=session.createSQLQuery(sql).addEntity(Entity.class);
            List<Entity>list=query.list();
            for (Entity entity : list) {
            System.out.println(entity.getXX());
         }
            System.out.println(list.size());
            System.out.println("操作成功！");
      } catch (Exception e) {
            e.printStackTrace();
            System.out.println("操作失败！");
      }
      finally{
            closeSession();
      }
  }
3.条件查询：
/**
  *
  *
  * addEntity(alias【别名1】, entityClass【实体类】)
  * addJoin(alias【关联的别名】, path【别名1的属性】)
  * {}：获取别名对应的属性名
  * 别名.*:代表获取别名下面所有的属性
  */
public void findEntityByXX() {
String sql="select {别名1.*},{别名2.*} from 表名1 别名1 inner join 表名2 别名2 on 别名1.字段名=别名2.字段名";
try {
      session=getSession();
      query=session.createSQLQuery(sql).addEntity("别名", Entity.class).addJoin("别名", "别名.表名2");
      List list=query.list();
      System.out.println(list.size());
} catch (Exception e) {
      e.printStackTrace();
}
finally{
      closeSession();
}
4.命名查询：
  需要在Entity.hbm.xml中：
  <query name="自定义：getEntity">
   <![CDATA[
   hql语句
   ]]>
</query>
  主要代码：
  /**
* 1.第一种方式：不加条件查询:query=session.getNamedQuery("getEntity");
* 2.第二种：条件查询:query.setParameter("属性名", "条件");
*
*/
  public void getEntityXX() {
try {
      session=getSession();
      query=session.getNamedQuery("getEntity");
      query.setParameter("属性名", "条件");
      List<Entity>list=query.list();
      for (Entity entity : list) {
         System.out.println(entity.getXX());
      }
} catch (Exception e) {
      e.printStackTrace();
}
finally{
      closeSession();
}
}
使用Session进行批量操作：
需要及时从缓存中清除已经处理完毕并且不会再访问的对象：
首先：调用flush()方法强制同步缓存和数据库：session.flush();
然后：调用clear()方法清空缓存:session.clear();

Hibernate批量操.zip (2.68 KB, 下载次数: 0)

账号		自动登录	找回密码
密码			立即注册

Centos6.5×64安装配置openmeetings3.0.3详

大疆运维招人啦，

C++ :try 语句块和异常处理

C++的多态

Red Hat RHCE 8 (EX294) Cert Guide

Java/C++ 区别：看完这一篇，就够用！

别再用过时库了！这 13 个顶级 C++ 库才是

[经验分享] Hibernate批量操作

浏览过的版块

扫码加入运维网微信交流群