Dear Spring Community,

I’m pleased to announce that the first public development milestone of Spring BlazeDS Integration, the newest member of the open source Spring portfolio, is now available.
Download | Reference Documentation | JavaDocs | Changelog

This is a foundational release that sets the stage for using Adobe Flex and BlazeDS in conjunction with the Spring programming model to build Rich Internet Applications.  We have a number of further integration ideas in mind already for the next milestone, and I would like to invite the community to get involved by trying out this early preview and giving us feedback in the community forum and Jira as we progress towards a full-fledged 1.0.  Check out Using Spring BlazeDS Integration 1.0.0.M1 to get started.

Jeremy Grelle
Spring BlazeDS Integration Lead

I’m pleased to announce that Spring Framework 3.0 M1 is finally available for download!

This release features several major changes, including a start of the major 3.0 themes such as EL and REST support:

• revised project layout and build system with module-based sources
• updated entire codebase for Java 5 code style (generics, varargs)
• updated to JUnit 4.5 and JRuby 1.1
• introduced Spring EL parser (org.springframework.expression package)
• introduced support for #{…} expressions in bean definitions
• introduced expression-enabled @Value annotation for embedded expressions
• introduced @PathVariable annotation for URI template handling in MVC handlers
• introduced default value support for @RequestParam in MVC handlers
• introduced @RequestHeader annotation for HTTP header access in MVC handlers
• introduced AbstractAtomFeedView and AbstractRssFeedView base classes
• introduced <spring:url> and <spring:param> JSP tags

as well as various minor enhancements.

Note that Spring Framework 3.0 requires Java 5 or above and J2EE 1.4 or above. We are building on Java 6 and Java EE 5 as the primary platform levels - but rest assured, we will retain compatibility with Java 5 enabled J2EE 1.4 servers such as WebLogic 9 and WebSphere 6.1.

This definitely looks like something to start taking a look at.

But then, everything new and cool seems to me like something worth taking a look at. Focus … must … fight … ADD … focus … breathe … focus …

One thing I forgot to mention in the last version of this post was the idea of spinning off a separate thread for sending out the notices. That’s another one of those things that I would really like to do, but like a number of such issues, I’ve just set off to the side in the interest of getting something to the point of actually working before investing too much in the bells and whistles. Now might be a good time to go back and explore that a little bit.

Another thing that I thought about doing was to build a few more example notice templates, particularly since Velocity 1.6 is now out. It would be fun to work up a few sample templates that leveraged some of the new capabilities the 1.6 release. But then, that thought got me thinking about the various applications for the notification service, and how all of the little services that we have built so far could leverage off of one another, and what kind of sample app could be constructed to best illustrate such use.  Which got me thinking …

Before I started putting the source code out on Subversion, I used to release a complete .ear file, including all of the source code. I stopped doing that because, for one, now you can just connect to Subversion and pull down the source code yourself, and for another, now I produce the .ear file using Maven, and I’ve never taken the time to figure out how to produce an .ear file using Maven that includes the source code. So, I just stopped doing that.

The point, here, though, that I was trying to get to in my rambling, convoluted way, is that I was thinking that maybe, instead of an .ear file full of source code, I should release a different kind of file … a “demo” file that included an application server and a database (presumably Tomcat and HSSQLDB) that you could just unzip and fire up and get to all of the examples. That would seem to be more useful than an .ear file that you would have to deploy to your own server, and would be a much faster path to seeing some of these examples actually work.

Of course, I would want to upgrade all of the examples, and come up with a little nicer way to launch them all and explain them all, but still, that’s an interesting idea. One that would undoubtedly take a considerable amount of work to set up, but even so, an interesting idea. Something to consider, anyway.

Which brings us back to that same old question: what to do next?!

  /**
   * <p>Logs the details of this notification.</p>
   *
   * @param deliveryMethod the delivery method used for this message
   * @param addresses an array of "address" objects containing the
   * implementation-specific addresses required for successful delivery of
   * the message
   * @param titleSubject an optional subject and/or title of the message to
   * be delivered
   * @param contentType the mime type of the message body
   * @param body the text of the message to be delivered
   * @param noticeData optional data used to resolve variables in the notice
   */
  private void auditNotification(String deliveryMethod, MessageAddress[] addresses,
         String titleSubject,  String contentType, String body, Object noticeData) {
    NoticeAudit noticeAudit = new NoticeAudit();

    Date rightNow = new Date();
    String userId = "NotifierImpl";
    HttpServletRequest req = findHttpServletRequest(noticeData);
    if (req != null) {
      if (StringUtils.isNotEmpty(req.getRemoteUser())) {
        userId = req.getRemoteUser();
        noticeAudit.setRemoteAddr(req.getRemoteAddr());
        noticeAudit.setRemoteHost(req.getRemoteHost());
        noticeAudit.setRemoteUser(req.getRemoteUser());
      }
    }
    noticeAudit.setStackTrace(getStackTraceString());
    noticeAudit.setAddressing(formatAddresses(addresses));
    noticeAudit.setContentType(contentType);
    noticeAudit.setDeliveryMethod(deliveryMethod);
    noticeAudit.setTitleSubject(titleSubject);
    noticeAudit.setBody(body);
    noticeAudit.setCreationDate(rightNow);
    noticeAudit.setCreatedBy(userId);
    noticeAudit.setLastUpdate(rightNow);
    noticeAudit.setLastUpdateBy(userId);

    // save audit details
    noticeAuditManager.save(noticeAudit);
  }

There are some details behind a few of the properties of the log, some of which I consider done, and others that I consider acceptable for now, but could really use a little more attention at some point. The findHttpServletRequest method is particularly convoluted and could use some work, but my basic thought there was that I did not want to add the HttpServletRequest as yet another parameter in the API, but if I could find it, I wanted to use it to log a few things that you can find there. So, I set up this little routine to hunt through the noticeData object, which can be literally anything, in an effort to see if I could locate an HttpServletRequest object:

  /**
   * <p>Returns the HttpServletRequest, if it can be located.</p>
   *
   * @param noticeData optional data used to resolve variables in the notice
   * @return the HttpServletRequest, if it can be located
   */
  @SuppressWarnings("unchecked")
  private static HttpServletRequest findHttpServletRequest(Object noticeData) {
    HttpServletRequest request = null;

    try {
      // first, see if the noticeData is the request itself
      request = (HttpServletRequest) noticeData;
    } catch (ClassCastException e) {
      try {
        // next, see if the noticeData is a map
        Map noticeDataMap = (Map) noticeData;
        Iterator i = noticeDataMap.keySet().iterator();
        while (request == null && i.hasNext()) {
          Object key  = i.next();
          try {
            // then, see if the map element is the request object
            request = (HttpServletRequest) noticeDataMap.get(key);
          } catch (ClassCastException e1) {
            // ... and if not, see if the map element is another map
            Map noticeDataSubMap = (Map) noticeDataMap.get(key);
            Iterator j = noticeDataSubMap.keySet().iterator();
            while (request == null && j.hasNext()) {
              Object subkey  = j.next();
              try {
                // then, see if the map element's map element is the request object
                request = (HttpServletRequest) noticeDataSubMap.get(subkey);
              } catch (ClassCastException e2) {
                // ... and if that's not it, then give up!
              }
            }
          }
        }
      } catch (ClassCastException e1) {
        // no one cares
      }
    }

    return request;
  }

I didn’t put much thought into that one, and I should probably spend a little more time on that process at some point, but I think it will do the job for now. The other area that will need some work one day is the answer to the question “Should we log this?” Right now, I set up a global variable and answered the question in this way:

  /**
   * <p>Returns true if this notice should be audited.</p>
   *
   * @param sendFrom the "from" address
   * @param sendTo the list of objects representing the notice recipients
   * @param sendToProperty the name of the property in the recipient object
   * that specifies the "to" address. If this parameter is null or blank, it
   * is assumed that the sendTo list contains simple "to" address strings
   * @param noticeTemplate the notice template
   * @param noticeData optional data used to resolve variables in the notice
   * @return true if this notice should be audited
   */
  private boolean isAuditLogActive(String sendFrom, List<Object> sendTo, String sendToProperty,
         NoticeTemplate noticeTemplate, Object noticeData) {
    return "true".equals(auditNotifications);
  }

In the future, I’d like to provide some way to make that decision on more of a case-by-case basis, depending on such things as template id, from address, to address, delivery method, calling module, or maybe even some flag passed in some way that says “Audit this” or “Don’t audit this.” I hadn’t really thought any of that through to completion, so I just passed everything that I had available to this method and didn’t reference any of it for now, but stuck it all in there anyway, just so that I would have it available. (I know … that’s a bad thing to do, philosophically speaking, but I still did it!)

Turning auditing off and on is one of those critical little things that needs to be as flexible as possible. Auditing consumes a considerable amount of overhead and storage, and you need to be able to finely control what gets audited and what doesn’t if the feature is going to be of any use at all. My global yes-or-no for everything approach is good for testing, but there has to be something a lot more ganular than that, or it’s just going to be “No” always. There definitely needs to be a lot more work done in that area.

But not today!

package org.restafarian.notify.manager;

import java.util.Date;

import org.restafarian.notify.beans.NoticeAudit;
import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;

public class NoticeAuditManagerTest extends AbstractTransactionalDataSourceSpringContextTests {
  private NoticeAuditManager noticeAuditManager;

  public void setNoticeAuditManager(NoticeAuditManager noticeAuditManager) {
    this.noticeAuditManager = noticeAuditManager;
  }

  protected String[] getConfigLocations() {
    setAutowireMode(AUTOWIRE_BY_NAME);
    return new String[] {"classpath*:/context/applicationContext*.xml"};
  }

  protected void onSetUpInTransaction() throws Exception {
    deleteFromTables(new String[]{"noticetemplate"});
  }

  public void testGetNoticeAudits() {
    Date rightNow = new Date();
    String userId = "NoticeAuditEntryManagerTest";
    NoticeAudit noticeAudit1 = new NoticeAudit();
    noticeAudit1.setRemoteAddr("127.0.0.1");
    noticeAudit1.setRemoteHost("localhost");
    noticeAudit1.setRemoteUser("testuser");
    noticeAudit1.setStackTrace(getStackTraceString());
    noticeAudit1.setAddressing("mailFrom: testuser@localhost\nmailTo: testuser@localhost");
    noticeAudit1.setContentType("text/plain");
    noticeAudit1.setDeliveryMethod("email");
    noticeAudit1.setTitleSubject("This is a test audit.");
    noticeAudit1.setBody("This is a test audit.");
    noticeAudit1.setCreationDate(rightNow);
    noticeAudit1.setCreatedBy(userId);
    noticeAudit1.setLastUpdate(rightNow);
    noticeAudit1.setLastUpdateBy(userId);
    NoticeAudit noticeAudit2 = new NoticeAudit();
    noticeAudit2.setRemoteAddr("127.0.0.1");
    noticeAudit2.setRemoteHost("localhost");
    noticeAudit2.setRemoteUser("testuser");
    noticeAudit2.setStackTrace(getStackTraceString());
    noticeAudit2.setAddressing("mailFrom: testuser@localhost\nmailTo: testuser@localhost");
    noticeAudit2.setContentType("text/hmtl");
    noticeAudit2.setDeliveryMethod("email");
    noticeAudit2.setTitleSubject("This is another test audit.");
    noticeAudit2.setBody("<html><body><p>This is a test audit.</p><body></html>");
    noticeAudit2.setCreationDate(rightNow);
    noticeAudit2.setCreatedBy(userId);
    noticeAudit2.setLastUpdate(rightNow);
    noticeAudit2.setLastUpdateBy(userId);
    noticeAuditManager.save(noticeAudit1);
    noticeAuditManager.save(noticeAudit2);

    assertEquals(2, noticeAuditManager.findAll().size());
  }

  private String getStackTraceString() {
    StringBuffer buffer = new StringBuffer();

    String separator = "";
    StackTraceElement[] element = Thread.currentThread().getStackTrace();
    for (int i=0; i<element.length; i++) {
      buffer.append(separator);
      buffer.append(element[i].toString());
      separator = "\n";
    }

    return buffer.toString();
  }
}

… followed closely by the NoticeAuditManagerImplTest:

package org.restafarian.notify.manager.impl;

import java.util.Date;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jmock.Mock;
import org.jmock.MockObjectTestCase;
import org.restafarian.notify.beans.NoticeAudit;
import org.restafarian.notify.dao.NoticeAuditDao;
import org.restafarian.notify.manager.impl.NoticeAuditManagerImpl;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.ObjectRetrievalFailureException;

public class NoticeAuditManagerImplTest extends MockObjectTestCase {
  private final Log log = LogFactory.getLog(NoticeAuditManagerImplTest.class);
  private NoticeAuditManagerImpl mgr = new NoticeAuditManagerImpl();
  private Mock mockDao = null;

  protected void setUp() throws Exception {
    mockDao = new Mock(NoticeAuditDao.class);
    mgr.setNoticeAuditDao((NoticeAuditDao) mockDao.proxy());
  }

  public void testAddAndRemoveNoticeAudit() throws Exception {
    Date rightNow = new Date();
    String userId = "NoticeAuditEntryManagerImplTest";
    NoticeAudit noticeAudit = new NoticeAudit();
    noticeAudit.setRemoteAddr("127.0.0.1");
    noticeAudit.setRemoteHost("localhost");
    noticeAudit.setRemoteUser("testuser");
    noticeAudit.setStackTrace(getStackTraceString());
    noticeAudit.setAddressing("mailFrom: testuser@localhost\nmailTo: testuser@localhost");
    noticeAudit.setContentType("text/plain");
    noticeAudit.setDeliveryMethod("email");
    noticeAudit.setTitleSubject("This is a test audit.");
    noticeAudit.setBody("This is a test audit.");
    noticeAudit.setCreationDate(rightNow);
    noticeAudit.setCreatedBy(userId);
    noticeAudit.setLastUpdate(rightNow);
    noticeAudit.setLastUpdateBy(userId);

    // set expected behavior on dao
    mockDao.expects(once()).method("save").with(same(noticeAudit));

    mgr.save(noticeAudit);

    // verify expectations
    mockDao.verify();

    assertEquals(noticeAudit.getTitleSubject(), "This is a test audit.");

    if (log.isDebugEnabled()) {
      log.debug("removing noticeAudit ...");
    }

    int id = noticeAudit.getId();
    mockDao.expects(once()).method("delete").with(eq(noticeAudit));

    mgr.delete(noticeAudit);

    // verify expectations
    mockDao.verify();

    try {
      // set expectations
      Throwable ex = new ObjectRetrievalFailureException(NoticeAudit.class, new Integer(id));
      mockDao.expects(once()).method("findById").with(eq(new Integer(id)))
           .will(throwException(ex));

      noticeAudit = mgr.findById(id);

      // verify expectations
      mockDao.verify();
      fail("NoticeAudit 'testtemplate1' found in database");
    } catch (DataAccessException dae) {
      log.debug("Expected exception: " + dae.getMessage());
      assertNotNull(dae);
    }
  }

  private String getStackTraceString() {
    StringBuffer buffer = new StringBuffer();

    String separator = "";
    StackTraceElement[] element = Thread.currentThread().getStackTrace();
    for (int i=0; i<element.length; i++) {
      buffer.append(separator);
      buffer.append(element[i].toString());
      separator = "\n";
    }

    return buffer.toString();
  }
}

That takes care of the service layer for the audit log, so now I guess all that is left is to actually do something with it. Time to start taking a second look at the Notifier …

package org.restafarian.notify.manager;

import java.util.List;

import org.restafarian.notify.beans.NoticeAudit;

/**
 * <p>This is the NoticeAudit manager interface.</p>
 */
public interface NoticeAuditManager {

  /**
   * <p>Returns all NoticeAudits in the database.</p>
   *
   * @return all NoticeAudits in the database
   */
  public List<NoticeAudit> findAll();

  /**
   * <p>Returns all NoticeAudits in the database that
   * match the specified search criteria.</p>
   *
   * @param noticeAudit an example NoticeAudit
   * @return all NoticeAudits in the database that
   * match the specified search criteria
   */
  public List<NoticeAudit> findByExample(NoticeAudit noticeAudit);

  /**
   * <p>Returns all NoticeAudits in the database that
   * match the specified search criteria.</p>
   *
   * @param propertyName the name of the specified property
   * @param propertyValue the search value for the specified
   * property
   * @return all NoticeAudits in the database that
   * match the specified search criteria
   */
  public List<NoticeAudit> findByProperty(String propertyName, Object propertyValue);

  /**
   * <p>Returns the NoticeAudit with the specified id.</p>
   *
   * @param id the id of the requested noticeAudit
   * @return the NoticeAudit with the specified id
   */
  public NoticeAudit findById(int id);

  /**
   * <p>Saves the NoticeAudit passed.</p>
   *
   * @param noticeAudit the noticeAudit to save
   */
  public void save(NoticeAudit noticeAudit);

  /**
   * <p>Deletes the NoticeAudit with the specified id.</p>
   *
   * @param noticeAudit the noticeAudit to delete
   */
  public void delete(NoticeAudit noticeAudit);
}

… and here is the concrete implementation:

package org.restafarian.notify.manager.impl;

import java.util.List;

import org.restafarian.notify.beans.NoticeAudit;
import org.restafarian.notify.dao.NoticeAuditDao;
import org.restafarian.notify.manager.NoticeAuditManager;

/**
 * <p>Concrete implementation of the NoticeAudit manager interface.</p>
 */
public class NoticeAuditManagerImpl implements NoticeAuditManager {
  private NoticeAuditDao dao;

  /**
   * <p>Returns all NoticeAudits in the database.</p>
   *
   * @return all NoticeAudits in the database
   */
  public List<NoticeAudit> findAll() {
    return dao.findAll();
  }

  /**
   * <p>Returns all NoticeAudits in the database that
   * match the specified search criteria.</p>
   *
   * @param noticeAudit an example NoticeAudit
   * @return all NoticeAudits in the database that
   * match the specified search criteria
   */
  public List<NoticeAudit> findByExample(NoticeAudit noticeAudit) {
    return dao.findByExample(noticeAudit);
  }

  /**
   * <p>Returns all NoticeAudits in the database that
   * match the specified search criteria.</p>
   *
   * @param propertyName the name of the specified property
   * @param propertyValue the search value for the specified
   * property
   * @return all NoticeAudits in the database that
   * match the specified search criteria
   */
  public List<NoticeAudit> findByProperty(String propertyName, Object propertyValue) {
    return dao.findByProperty(propertyName, propertyValue);
  }

  /**
   * <p>Returns the NoticeAudit with the specified id.</p>
   *
   * @param id the id of the requested noticeAudit
   * @return the NoticeAudit with the specified id
   */
  public NoticeAudit findById(int id) {
    return dao.findById(new Integer(id));
  }

  /**
   * <p>Saves the NoticeAudit passed.</p>
   *
   * @param noticeAudit the noticeAudit to save
   */
  public void save(NoticeAudit noticeAudit) {
    dao.save(noticeAudit);
  }

  /**
   * <p>Deletes the NoticeAudit with the specified id.</p>
   *
   * @param noticeAudit the noticeAudit to delete
   */
  public void delete(NoticeAudit noticeAudit) {
    dao.delete(noticeAudit);
  }

  public void setNoticeAuditDao(NoticeAuditDao dao) {
    this.dao = dao;
  }
}

All we need now is a couple of unit tests, and we can call this portion of the audit process complete!

package org.restafarian.core.dao.hibernate;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.util.Assert;

public abstract class AbstractHibernateDao<E> {
  private final Class<E> entityClass;
  private final SessionFactory sessionFactory;

  /**
   * <p>Constructs a new <code>AbstractHibernateDao</code> using the
   * parameters provided.</p>
   */
  public AbstractHibernateDao(Class<E> entityClass, SessionFactory sessionFactory) {
    Assert.notNull(entityClass, "entityClass must not be null");
    Assert.notNull(sessionFactory, "sessionFactory must not be null");
    this.entityClass = entityClass;
    this.sessionFactory = sessionFactory;
  }

  /**
   * <p>Returns all entities in the database.</p>
   *
   * @return all entities in the database
   */
  public List<E> findAll() {
    return all();
  }

  /**
   * <p>Returns all entities in the database that
   * match the specified search criteria.</p>
   *
   * @param referenceObject an example entity
   * @return all entities in the database that
   * match the specified search criteria
   */
  public List<E> findByExample(E referenceObject) {
    Example example = Example.create(referenceObject);
    example.excludeProperty("id");
    return list(criteria().add(example));
  }

  /**
   * <p>Returns all entities in the database that
   * match the specified search criteria.</p>
   *
   * @param propertyName the name of the specified property
   * @param propertyValue the search value for the specified
   * property
   * @return all entities in the database that
   * match the specified search criteria
   */
  public List<E> findByProperty(String propertyName, Object propertyValue) {
    return list(criteria().add(Restrictions.eq(propertyName, propertyValue)));
  }

  /**
   * <p>Returns the entity with the specified id.</p>
   *
   * @param id the id of the requested entity
   * @return the entity with the specified id
   */
  public E findById(Serializable id) {
    E requestedObject = get(id);
    if (requestedObject == null) {
      throw new ObjectRetrievalFailureException(entityClass, id);
    }
    return requestedObject;
  }

  /**
   * <p>Returns the entity class.</p>
   *
   * @return the entity class
   */
  public Class<E> getEntityClass() {
    return entityClass;
  }

  /**
   * <p>Returns a Hibernate Criteria object for the current session.</p>
   *
   * @return a Hibernate Criteria object for the current session
   */
  protected Criteria criteria() {
    return currentSession().createCriteria(entityClass);
  }

  /**
   * <p>Returns a Hibernate Query object for the current session.</p>
   *
   * @return a Hibernate Query object for the current session
   */
  protected Query query(String hql) {
    return currentSession().createQuery(hql);
  }

  /**
   * <p>Returns the current session.</p>
   *
   * @return the current session
   */
  protected Session currentSession() {
    return sessionFactory.getCurrentSession();
  }

  /**
   * <p>Returns all objects of this entity.</p>
   *
   * @return all objects of this entity
   */
  protected List<E> all() {
    return list(criteria());
  }

  /**
   * <p>Returns all objects of this entity that match the specified criteria.</p>
   *
   * @param criteria the search criteria
   * @return all objects of this entity that match the specified criteria
   */
  @SuppressWarnings("unchecked")
  protected List<E> list(Criteria criteria) {
    return criteria.list();
  }

  /**
   * <p>Returns all objects of this entity that satisfy the specified query.</p>
   *
   * @param query the search query
   * @return all objects of this entity that satisfy the specified query
   */
  @SuppressWarnings("unchecked")
  protected List<E> list(Query query) {
    return query.list();
  }

  /**
   * <p>Returns a single instance of this entity that matches the specified
   * criteria.</p>
   *
   * @param criteria the search criteria
   * @return a single instance of this entity that matches the specified
   * criteria
   */
  @SuppressWarnings("unchecked")
  protected E uniqueResult(Criteria criteria) {
    return (E) criteria.uniqueResult();
  }

  /**
   * <p>Returns a single instance of this entity that satisfies the specified
   * query.</p>
   *
   * @param query the search query
   * @return a single instance of this entity that satisfies the specified
   * query
   */
  @SuppressWarnings("unchecked")
  protected E uniqueResult(Query query) {
    return (E) query.uniqueResult();
  }

  /**
   * <p>Returns the instance of this entity with the specified id.</p>
   *
   * @param id the id of the requested entity
   * @return the instance of this entity with the specified id
   */
  @SuppressWarnings("unchecked")
  protected E get(Serializable id) {
    return (E) currentSession().get(entityClass, id);
  }
}

… and stuck them into here:

package org.restafarian.core.dao.hibernate;

import org.hibernate.SessionFactory;

/**
 * <p>Extends the <code>AbstractHibernateDao</code> to create an update version,
 * adding standard data maintenance methods.</p>
 */
public abstract class AbstractHibernateUpdateDao<E> extends AbstractHibernateDao<E> {

  /**
   * <p>Constructs a new <code>AbstractHibernateUpdateDao</code> using the
   * parameters provided.</p>
   */
  public AbstractHibernateUpdateDao(Class<E> entityClass, SessionFactory sessionFactory) {
    super(entityClass, sessionFactory);
  }

  /**
   * <p>Saves the entity passed.</p>
   *
   * @param entity the entity to save
   */
  public void save(E entity) {
    currentSession().saveOrUpdate(entity);
  }

  /**
   * <p>Deletes the entity.</p>
   *
   * @param entity the entity to delete
   */
  public void delete(E entity) {
    currentSession().delete(entity);
  }
}

Now the original is a “read only” version which can be extended to create read-only DAOs, and the abstract extension of that throws in the data maintenance methods, so that one can be used as the basis for DAOs that actually manipulate the data. Since all of the DAOs that I built by extending the original were data maintenance DAOs, I had to go back into each one and extend the new one instead of the old one, but that all went pretty quick and now it’s done.

At this point, I am calling the DAO refactoring project both complete and a success, and now I am going to get back to whatever it was that I was doing prior to the start of this little detour.

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO] ------------------------------------------------------------------------
[INFO] example-parent ........................................ SUCCESS [14.063s]
[INFO] core .................................................. SUCCESS [50.671s]
[INFO] approval .............................................. SUCCESS [7.250s]
[INFO] approval-web .......................................... SUCCESS [17.391s]
[INFO] authorization ......................................... SUCCESS [9.531s]
[INFO] authorization-web ..................................... SUCCESS [18.016s]
[INFO] core-web .............................................. SUCCESS [16.937s]
[INFO] example-web ........................................... SUCCESS [23.110s]
[INFO] identity-web .......................................... SUCCESS [1:26.375s]
[INFO] notify ................................................ SUCCESS [47.562s]
[INFO] notify-web ............................................ SUCCESS [28.469s]
[INFO] example ............................................... SUCCESS [4:47.734s]
[INFO] ------------------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10 minutes 25 seconds
[INFO] Finished at: Thu Dec 04 17:45:29 PST 2008
[INFO] Final Memory: 12M/45M
[INFO] ------------------------------------------------------------------------

Now every project boasts this new addition to its pom.xml file, in addition to all of the little things that had to come along to accommodate that:

    <plugins>
       <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>
    </plugins>

That should just about finish up the whole refactoring process, although I still think I want to split up the abstract Hibernate DAO into a read-only version and an extension of that for the update version. That should be pretty simple though, and then I can get back to what it was that I was doing before I started down this road of overhauling everything.

Let’s see now, just what was I doing before that …

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1 minute 41 seconds
[INFO] Finished at: Tue Dec 02 18:41:45 PST 2008
[INFO] Final Memory: 16M/39M
[INFO] ------------------------------------------------------------------------

My goal was to resolve all of the warning messages that had cropped up in the core project once I changed the Java version to 5.0, but I have to admit that after a while I got a little lazy and just slipped in the old @SuppressWarnings(”unchecked”) in more places than are really appropriate, just to speed up my journey to “done”. Also, it didn’t help that I had stubbed out the findByTableIdEntryId method (”return null;”) in the LookupTableEntryDaoHibernate the other day and forgot to go back and actually put in the code to return valid results. That had me running around in circles for a while trying to figure out why the testFindByTableIdEntryId kept returning nothing when I knew damn well that there was data in the database, but eventually I managed to figure that out.

So, that takes care of one my many little interrelated projects … now I just have to go through all of the others and do the same thing!

package org.restafarian.core.dao.hibernate;

import org.hibernate.SessionFactory;
import org.restafarian.core.beans.LookupTable;
import org.restafarian.core.dao.LookupTableDao;

/**
 * <p>This is the LookupTable data access object.</p>
 */
public class LookupTableDaoHibernate extends AbstractHibernateDao<LookupTable>
       implements LookupTableDao {

  /**
   * <p>Constructs a new LookupTableDaoHibernate using the parameters provided.</p>
   */
  public LookupTableDaoHibernate(SessionFactory sessionFactory) {
    super(LookupTable.class, sessionFactory);
  }
}

… and this:

package org.restafarian.core.dao.hibernate;

import org.hibernate.SessionFactory;
import org.restafarian.core.beans.LookupTableEntry;
import org.restafarian.core.dao.LookupTableEntryDao;

/**
 * <p>This is the LookupTableEntry data access object.</p>
 */
public class LookupTableEntryDaoHibernate extends AbstractHibernateDao<LookupTableEntry>
       implements LookupTableEntryDao {

  /**
   * <p>Constructs a new LookupTableEntryDaoHibernate using the parameters provided.</p>
   */
  public LookupTableEntryDaoHibernate(SessionFactory sessionFactory) {
    super(LookupTableEntry.class, sessionFactory);
  }

  /**
   * <p>Returns the LookupTableEntry with the specified table id
   * and entry id.</p>
   *
   * @param id the id of the requested look-up table
   * @param id the id of the requested entry
   * @return the requested LookupTableEntry
   */
  public LookupTableEntry findByTableIdEntryId(String tableId, String entryId) {
    return null;
  }
}

Much smaller than the originals, which I like, but since I changed the interface just a tad, I now have to go back and rework the service layer and the unit tests to sync everything back up.

Good Mr. Krueger has also provided some even more useful suggestions, so I’ll be taking a look at those as well. I had originally thought about dumping the old .hbm.xml files in favor of annotations back when I started this refactoring process, which I still intend to do, but I wanted to limit myself to just one set of new things at a time while I worked my way through the DAO enhancements. With these other suggestions, now may be a good point to go back yet again, and make the move to annotations at the same time.

But first I think I have a little work to do with all of the rest of my little parts and pieces now that I have brought a couple of the projects in the pile up to Java 5 and left the rest behind. I think I better work on bringing everything else in the portfolio up-level as well, and then see if I can make my way through a full build! That may take a little time …