hibernate效率问题

声明：本博文用于学习总结及工作心得

基本环境：

Ubantu 14.04、 JDK1.7 、Mysql(存储引擎InnoDB)、SSH、存储介质:固态硬盘

最近项目中在执行常用数据表格时效率出现问题，主要问题在于持久化层的增删该查，利用hibernate执行相关操作，耗时是在接受不了

以200条数据for循环操作为例：（表格已建索引， pojo类配置文件无误）

插入操作耗时40s左右；修改操作40s左右；查找操作28s左右；并且不单单是耗时比较长，并且cpu占用率也很高达到40%；

在这之前系统是使用的机械硬盘，测试效率时，耗时更加长，

然后更换为固态硬盘，虽然其读写能力有提高但是提升幅度有限；

经过仔细研究相关代码后发现问题所在：

代码中插入时间戳多次进行测试，发现插入修改一条数据，平均耗时在100多毫秒，查找平均耗时在160多毫秒左右；

以下为Hibernate操作：

插入操作
public void insert(final Object entity) {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.save(entity);
            session.flush();
            tx.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
            session.close();
        }finally {
            if (session.isOpen()) {
                session.close();
            }
        }
    }

修改操作
public void update(final Object entity) {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        try {
            session.update(entity);
            session.flush();
            tx.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
            session.close();
        }finally {
            if (session.isOpen()) {
                session.close();
            }
        }
    }

查询操作
 public T get(Serializable id) {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        T t = null;
        try {
            t = (T)session.get(entityClass, id);
            session.flush();
            tx.commit();
            session.close();
        } catch (Exception e) {
            tx.rollback();
            session.close();
        }finally {
            if (session.isOpen()) {
                session.close();
            }
        }
        return t;
    }

问题就出在action中，我们每次执行相关操作时，都去调用DAO层的相关方法，每次都需要打开session,开启事务，在插入或者修改时，没执行一次，都需要flush;

在执行flush之前数据一直存在于内存中，只用flush后才会将内存中的数据写入数据库，这样一来，每次操作时候都需要数据库IO操作，这样无疑大大降低了效率；

同样在我们get一个实例对象的时候，每次都去get这样的效率肯定低；

知道问题以后，改进就不成问题了：

针对插入，修改，删除操作；使用hibernate批量操作；

针对级联数据时，可以用一条sql语句将相关数据查询出来，放入List集合或者其它数据结构进行操作；（主要是要看实际的业务需求）

看一下批处理操作：

批量插入操作(可以写入公共方法)
public void batchInsert(List<DosingBill> dosingBills) {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        try {
            int i = 0;
            for (DosingBill dosingBill : dosingBills) {
                session.save(dosingBill);
                if (++i % 40 == 0) {
                    session.flush();
                    session.clear();
                    tx.commit();
                    tx = session.beginTransaction();
                }
            }
            tx.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
            session.close();
        } finally {
            if (session.isOpen()) {
                session.close();
            }
        }

    }

批量修改操作(可以写入公共方法)
public void batchUpdate(List<Stock> stocks) {
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();
        try {
            int i = 0;
            for (Stock stock : stocks) {
                session.update(stock);
                if (++i % 40 == 0) {
                    session.flush();
                    session.clear();
                    tx.commit();
                    tx = session.beginTransaction();
                }
            }
            tx.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
            session.close();
        } finally {
            if (session.isOpen()) {
                session.close();
            }
        }

    }

红色代码部分：每40次操作执行flush，清理缓存，提交事务

同样在for循环中get相关关联的对象时，在for循环执行之前先获取这200条记录中需要使用到的关联对象；

例如：

public Map<Integer, BomItem> getByIds(String ids) {
        Map<Integer, BomItem> maps = new HashMap<Integer, BomItem>();
        List<BomItem> items = this.findAll("from BomItem where id in(" + ids + ")");

        for (BomItem bomItem : items) {
            maps.put(bomItem.getId(), bomItem);
        }
        return maps;
    }

这里为了在循环中更加容易获取对象将其转化为Map集合；ids为ID字符串

还有我们在获取级联对象数据时，是否是真的需要整个级联实例对象，如果只是需要返回几个字段的值，就一定要注意，获取一个对象比获取几个字段消耗的时间多的多，特别是数据量大的时候，这些小细节，越需要注意，不然积少成多，一样影响效率

hibernate 多字段结果集返回
public Map<String, BigDecimal> getStockQtyAndPlanQty(AllGoods allGoods, String ids, Integer goodsAllocationId) {
        Map<String, BigDecimal> maps = new HashMap<String, BigDecimal>();
        String hql = "select sum(quantity),sum(planQuantity) from Stock s where s.allGoods.id = " + allGoods.getId();
        if (!"".equals(ids)) {
            hql += " and inStoreRecord.inWarehouse.id in (" + ids + ")";
        }
        if (goodsAllocationId != null) {
            hql += " and inStoreRecord.inGoodsAllocation.id = " + goodsAllocationId + "";
        }
        List<Object[]> objects = findAll(hql);
        if (null != objects && !objects.isEmpty()) {
            for (Object[] link : objects) {
                maps.put("totalQty", link[0] == null ? new BigDecimal(0) : (BigDecimal) link[0]);
                maps.put("totalPlanQty", link[1] == null ? new BigDecimal(0) : (BigDecimal) link[1]);
            }
        }
        return maps;
    }

经过简单的修改，测试后，200条记录所有操作都可以在1s中完成， CPU使用率变为4%，相比之前足足提高几十倍；这样虽然多了几个for循环，但是总比每次去操作数据库来的快；

需要注意的是以上修改需要根据实际业务情况来修改；