我应该如何使用事务来防止内存不足异常？

Question

I can't figure out what annotations to use on my service class to minimise the memory required by the application.

Take a customer/order scenario where I'd like to find the largest total spend by a single customer. There are in total 1 million orders and 100 customers, each customer has made 10,000 orders.

The simplest example I can think of is:

public class MyService {
    @Transactional(readOnly=true)
    public int getMaxSpend() {
        int maxSpend = 0;
        List<Customer> customers = customerDao.findAll();
        for(Customer customer : customers) {
            List<Order> orders = orderDao.getOrders(customer);
            for(Order order : orders) {
                if(order.getTotal() > maxSpend) maxSpend = order.getTotal();
            }
        }
        return maxSpend;
    }
}

Since the transaction spans the loading of each customers orders I believe there will eventually be a million objects in the hibernate session which is far from ideal. I'd like to minimise the number of Order instances in memory by garbage collecting each customers orders once the iteration has been completed for that customer.

In the following example Customers do not reference their collection of orders nor do orders reference their customer:

public class MyService {
    @Transactional(propagation=Propagation.NEVER)
    public int getMaxSpend() {
        int maxSpend = 0;
        List<Customer> customers = getAllCustomers();
        for(Customer customer : customers) {
            int customerSpend = getCustomerSpend(customer);
            if(customerSpend > maxSpend) maxSpend = customerSpend;
        }
        return maxSpend;
    }

    @Transactional(readOnly=true)
    private List<Customer> getAllCustomers() {
        return customerDao.findAll();
    }

    @Transactional(readOnly=true)
    private int getCustomerSpend(Customer customer) {
        int customerSpend = 0;
        List<Order> orders = orderDao.getOrders(customer);
        for(Order order : orders) {
            customerSpend += order.getTotal();
        }
        return customerSpend;
    }
}

Unfortunately when I profile the memory in jprofiler there are still 1 million instances of Order loaded. I expected a hibernate exception as I thought private methods couldn't be transactional but this never happened. Is the above the correct approach and I somehow have a transaction open already or is there a different way of accomplishing my goal?

Answer 1

If getTotal() returns a value of persistent field, the best approach is to write HQL query with aggregate function:

select max(o.total) from Order o

Alternatively, you can periodically clear the session cache by calling clear() inside your loops (or by calling detach() on processed objects). Clearing the cache will turn entities into detached state, and they'll be collected by GC soon. It's a common practice for implementing batch operations with Hibernate.

Answer 2

只需编写一条sql语句即可返回所需的结果。