These stub classes are easy to construct, and can be useful for quick mock ups. They require less effort than providing true persistance. By following the style shown below, for example, a pseudo-DAO could be constructed in 15 minutes.

This example pseudo-DAO implements pseudo-persistence for Person objects. The intent is to create a pseudo-DAO whose API will match the final, true DAO. Thus, the same class can evolve from a mock up into a final  implementation, without affecting the caller in any way.

The underlying technique is simply to store objects in a static member of the pseudo-DAO. In this case, a Map is used.

package myapp.data;

import java.util.*;

import myapp.business.Person;

/**
* Provides "pseudo-persistance", by storing objects as static data attached to this
* class. Such data is lost when the application is shut down, but is retained
* as long as the application is running.
*
* <P>An alternate style would be to use static, synchronized methods. This would
* be appropriate if the DAO implementation is used directly by the caller, as in
* <tt>PersonDAO.fetch(name)</tt>, instead of via a factory. The important thing
* is to match the desired style of the true DAO into which this pseudo-DAO
* will evolve.
*
* <P>Note that <tt>DataAccessException</tt> (a checked exception) can and should
* be declared in the throws clause, even when the underlying implementation for
* this pseudo-DAO never throws such an exception. Again, the idea is to provide
* a stub which, from the point of view of the caller, is as realistic as possible.
*/
public final class PersonDAO {

  /**
  * Add <tt>aPerson</tt> to the datastore, returning an indicator of
  * success or failure.
  *
  * If <tt>aPerson</tt> already exists in the datastore, then return false.
  */
  public boolean add(Person aPerson) throws DataAccessException {
    boolean result = false;
    synchronized(fPersons) {
      if ( ! fPersons.containsKey(aPerson.getName()) ) {
        fPersons.put(aPerson.getName(), aPerson);
        result = true;
        log("Persons after add: " + fPersons);
      }
    }
    return result;
  }

  /**
  * Fetch a person from the datastore, using <tt>aName</tt> as a unique
  * identifier.
  *
  * <P>If no <tt>Person</tt> is found, return null.
  */
  public Person fetch(String aName) throws DataAccessException {
    Person result = null;
    synchronized(fPersons){
      if( fPersons.containsKey(aName) ){
        result = (Person)fPersons.get(aName);
      }
      log("Persons during fetch: " + fPersons);
    }
    return result;
  }

  /**
  * Update the data associated with <tt>aPersons</tt>, returning an
  * indicator of success or failure.
  *
  * <P>If <tt>aPerson</tt> is not found in the datastore, then return false.
  */
  public boolean change(Person aPerson) throws DataAccessException {
    boolean result = false;
    synchronized(fPersons){
      if ( fPersons.containsKey(aPerson.getName()) ) {
        fPersons.put(aPerson.getName(), aPerson); //replaces old entry
        result = true;
        log("Persons after change: " + fPersons);
      }
    }
    return result;
  }

  /**
  * Delete the <tt>Person</tt> identified uniquely by <tt>aName</tt>,
  * returning an indicator of success or failure.
  *
  * <P>If <tt>aName</tt> is not found in the datastore, then return false.
  */
  public boolean delete(String aName) throws DataAccessException {
    boolean result = false;
    synchronized(fPersons){
      if ( fPersons.containsKey(aName) ) {
        fPersons.remove(aName);
        result = true;
        log("Persons after delete: " + fPersons);
      }
    }
    return result;
  }

  // PRIVATE //

  /**
  * Stores Person objects in a static field, attached to this class, which will
  * remain available as long as this class remains loaded.
  *
  * <P>Keys - String containing the Person's name.<br>
  * Values - Person object.
  */
  private static Map fPersons = new LinkedHashMap();

  private void log(String aText){
    System.out.println(aText);
  }
}