How to Use Spring AOP for Auditing?

[Phoenix Kilimba]

Dear Sirs et Madames;

I have an application in which there are a number of persistent entities. All these entities have a few things in common, they all have the fields insertedBy, insertedDate.

The insertedBy field is the currently logged in user. My Dao interface looks like so:

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

/**
 * From the article http://www.ibm.com/developerworks/java/library/j-genericdao.html
 * <BR><BR>
 * A typesafe interface.<BR>
 * All database access in the system is made through a DAO to achieve encapsulation.<BR>
 * Each DAO instance is responsible for one primary domain object or entity.<BR>
 * If a domain object has an independent lifecycle, it should have its own DAO.<BR>
 * The DAO is responsible for creations, reads (by primary key), updates, and 
 * deletions -- that is, CRUD -- on the domain object.<BR>
 * The DAO may allow queries based on criteria other than the primary key such as 
 * finder methods or finders.<BR>
 * The return value of a finder is normally a collection of the domain object for
 * which the DAO is responsible.<BR>
 * The DAO is not responsible for handling transactions, sessions, or connections. 
 * These are handled outside the DAO to achieve flexibility.
 */
public interface Dao<T, PK extends Serializable> {

    /** Persist the newInstance object into the database */
    PK create(T newInstance);

    /** Retrieve an object that was previously persisted to the
     * database using the indicated id as primary key */
    T read(PK id);

    /** Save changes made to a persistent object */
    void update(T transientObject);

    /** Remove an object from persistent storage in the database */
    void delete(T persistentObject);

    /** Retrieve the total number of unique entities in the database */
    int getTotalCount();

    /** Retrieve an entity with the specified propertyName with the
     * associated value */
    T findByProperty(String propertyName, Object value);

    /** Retrieve a list of all objects of the DAO's entityType */
    List<T> findAll();
    
    /** Closes current session */
    void closeCurrentSession();
    
    public T merge(T newInstance);
   
    public void saveOrUpdate(T newInstance);
   
    public void flush();    
    
    
    /** Retrieve a list of all objects of the DAO's entityType and also
     * limit the number or results returned specified by the index of
     * firstResult and the amount of maxResults */
    List<T> findPaged(int maxResults, int firstResult);

    List<T> findListByProperty(String propertyName, Object value);

    List<T> findByExample(T exampleInstance, String... excludeProperty);
}
  

and my EntityCrud Interface looks like so:

    
/**
 * Interface that represents the actions the user can take when using
 * the front end for a specific entity (i.e. Location)
 * 
 * This interface acts as a controller between the front end and the back end
 *
 * @param <T> The type of entity
 * @param <PK> The primary key type (i.e. java.lang.Long) for a given entity type
 */
public interface EntityCrud<T, PK extends Serializable> {

    void setDao(Dao<T, PK> dao);

    PagingState getPager();

    /**
     * Action to direct user to the full list of entities for a given entity type
     * @return
     */
    String listSetup();

    /**
     * Action to direct user to the form to create a new entity
     * @return
     */
    String createSetup();

    /**
     * Action that is called when user creates a new entity
     * @return
     */
    String create();

    /**
     * Action to direct user to the form displaying details for an entity
     * @return
     */
    String detailSetup();

    /**
     * Action to direct user to the edit form for an entity
     * @return
     */
    String editSetup();

    /**
     * Action that is called when user saves an entity from the edit entity form
     * @return
     */
    String edit();

    /**
     * Action that is called when user wants to delete an entity
     * @return
     */
    String delete();

    String next();

    String prev();

    /**
     * Get the current entity item
     * Used mostly inside the JSF pages when binding a component to a value
     * @return
     */
    T getItem();

    List<T> getPagedItems();

    SelectItem[] getSelectItems();

    void setConverter(EntityConverter<T> converter);

    EntityConverter<T> getConverter();

    void validateCreate(FacesContext facesContext, UIComponent component,
            Object value);

    public void setItem(T entityItem);
    
}

EntityCrudImpl looks like:

@Transactional
public class EntityCrudImpl<T , PK extends Serializable> implements
        EntityCrud<T, PK> {

    static Log log = LogFactory.getLog(EntityCrudImpl.class);
    // This is currently being used to create a new
    // instance of the entity type
    Class<T> entityClass;
    String outcomePrefix;
    // The current entity (or "backing bean") being worked on
    // wired from the applicationContext.xml file
    T entityItem;
    PagingState pager;
    Dao<T, PK> dao;
    List<T> pagedItems;
    // used to convert an entity from a string to object, or
    // object to a string
    EntityConverter<T> converter;
    // helper service
    JsfService jsfService;
    protected CurrentUser currentUser;

    public EntityCrudImpl(Class<T> entityClass) {
        if (entityClass == null) {
            throw new IllegalArgumentException(
                    "entity class type required for crud");
        }
        if (log.isDebugEnabled()) {
            log.debug("creating crud for class: " + entityClass.getName());
        }
        this.entityClass = entityClass;
        this.outcomePrefix = entityClass.getSimpleName().toLowerCase();
        pager = new PagingState();
    }

    public void setJsfService(JsfService jsfService) {
        this.jsfService = jsfService;
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#setDao(is.dao.Dao)
     */
    public void setDao(Dao<T, PK> dao) {
        this.dao = dao;
    }

    public Dao<T, PK> getDao() {
        return dao;
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#getPager()
     */
    public PagingState getPager() {
        if (pager.getTotalCount() < 0) {
            pager.setTotalCount(dao.getTotalCount());
        }
        return pager;
    }

    /**
     * Create a new instance of the entity type
     * @return the new object instance
     */
    protected T newInstance() {
        try {
            return entityClass.newInstance();
        } catch (Exception e) {
            throw new FacesException("failed to instantiate entity "
                    + entityClass.getName(), e);
        }
    }

    /**
     *
     * @param resetPaging
     */
    protected void reset(boolean resetPaging) {
        entityItem = null;
        pager.setTotalCount(-1);
        pagedItems = null;
        if (resetPaging) {
            pager.setPageIndex(0);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#listSetup()
     */
    public String listSetup() {
        reset(true);
        return outcomePrefix + "_list";
    }

    /**
     *
     */
    public void validateCreate(FacesContext facesContext,
            UIComponent component, Object value) {
        T newItem = null;
        try {
            newItem = entityClass.newInstance();
        } catch (Exception e) {
            log.error("failed to create item instance", e);
        }
        String newItemString = converter.getAsString(FacesContext.getCurrentInstance(), null, newItem);
        String itemString = converter.getAsString(FacesContext.getCurrentInstance(), null, entityItem);
        if (!newItemString.equals(itemString)) {
            createSetup();
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#createSetup()
     */
    public String createSetup() {
        reset(false);
        entityItem = newInstance();
        return outcomePrefix + "_create";
    }

    /**
     * Persist the current entity item to the database
     */
    public String create() {
        try {
            performAudit(entityItem);
            dao.create(entityItem);
            jsfService.addMessage("Item was successfully created.");
        } catch (Exception e) {
            jsfService.addError(e.getMessage());
            return null;
        }
        return listSetup();
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#detailSetup()
     */
    public String detailSetup() {
        return scalarSetup(outcomePrefix + "_detail");
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#editSetup()
     */
    public String editSetup() {
        return scalarSetup(outcomePrefix + "_edit");
    }

    /**
     * Update a persisted entity
     */
    public String edit() {
        // convert the current entity item to a string
        String itemString = converter.getAsString(FacesContext.getCurrentInstance(), null, entityItem);
        String itemId = jsfService.getReqParam("itemId");
        // verify the edited item is valid
        if (itemString == null || itemString.length() == 0
                || !itemString.equals(itemId)) {
            String outcome = editSetup();
            if ((outcomePrefix + "_edit").equals(outcome)) {
                jsfService.addError("Could not edit item. Try again.");
            }
            return outcome;
        }
        // attempt to update
        try {
            dao.update(entityItem);
            jsfService.addMessage("Item was successfully updated.");
        } catch (Exception e) {
            jsfService.addError(e.getMessage());
            return null;
        }
        return detailSetup();
    }

    /**
     * Remove/delete an entity from persistence
     */
    public String delete() {
        T persistentObject = converter.getAsObject(FacesContext.getCurrentInstance(), null, jsfService.getReqParam("itemId"));
        try {
            dao.delete(persistentObject);
            jsfService.addMessage("Item was successfully deleted.");
        } catch (Exception e) {
            jsfService.addError(e.getMessage());
            return null;
        }
        return listSetup();
    }

    @SuppressWarnings("unchecked")
    protected String scalarSetup(String outcome) {
        reset(false);
        entityItem = (T) jsfService.getObjViaReqParam("itemId", converter, null);
        if (entityItem == null) {
            String itemId = jsfService.getReqParam("itemId");
            jsfService.addError("The item with id " + itemId
                    + " no longer exists.");
        }
        return outcome;
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#next()
     */
    public String next() {
        reset(false);
        getPager().nextPage();
        return outcomePrefix + "_list";
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#prev()
     */
    public String prev() {
        reset(false);
        getPager().previousPage();
        return outcomePrefix + "list";
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#getItem()
     */
    public T getItem() {
        if (entityItem == null) {
            entityItem = newInstance();
        }
        return entityItem;
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#getPagedItems()
     */
    public List<T> getPagedItems() {
        if (pagedItems == null) {
            pagedItems = dao.findPaged(pager.getPageIncrement(), pager.getPageIndex());
        }
        return pagedItems;
    }

    public SelectItem[] getSelectItems() {
        return jsfService.getSelectItems(dao.findAll());
    }

    /*
     * Return SelectItem for a subset of enitities depending on the value of a
     * property being searched on
     */
    public SelectItem[] getSelectItemsByProperty(String propertyName, Object value) {
        return jsfService.getSelectItems(dao.findListByProperty(propertyName, value));
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#setConverter(javax.faces.convert.Converter)
     */
    public void setConverter(EntityConverter<T> converter) {
        this.converter = converter;
    }

    /*
     * (non-Javadoc)
     *
     * @see is.webui.EntityCrud#getConverter()
     */
    public EntityConverter<T> getConverter() {
        return converter;
    }

    public void setItem(T entityItem) {
        this.entityItem = entityItem;
    }

    public CurrentUser getCurrentUser() {
        return currentUser;
    }

    public void setCurrentUser(CurrentUser currentUser) {
        this.currentUser = currentUser;
    }

}

  

My question is: I need the two properties of an entityItem insertedBy, insertedDate updated whenever the create() method (which effectively is the method which persists the entityItem) is called. I got it into my head to use Spring AOP and to create an aspect to achieve this, however as am kind of new to Spring AOP could anyone tell me how this could be achieved, and the merits of using aspects to achieve it? Is there an example where one has used aspects for auditing which I could maybe have a look at?

Any help would be greatly appreciated.

[David Newton]

Too much code, too many comments: particular when asking non-specific questions, post *only* what is specifically necessary to provide information useful to answering the question.

Why do you want an aspect for this? Why not just code it somewhere?

[Phoenix Kilimba]

Sorry about the code that goes on and on, I tried just coding it, however, ALL persistent entities have these two fields, but not all persistent entities share a parent superclass. So the problem becomes, should I hard code this logic directly into each entityDao (repetitive, always the same code) or is there someway I can centralise the code to avoid repetitiveness (Inheriting from a superclass would be the first choice but that forces some classes which dont always fit the IS-A criteria being forced to inherit from a superclass) , so I thought Aspects may allow me to write once and call where needed. Hope I explained that well enough, please let me know if you need any more info.

Thanks again in advance

[David Newton]

Have them implement an interface.

I'm not saying not to do it with aspects, but you'd have the same problem with the class hierarchy unless you had as aspect for each type. At that point the complexity of an AOP solution outweighs just doing it normally.

[Phoenix Kilimba]

David Newton wrote:Have them implement an interface.

I'm not saying not to do it with aspects, but you'd have the same problem with the class hierarchy unless you had as aspect for each type. At that point the complexity of an AOP solution outweighs just doing it normally.

Well correct me if am wrong, but I thought I could avoid having an aspect for each type if I had the create() method in EntityCrudImpl as the join point. Would that not avoid the repetitious code, would that not work?

Thanks again

[David Newton]

I thought you were saying that you didn't have a consistent interface to get the values to update--how would you call the setters for update date etc. from the aspect?

[Phoenix Kilimba]

Sorry for the late response, I had left the office. Well the Aspect class looks like so:

 
public class Auditor {
    /** Spring Injected */
    private CurrentUser currentUser;

    public void setInsertBy(Object entityItem) {
        try {
            Method method = null;
            try {
                method = entityItem.getClass().getMethod("setInsertBy", User.class);
            } catch (NoSuchMethodException ex) {
                Logger.getLogger(Auditor.class.getName()).log(Level.SEVERE, null, ex);
            } catch (SecurityException ex) {
                Logger.getLogger(Auditor.class.getName()).log(Level.SEVERE, null, ex);
            }
            method.invoke(entityItem, currentUser.getCurrentUser());
        } catch (IllegalAccessException ex) {
            Logger.getLogger(Auditor.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(Auditor.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(Auditor.class.getName()).log(Level.SEVERE, null, ex);
        }


    }

    public CurrentUser getCurrentUser() {
        return currentUser;
    }

    public void setCurrentUser(CurrentUser currentUser) {
        this.currentUser = currentUser;
    }
}
   

And is configured in applicationContext.xml like so:

   
<!-- Simple bean which will later be used as an aspect -->
    <bean id="auditor" class="org.openhds.webui.util.Auditor" >
        <property name="currentUser" ref="currentUser" />
    </bean>

    <!-- Aspect definition -->
    <aop:config>

        <aop:aspect ref="auditor">

            <aop:pointcut id="insertByMethod"
                          expression="execution(* org.openhds.webui.EntityCrud.performAudit(java.lang.Object))
                          and args(entityItem)"/>

            <aop:before pointcut-ref="insertByMethod" method="setInsertBy"/>

        </aop:aspect>

    </aop:config>

 

Any observations or criticisms greatly appreciated, all part of the learning process :-) !
Thanks again

[David Newton]

Sure, using reflection would work.

I'm still not convinced I wouldn't just create an "Auditable" interface, but like I said--whatever works :)