If I have a form-backing object that has a complicated object tree — say a Person that has a Contact Info object that has an Address object that has a bunch of Strings — it seems that the object needs to be fully populated with component objects before I can bind to it. So if I’m creating a new Person, I need to make sure it has all the component objects populated off the bat, and if I’m retrieving a Person from the database, I need to make sure that any objects that aren’t populated from the database get populated with empty objects.
First question, of course — am I correct in my assumptions above? It does seem that if I try to bind to person.contactInfo.homeAddress.street and there is no ContactInfo, I get a null pointer exception.
Second, what’s the best way to initialize my object. I can think of a couple of approaches. One is to initialize all member objects at declaration:
public class Person { String name; ContactInfo contactInfo = new ContactInfo(); //getters, setters, etc. } public class ContactInfo { String phone; Address homeAddress = new Address(); } and so forth.
Another approach is to have a PersonFactory that initializes everything (or to have a factory method Person.getInstance that initializes everything).
In the case of retrieving a Person from the database, the first approach will solve the issue (i.e. if this particular person doesn’t have an address in the database, the object will still have an Address), but this will mean creating each object twice. Not sure how to handle this otherwise, except to make the DAO explicitly populate everything even if nothing has been retrieved from the database. Or to give the factory a method to go through the object and ‘fill in’ anything that’s missing.
Suggestions?
Call it overkill if you like, but what we actually ended up doing was to create a generic factory that will take any object and use reflection to (recursively) find all the null properties and instantiate an object of the correct type. I did this using Apache Commons BeanUtils.
This way you can take an object that you may have gotten from various sources (a DAO, deserialization from XML, whatever), pass it through this factory, and use it as a form-backing object without worrying that something you need for binding may be null.
Admittedly, this means instantiating properties that we may not need for a given form, but in our case that doesn’t typically apply.