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();

Hibernate批量操作

Python实现大麦网抢票的四大关键技术点解析

c++

一生有你

Hibernate批量操作

我的友情鏈接

Spring 框架之九陰真經

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結