Critique my Web App design. (very long, maybe interesting)

Question

Hi all
I guess this is really a design issue, and I was just looking for confirmation that what I have done is good practice.
I am writing a web application with the works, forms, beans, client validation, server validation, everything. In the future, I envisage there may be a requirement for the functions of this web application to be utilised by some kind of desktop application (perhaps a stand alone swing or an extension to some existing software or something like that).
I guess maybe the best way to do this is to explain the dataflow.
A client is presented with IE window, invoked by a third party application which also hands in some URL parameters. This window consists of a menu frame on the left, and a "form frame" on the right. The client selects a form from the menu frame, by clicking a standard html link. The link adds a "command" parameter to the URL and passes the request to a servlet. The servlet reads the "command" parameter to determine which form the user would like to see and displays it in the "form frame". It then uses getRequestDispatcher and forwards the request to the appropriate JSP form.
The form that is displayed initialises a unique bean (scope=request) for the form that is displayed. The bean is initialised with a few default values which are set in the constructor of the bean.
The first thing the JSP does is check the "process" parameter (which should not have been set yet), if it is "true", the properties of the bean are set from the fields on the form (introspection). The user enters some values on the form and some hidden parameters (including process=true) which are taken from the URL are set. The form is submitted to itself (the same JSP) after running some basic client side validation (numbers in numbers fields, field length, etc).
If process=true, then the properties of the bean have been set and the request is forwarded (<jsp:forward>) to a validation servlet.
The validation servlet looks up a properties file and creates a JDBC connection from those properties. It extracts the bean from the request, and makes a call to it�s validate() method which takes the JDBC connection as a parameter.
The validate() method runs some queries against the database and returns true or false or throws an SQLException back to the validation servlet. If validate returns false, it sets an error message in a hashtable in the bean.
If the validation servlet catches an exception thrown from the validate() method of the bean, it writes the response to the screen (form frame).
If the validate() method returns false, the validation servlet, using getRequestDispatcher() forwards the request back to the original form. The form renders its fields based on the values in the bean in the request, and also writes out any error messages that the validate() method of the bean may have put () into its errors hashtable.
If the validate() method returns true, a new Statement is created on the original JDBC Connection object. A method in the bean is accessed which returns an SQL INSERT statement which is inserted via statement.executeUpdate(). The request is then forwarded, using getRequestDispatcher() to a confirmation page that simply displays the properties that have been set in the bean.
Hope I'm not boring you to death yet...
My comments/questions are:
Firstly, is this proper MVC design? I've read tutorials and things like that and have tried to fit the MVC architecture.
Should the servlet, which initially determines which form is displayed to the user (I believe this is an implementation of the "command" pattern), in fact be an interface of the package that contains all the beans? This way, when it comes time to stick a different front end on all this, all that needs to be done is implement that interface. E.g. for my current set up, I would implement that interface and have it extend HttpServlet and have its doPost() method to display the correct form...
...or... is it acceptable that if a different application is to call my code, a new interface or command type structure will be required anyway?
Because the beans contain their own validation methods and their own method to create a sql insert statement. When it comes time to use the same functionality but called from a different client application, they will look after themselves, provided the calling application can supply them with a connection. Correct?
The servlet that calls the validate() method of my bean, instantiates a JDBC connection and a statement. The validate method of my bean also creates a statement. I have explicitly closed the statements in the validate method of my bean, and that method throws SQLExceptions which the servlet will catch (in case something goes wrong). However, what is the life of a servlet? Will the connection and statement objects opened created by the servlet be destroyed when the servlet forwards the request on (which happens based on the results of the beans validate() method). there is a point just after the values of the bean have been inserted into the database that I can explicitly destroy the connection and statement object, it just makes things a little more messier (just code readability).
Ok, this is really long now, thank you very much to anyone who bothered reading that. Even bigger thanks to anyone who can be bothered responding. Even links are appreciated.
Hey, at least I�m not just asking you to do my homework assignment. :-)
PS. I�m sure ill come up with more questions.... ;-)

Answer 1

bump?
:(