How and when to load data in a JSF 2 Web App

Question

From How and when should I load the model from database for h:dataTable I love the idea of essentially caching data from a database in a PostConstruct method and subsequently accessing it in memory as many times as JSF wants to without a trip to the database, but I'm struggling with how to load and store it in memory. The classic object-to-relational impedance mismatch.

My model classes (beans, pure data objects) depend on other classes, i.e. objects contain other objects which are shared (e.g. a course has a student that is also in other courses). I am forced to do one of the following, all of which seem awkward:

• denormalize the in-memory data (beans) completely (different copies of the same student object appear in different course objects). I don't like copies of data which can get out of sync.
• use ID attributes (the course class has a studentID member). This necessitates looking up the student in the list of students using the ID whenever any student attribute is needed. Ecch.
• load all the data from bottom up in the contains hierarchy (load all the students, then load the courses, and for each course find the already-loaded related student object and put a reference to that object in the course object). This is a lot of searching but only has to be done once. If there are any circular references it won't work.

In addition, in order to make sure the model (the in memory data) is always in sync with the database, I would think that one would save and then load all the data every time the user changes any data, rather than incrementally change it in memory and then in the database and hope that I didn't forget to do this every time.

In a non-JSF application, it would not be heavy to hit the database with each user interaction unless the data were enormous, which would necessitate designing around performance rather than object-oriented anyway.

I am curious how others have approached this problem.

Answer 1

I use JSF with a complex database (and Hibernate ORM) a lot. My approach is very similar to what you linked and I never had any problems with it.

There are a few things to keep in mind to prevent troubles though:

• never do caching over more requests, it's a headache to solve all the lazy loaded relations

• when caching collections, remember to force refreshing them when you change anything (adding/removing a member), I do it like this:

  private List<Person> people = null;
  private Person person = null;
  
  private void initPeople() {
      this.people = this.peopleDao.getPeople();
  }
  
  public List<Person> getPeople() {
      // this will be called first in the restore view phase
      // then a few times later depending on the references in the
      // JSF page
      if (this.people == null) {
          initPeople();
      }
      return this.people;
  }
  
  public void savePerson() {
      // this will be called in the update model phase
      // so we reset the people collection to force its
      // re-initialization in later phases (like render response)
      peopleDao.savePerson(this.person);
      this.people = null;
  }
  

And I have a RequestListener, that manages the request-scoped hibernate session for the DAOs:

public class RequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // Create a Hibernate session and store it to a request scoped bean
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        // Close the Hibernate session created for this request
    }
}

Of course you could do it in a simple request-scoped bean in a @PostConstruct and @PreDestroy, but this way I can mix my JSF with plain servlets, which I do a lot.

Answer 2

On thinking this through, I think this is as others have suggested a caching question, not a JSF question, although I suspect others who use JSF have had to consider the issue of caching data in an object model in memory due to JSF's chatty nature in the view.

In the end I chose to write my own small ORM for my app: load the entities that have no dependencies in them first, then the entities that depend on them, and on up the contains hierarchy. This necessitates a not-very-scalable search through the lower-level entities to find the ones I want by ID - e.g. when constructing a course object from DB query results which contain studentIDs, iterate through all the student objects already loaded to find the ones I want. This seems a little awkward to me but it's the best I could come up with and the data size in this particular app is pretty manageable. This is probably simply due to my ignorance of how object-relational mapping is done.

I still face the question of how to efficiently refresh this cached object model when data changes. Thanks so much for your responses!