hibernate效率问题

不念不忘少年蓝@ 2022-07-14 07:53 138阅读 0赞

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

基本环境：

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循环，但是总比每次去操作数据库来的快；

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