I am getting the infamous LazyInitializationException in a simple web app I am writing.

I have 2 entities being access: Person and Report

Here is the Person Java Class:


And here is the Hibernate Mapping File:


Here is the Report Java Class:


And the Report Hibernate Mapping File:


I have a Data Access Object set up to handle my Hibernate functions. Here are the portions of the file that I am using for this particular feature:


In my page controller I grab the reports by the project_id and loop through them to display on the page. When I attempt to access the Person data it fails and gives me the LazyInitializationException.

From this information can anybody help me understand the proper HQL or Java syntax that populates the Person within the Report records I am retrieving? I guess I assumed that Hibernate automatically fetched that data from the Person table when I did the call for the reports. After all I am getting the person_id out of the Person object...

Any help with this would be greatly appreciated.

Thanks

You say:
list = (ArrayList) session.createQuery(hql).list();

This may not be an issue but,
.list() returns List not ArrayList... have you verified that the backing class is ArrayList? Even if you have it is good to follow the contract.

public ArrayList getReportsByProjectId(int project_id)
aught to be:
public List<Report> getReportsByProjectId(int project_id)

Thanks! :) I'm not well versed in that syntax, but I'll research and implement it into my code.

Question about that syntax: I want to have a reusable function for returning a list of objects. How would I pass the object class into the function for applying to the List? Here is what I am currently using:



Any clue of how to resolve my Lazy Loading issue with Hibernate?

Really I don't know much about Hibernate... but... you should work with the return type, unless you know for a fact what backs it.
Here let's change this method so it agrees with the contract:

public List getObjects(String hql) {
List list = null; //here you created an arraylist, but never used it... actually it gets thrown away... when you did the assignment.

try {
session = getSession();
trans = session.beginTransaction();
list = session.createQuery(hql).list(); //here list() returns a new List so list would have a new reference
trans.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
closeSession(session);
}
return list;
}
/* so now list either contains a good list or null, but it would never contain null... unless an exception was thrown (because you would get an empty list otherwise)... The better way is throwing the exception rather than checking for null. Say this is a web application, you would want some error condition set and some error message set which the web page could display.*/

Understanding Generics: This is really simple and I recommend using this syntax for a while until you get used to it...
You are comfortable with the type ArrayList... and you know that an ArrayList can hold any type of Objects. But more often than not your program does not expect a particular ArrayList to hold anytype of object... So instead of just saying plain old ArrayList we say ArrayList<Report> and if we want to be clear in cases where we know the ArrayList could hold different types of Objects we could say ArrayList<?>. Say the ArrayList isn't holding any random object but objects that share a base class we could enforce this with ArrayList<? extends Report>, now our list will only hold Reports, TSPReports and TopSecretReports or what ever extends Report. So you get the idea. If your method returns ArrayList<?> (as in the case with getObjects() because it could return a few different kinds) then when it gets to a method that is designed to process a certain type of Object, say Report Objects then you can cast ArrayList<?> to ArrayList<Report> and you are good to go.

Why do this: 1) It makes it easier to read because it is clear without looking around what is coming and going from containers. 2) It will help catch errors, because it is more difficult to use the container incorrectly.

Here is the above method again with Generics:
public List<?> getObjects(String hql) {
List<?> list = null; //here you created an arraylist, but never used it... actually it gets thrown away... when you did the assignment.

try {
session = getSession();
trans = session.beginTransaction();
list = session.createQuery(hql).list(); //here list() returns a new List so list would have a new reference
trans.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
closeSession(session);
}
return list;
}

PS: I didn't test any of the code.

Well... what I have found on my own so far is that I need to load the Person objects into the Reports before closing the Hibernate Session. I may eventually write a reusable method that can handle this for any class, but for now I'll handle these types of request in a way similar to what I have done with the Report object.

Here is one of the method for retrieving the Report objects that clears up the Lazy load:



I doubt this is the most efficient way to do this, but it does work consistently without errors.