Let's start with some details:

• My technology stack includes:
  • Spring 3.1.1.RELEASE
  • Hibernate 4.1.5.SP1
  • JSF 2.0?
  • OpenSessionInViewFilter (org.springframework.orm.hibernate4.support.OpenSessionInViewFilter)
  • PrimeFaces 3.3.1
  • Lombok 0.11.2
  • JBoss 7.1.1.Final

In a nutshell:

Encountering a LazyInitializationException when trying to add objects to a detached entity (Employee) in my application. Utilizing a custom collection as a transfer object resolves the issue.

Detailed Explanation:

I have an entity named Employee which includes a collection of Locations:

@Data
@EqualsAndHashCode(callSuper = true, of = {})
@ToString(callSuper = true, of = {})
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Employee extends Person
{
    @ManyToMany
    @JoinTable(name = "location_employee",
            joinColumns = @JoinColumn(name = "employee_id",
                    referencedColumnName = "id"),
            inverseJoinColumns = @JoinColumn(name = "location_id",
                    referencedColumnName = "id"))
    private Set<Location>   locations   = new HashSet<Location>();
}

The Employee class inherits from Person which contains attributes such as name, but they are irrelevant for this scenario.

@Data
@EqualsAndHashCode(of = "id")
@ToString(of = { "id", "name" })
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Person
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Setter(AccessLevel.NONE)
    private Long    id;

    private String  name;
}

The Location class is simple as well:

@Data
@EqualsAndHashCode(of = "id")
@ToString(of = { "id", "name" })
@Entity
public class Location
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Setter(AccessLevel.NONE)
    private Long            id;

    private String          name;
    @ManyToMany
    @JoinTable(name = "location_employee",
            joinColumns = @JoinColumn(name = "location_id",
                    referencedColumnName = "id"),
            inverseJoinColumns = @JoinColumn(name = "employee_id",
                    referencedColumnName = "id"))
    private Set<Employee>   employees = new HashSet<Employee>();
}

All collections default to lazy loading. However, when attempting to modify the locations collection of an Employee, a LazyInitializationException is thrown. Using a different collection for data transfer purposes mitigates this issue.

To eager load the Employee for manipulation on a JSF page, I use the following backing bean:

@Named
@Scope("view")
public class BackingBean
{
    @Inject
    private EmployeeDAO employeeDAO;
    private Employee        employeeFull;
    @Inject
    private LocationDAO locationDAO;
    private List<Location> locations;

    public Employee getSelectedEmployeeFull()
    {
        if (selectedEmployeeFull == null)
        {
            selectedEmployeeFull = employeeDAO.getEagerById(1L);
        }
        return selectedEmployeeFull;
    }

    public void setEmployeeFull(Employee e)
    {
        employeeFull = e;
    }

    public List<Location> getLocations()
    {
        if (locations == null)
        {
            locations = locationDAO.getAll()
        }
        return locations;
    }

    //...
} 

The EmployeeDAO class defines the query for eager loading:

@Named
public class EmployeeDAO
{
    @Inject
    private SessionFactory sessionFactory;

    @Transactional(readOnly = true)
    public Employee getEager(Long id)
    {
        Query q = sessionFactory.getCurrentSession().createQuery("select e from Employee e join fetch e.locations where e.id = :id");
        q.setParameter("id", id);
        try
        {
            return (Employee) q.uniqueResult();
        }
        catch (NonUniqueObjectException ex)
        {
            //Exception handling
            return null;
        }
    }
}

The JSF snippet that implements the functionality:

<p:dialog dynamic="true">
    <h:form>
        <p:selectCheckboxMenu label="Locations" value="#{employeeBean.employeeFull.locations}">
            <f:selectItems var="location" itemLabel="#{location.name}" value="#{employeeBean.locations}" />
        </p:selectCheckboxMenu>

        <p:commandButton value="save" action="#{employeeBean.update}"/>
    </h:form>
</p:dialog>

When launching the dialog, it properly loads the employeeFull property and populates the selectCheckboxMenu with existing Locations associated with the Employee.

However, upon submitting the form by clicking save without making any changes triggers a LazyInitializationException pertaining to the Employee.locations collection:

Error message goes here...

The EmployeeBean.update method is not invoked, evidenced by the absence of any breakpoint hits.

Now for the grand finale: How can I prevent this LazyInitializationException.

UPDATE

A temporary solution has been devised, although not necessarily optimal:

In the JSF page:

<p:dialog dynamic="true" onShow="loadSelectedEmployee()">
    <h:form>
        <p:remoteCommand action="#{employeeBean.loadSelectedEmployee}" name="loadSelectedEmployee" update=":editEmployeeDialogContent" />
    </form>
    <p:outputPanel layout="block" id="editEmployeeDialogContent">
        <h:form rendered="#{employeeBean.selectedEmployeeLoaded}">
            <p:selectCheckboxMenu label="Locations" value="#{employeeBean.selectedEmployee.locations}">
                <f:selectItems var="location" itemLabel="#{location.name}" value="#{employeeBean.locations}" />
            </p:selectCheckboxMenu>

            <p:commandButton value="save" action="#{employeeBean.update}"/>
        </form>
    </p:outputPanel>
</p:dialog>

In the backing bean:

public void loadSelectedEmployee()
{
    if (!selectedEmployeeLoaded)
    {
        selectedEmployee.setLocations(locationManager
                .getByEmployee(selectedEmployee));
        selectedEmployee.setRoles(roleManager
                .getByEmployee(selectedEmployee));
        selectedEmployeeLoaded = true;
    }
}