Adding domain objects

Question

Hello,
I'm working with an application where we have many, many, many domain objects that could be added to a "header". In my business/service interface I don't like to write 50+ of addX(...), addY(...), addZ(...) etc. methods.
Every domain object extends a domain object base class. In my business/service interface I've added one single method for adding domain objects to make the interface somewhat smaller:
public void add(DomainObject[] someDomainObjects);
    ...The elements of the domain object array are of different kind, but all extends the domain object base class. I'd like to implement class and method that have a strategy for determining what kind of domain object the current one is in the given array and invoke the correct add(...) method for that particular domain object.
The most simple way of doing it is to have a very big if-else using instanceof to determine what kind of domain object it is, but it doesn't feel like a very nice design.
Example:
public class MyBusinessObject {
    public void add(DomainObject[] someDomainObjects) {
        // Iterate over all domain objects in the array
        for (DomainObject domainObject : someDomainObjects) {
            // Determine what kind of domain object it is and create the correct DAO
            if (domainObject instanceof X) {
                DomainObjectXDao xDao = new DomainObjectXDao();
                // Save the current domain object
                xDao.save((X) domainObject);
            } else if (domainObject instanceof Y) {
                DomainObjectYDao yDao = new DomainObjectYDao();
                // Save the current domain object
                yDao.save((Y) domainObject);
            } else if (domainObject instanceof Z) {
                DomainObjectZDao zDao = new DomainObjectZDao();
                // Save the current domain object
                zDao.save((Z) domainObject);
            } else if (...) {
}Is there any design pattern for making this a more nice design?
If anyone could contribute with their good knowledge I'd be very glad!
Regards, Andreas Eriksson

Answer 1

Map the DomainObject types to their respective DAOs and look them up as you loop through them in the add method, e.g.:
public class MyBusinessObject {
  private Map daos = new HashMap();
    daos.put(X.class, new XDomainTypeDAO());
    daos.put(Y.class, new YDomainTypeDAO());
    daos.put(Z.class, new ZDomainTypeDAO());
  public void add(DomainObject[] objs) {
    for (DomainObject obj : objs) {
      Class type = obj.getClass();
      DAO dao = (DAO) daos.get(type);
      if (dao == null) {
        throw new IllegalArgumentException(
          "No DAO configured for DomainObject type " + type);
      dao.save((DomainObject) obj);
}You'd have to create a DAO interface (or abstract base class) which defines a save method with the signature public void save(DomainObject obj). Then each DAO would have to implement this method and cast the passed domain object to the expected type.
To take things further, you could introduce a DAOProvider interface to hide where the MyBusinessObject obtains the DAOs from (rather than have it maintain the map), e.g.:
public interface DAOProvider {
  DAO daoFor(Class domainType);
// A really simple implementation - assmes that DAOs are thread-safe
public class SimpleDAOProvider implements DAOProvider {
  private Map daos = new HashMap();
    daos.put(X.class, new XDomainTypeDAO());
    daos.put(Y.class, new YDomainTypeDAO());
    daos.put(Z.class, new ZDomainTypeDAO());
  public DAO daoFor(Class domainType) {
     DAO dao = (DAO) daos.get(type);
     if (dao == null) {
       throw new IllegalArgumentException(
         "No DAO configured for DomainObject type " + domainType);
    return dao;
}The advantage of this is you can alter the strategy for handing out DAOs, e.g. pass the same instance back each time, or dynamically instantiate a new instance, etc. Of course, you need a way for the MyBusinessObject to get hold of a DAOProvider instance (inject it? Have it use a factory?)