Hibernate批量操作

批量处理数据：指的是在一个事务场景中需要处理大量数据。
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();