I seem to be having a problem caching Persistant Objects that have been mapped to use a proxy. Specifically, I am doing a HQL query to return these POs, the first request is successful, but a the second request, if I use the cached query results I get the following exception:

net.sf.hibernate.HibernateException: Could not initialize proxy - the
owning Session was closed
at
net.sf.hibernate.proxy.LazyInitializer.initialize(LazyInitializer.java:47)
at
net.sf.hibernate.proxy.LazyInitializer.initializeWrapExceptions(LazyInitializer.java:60)
at
net.sf.hibernate.proxy.LazyInitializer.getImplementation(LazyInitializer.java:164)
at
net.sf.hibernate.proxy.CGLIBLazyInitializer.intercept(CGLIBLazyInitializer.java:108)
at
org.ifmc.qies.qw.data.po.QwDataGrp$$EnhancerByCGLIB$$14a5c192.getSqncNum()

etc.

Let me know if you need more info, I am in a bit of a rush at the moment. I have a PO named "Orders" which is mapped with proxy="package.name.Orders". Basically I am running a cached query such as this:

select o from Orders where name="somebody"

and I am displaying some info about the orders on my web page by iterating over the resulting List. (I am calling some getter methods on the fields so I know the proxy gets initialized). The first time this is run there is no error. However, if I would press "reload" in my browser (which loads the cached results in a new session) I get the error posted above.

Am I misunderstanding how caching proxied objects is supposed to work? Why would this error occur? Is it perhaps a problem since I am using the query cache?

I am using version 2.1.2.

Thanks in advance,
Daniel

I found the reason for this error. My session was being closed before the objects got displayed.

The first time after the query was run, the result set came back with objects all initialized already, so even though the session was closed they all displayed correctly. However, in the second request, when the cached query results are used, internally the id set of all the rows are used to fetch those objects already cached in the previous request. At that point the code thinks that the proxied objects are not initialized, so it tries to initialize it, and seeing that the session is closed it throws the exception.

What I dont understand is why the session must be open when using the results of the second query. After all, when the objects were placed in the cache by the first request they were initialized proxies, so why when the second request tries to use them are they not still initialized? Why would those objects lose their "initialized" status?

Since I did not get any replies to my question, perhaps I am not being clear. I will now be more specific.

I have code similar to this:



Note once again that the Order object is mapped to use a proxy, and the Desc field is not part of the PK so the proxy needs to be initialized in order to get the value.

So my question is, if the first query already loads proxied objects that are already initialized and places the already initialized objects into the second-level cache, why when the 2nd query retrieves the cached results do those objects lose the "initialized" status? Why is the first query different than the 2nd, that with the first query it doesn't matter if the session is closed or not but in the second query it does? Is this perhaps a bug?

(In case you are wondering, others on my team want the Hibernate session closed in the servlet before forwarding to the JSP. So I would put the resulting List in the http servlet request object and iterate over the elments in my JSP to display the results. I would hate in my servlets to have to iterate over the result set and call initialize() on every element every time I run a query that the results would be used in this fashion. It seems a bug. )

Thanks,
Daniel

This is correct and expected functionality. Entity state is NOT cached in the query cache. (It is not that hard to iterate over query results and call Hibernate.initialize(), by the way.)

Thanks for the reply Gavin.

Isn't this inefficient though? After all the objects were already initialized when they were placed in the cache, so what additional benefit is there when they come back in an uninitialized state when fetching them from the cache subsequentially?

(Also it is not that it is difficult to iterate over the result set and call initialize(), it is just that this would need to be done in almost every servlet we have that uses any sort of cached query results. And it is bug prone in the sense that if one forgets in one place to place this loop that page would have an exception.

It is also a bit of a difficult bug to find, as when the user encounters the page the first time everything appears working fine. It is only the second time the user goes to that page that the exception occurs (such as if they hit the refresh button). It would be much less error prone to have the cached query objects to come back initialized as they were when the query first ran. For what purpose are they pulled from the cache unitialized that this is "expected behavior"?)

Your suggested strategy could result in loading the entire cache into the session. Ok, thats a bit extreme. But a user found that for a complex object graph, "eager" loading from the cache was a performance bug.