Everyone else raised completely valid points about not doing what your doing in an Action and why you shouldn't, so I'll just try and answer the question :)

* Wrap your call to getConnection() in a try block with only a finally:

  try {
    Connection con = getDataSource().getConnection();
  } finally {
    con.close();
  }

All other exceptions will still bubble up to the global handler.

* Have a base Action that is responsible for getting the connection, and for having this finally:

  public class MyBaseAction extends Action {
    public ActionForward execute(...) {
      try {
        Connection con = getDataSource().getConnection();
        realExecute(...,con);
      } finally {
        con.close();
      }
    }
  }

So, all of your actual Actions will extend MyBaseAction instead of Action, and will implement realExecute() instead of execute(). realExecute() has the same signature as execute(), with the addition of the connection being passed in as well. So, any exception that occurs in the actual Action will still invoke the global handler, but the connection will always be closed, and your actual Actions remain nice and clean.

Then again, as others said, best practices dictate you shouldn't really be doing this anyway, but if you have to, these options might help, specifically the second I would prefer.

Frank

emre akbas wrote:
Hi all,
In a well written struts application, we assume declarative exception
handling is used. Therefore the code of the action classes will look clean
and short (and nice) because all the exception handling is done via the
exception-handler classes outside. My question is about db connection
management when declarative exception handling is used.

A usual scenario is :

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class MyAction extends Action {
...
public ActionForward execute( . .. ) {
..
Connection con = getDataSource().getConnection();

// an exception occurs here and the control passes to the
// exception-handler class, which can never close the connection
// opened above.
....

con.close();
}
...
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

What to do in a situation like above? Since the exception-handler could not
close the connection opened in the Action class, this will cause the
connections in the pool to be exhausted. To prevent the situation above, we
may :

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class MyAction extends Action {
...
public ActionForward execute( . .. ) {
..
Connection con = null;
try {
con = getDataSource().getConnection();

// an exception occurs here
....

} catch(MyAppSpecifiException e) {
....
} catch(Exception e) { // IMPORTANT, this line will catch all the exceptions
....
} finally {
con.close();
}

}
...
}


The scheme above seems to solve the unclosed connection problem but it does
not use declarative exception-handling and the code is really messed-up with
exception handling statements. It does not look nice, clean and short.

The situation is more complicated when you call a service method within the
action and that service method throws an exception.

I would like to hear your points on this issuse. Thanks in advance.


--

Emre Akbas


--
Frank W. Zammetti
Founder and Chief Software Architect
Omnytex Technologies
http://www.omnytex.com
AIM: fzammetti
Yahoo: fzammetti
MSN: [EMAIL PROTECTED]

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to