Question

I have the following two classes and I am starting to see a pattern that even with my little Java background is screaming for a fix. Every new Object is going to require a set of Actions and the number of classes could grow out of hand. How do I refactor this into a generic DeleteAction class?

I know some of the answers will be use Hibernate, or JPA, or some Framework, but at the moment I can’t utilize any of those tools. Oh, and our server only has jdk 1.4 (don’t ask!). Thanks.

public class DeleteCommitmentAction implements ControllerAction {

  public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException {

    CommitmentListDAO clDAO = new CommitmentListDAO();
    CommitmentItemForm ciForm = new CommitmentItemForm(clDAO);
    CommitmentItem commitmentItem = ciForm.deleteCommitmentItem(request);

    RequestDispatcher view = request.getRequestDispatcher("views/commitmentView_v.jsp");
    view.forward(request, response);
  }
}

.

public class DeleteProgramAction implements ControllerAction {

  public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException {

    ProgramDAO prgDAO = new ProgramDAO();
    ProgramForm prgForm = new ProgramForm(prgDAO); 
    ProgramForm prg = prgForm.deleteProgram(request);

    RequestDispatcher view = request.getRequestDispatcher("views/programView_v.jsp");
    view.forward(request, response);
  }
}

The approach that I think I need to take is to make interfaces. Starting with the DAO, I have created the following interface.

public interface GenericDao {
  public void create(Object object, STKUser authenticatedUser) throws DAOException;
  public void retreive(String id, STKUser authenticatedUser) throws DAOException;
  public void update( final Object object, STKUser authenticatedUser) throws DAOException;
  public void delete(String id, STKUser authenticatedUser) throws DAOException;
}

And then in my DeleteAction class I tried this

GenericDao gDAO = new GenericDao();

but Eclipse is stating “Cannot instantiate the type GenericDao” So now I am lost.

Update: Based on Péter Török’s answer, here is what I have:

This is the servlet specific for handling operations on Commitment Items:

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String schema = General_IO.getSchemaPath("TPQOT_463_COMMITMENT", request.getServerName());
    CommitmentListDAO clDAO = new CommitmentListDAO();
    CommitmentItemForm ciForm = new CommitmentItemForm(clDAO);
    CommitmentItem commitmentItem = new CommitmentItem();

    // I think this is the Application Controller Strategy
    actionMap.put(null, new ListCommitmentsAction());
    actionMap.put("list", new ListCommitmentsAction());
    actionMap.put("view", new ViewCommitmentItemAction(schema));
    //actionMap.put("delete", new DeleteCommitmentAction(schema));
    // Change to the Generic DeleteAction and pass in the parameters
    actionMap.put("delete", new DeleteAction(ciForm, commitmentItem, schema,  "views/commitmentDeleteConfirm_v.jsp",  "views/commitmentView_v.jsp" ));
    // When happy with this approach, change other actions to the Generic Versions.


    actionMap.put("sqlConfirmDelete", new DeleteCommitmentConfirmAction());
    actionMap.put("edit", new EditCommitmentItemAction(schema));
    actionMap.put("sqlUpdate", new UpdateCommitmentItemAction1(schema));
    actionMap.put("new", new NewCommitmentFormAction(schema));
    actionMap.put("sqlInsert", new InsertCommitmentItemAction1(schema));

    String op = request.getParameter("method");
    ControllerAction action = (ControllerAction) actionMap.get(op);

    if (action != null) {
        action.service(request, response);
    } else {
        String url = "views/errorMessage_v.jsp";
        String errMessage = "Operation '" + op + "' not a valid for in '" + request.getServletPath() + "' !!";
        request.setAttribute("message", errMessage);
        request.getRequestDispatcher(url).forward(request, response);
    }
}

And here is the Generic DeleteAction:

public class DeleteAction implements ControllerAction {

  private Form form;
  private Object obj;
  private String schema = null;
  private String xPage;
  private String yPage;

  public DeleteAction(Form form, Object item, String schema, String yPage, String xPage) {
    this.form = form;
    this.item = item;  //passed in javabean??
    this.schema = schema;
    this.xPage = xPage;
    this.yPage = yPage;
  }

  public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    item = form.delete(request);

    /* Database schema is described in xml files.
    Hash maps of field names, sizes, and titles; foreign key names, titles, 
    lookup tables; and primary keys information are used to dynamically 
    build HTML forms in the views.
    */      
    HashMap test = ReadTableSchema.returnSchema(schema);
    HashMap hshFields = (HashMap) test.get("hshFields");
    HashMap hshForeignKeys = (HashMap) test.get("hshForeignKeys");
    HashMap hshPrimaryKeys = (HashMap) test.get("hshPrimaryKeys");

    request.setAttribute("hshFields", hshFields);
    request.setAttribute("hshPrimaryKeys", hshPrimaryKeys);
    request.setAttribute("hshForeignKeys", hshForeignKeys);

    request.setAttribute("item", item);
    request.setAttribute("form", form);
    request.setAttribute("pageName", "Delete");

    //Check for deletion authorization if successful forward to the confirmation page
    if (form.isSucces()) {
      request.setAttribute("message", "Please confirm permanent deletion of the data below.");
      RequestDispatcher view = request.getRequestDispatcher(yPage);
      view.forward(request, response);
    } else {
      // Not authorized to delete the data so just re-display
      RequestDispatcher view = request.getRequestDispatcher(xPage);
      view.forward(request, response);
    }
  }
}

then here is the interface (right now just for delete) that will be used by all forms.

public interface CRUD {
    public Object delete(HttpServletRequest request);
}

Answer 1

You can’t instantiate an interface, you need a concrete subclass for that. However, creating concrete subclasses just increases the number of classes, which you are trying to avoid. It is better to use composition instead of inheritance.

Namely, if you manage to make a common interface for the forms, and hide the actions deleteCommitmentItem, deleteProgram etc. behind one single method, you can parametrize your action instances with the required form (or a factory to provide this), e.g.:

public class GenericAction implements ControllerAction {
  private Form form;
  private String page;

  GenericAction(Form form, String page) {
    this.form = form;
    this.page = page;
  }

  public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException {

    Item item = form.performDelete(request);

    RequestDispatcher view = request.getRequestDispatcher(page);
    view.forward(request, response);
  }
}

...
CommitmentListDAO clDAO = new CommitmentListDAO();
CommitmentItemForm ciForm = new CommitmentItemForm(clDAO);
GenericAction deleteCommitmentAction = new GenericAction(ciForm, "views/commitmentView_v.jsp");

ProgramDAO prgDAO = new ProgramDAO();
ProgramForm prgForm = new ProgramForm(prgDAO); 
GenericAction deleteProgramAction = new GenericAction(prgForm, "views/programView_v.jsp");

Thus you need no new classes for new kinds of actions, just instantiate GenericAction with different parameters.