Web app Connection.close()...how to prevent

Question

Hello
I am somewhat new to this, but I am developing an web application that will be a help desk of sorts for clients to log on and create trouble tickets, plus many other features. I have completed the project and it works fine when I first start tomcat but an unexpected state keeps occurring and I can't seem to figure it out.
After a while (I say a while cause I'm not sure exactly how long, but I'd say +5 hours) my application no longer will work and in the tomcat log I get the following message.
Could not execute a query statement!Connection.close() has already been called. Invalid operation in this state.
java.sql.SQLException: Connection:close() has already been called.
at com.mysql.jdbc.Connection.getMutex(Connection.java:1906)
at com.mysql.jdbc.Statement.executeQuery(Statement.java:1115)
at brokers.RelationalBroker.query(RelationalBroker.java:171)
the RelationalBroker.java is
package brokers;
* Created on May 12, 2004
* Class: RelationalBroker
* Package: brokers
* On-Track, Ticket Tracking System
* @author
* @version
* This Class is used as the super class for all of the child brokers
* for the database. The main purpose if this class is to allow all the
* child classes to share the open connection to the database and execute
* queries and updates on the database. This class is part of the brokers
* package.
//imports
import java.sql.*;
public class RelationalBroker {
    //Instance Attributes
     * The attribute con represented by a Connection object is used to hold
     * the active connection to the database. This connection is shared with
     * all of the child brokers.
    private Connection con = null;
     * The attribute statement represented by a Statement object is used to
     * execute the query and update statements on the database by the child
     * brokers.
    private Statement statement = null;
     * The attribute results represented by a ResultSet is used to hold
     * the results of a query executed on the database.
    private ResultSet results = null;
    //Constructors
     * Default constructor used to create a RelationalBroker object.
    public RelationalBroker(){
    //     Getters
     * The Getter getCon is used to get the Connection object.
     * @return Connection con.
    public Connection getCon() {
        return con;
     * The Getter getResults is used to get the ResultSet results.
     * @return ResultSet results.
    public ResultSet getResults() {
        return results;
     * The Getter getStatement is used to get the Statement object.
     * @return Statement statement.
    public Statement getStatement() {
        return statement;
    //Methods
     * The method connect is used to connect to the database given a username
     * password, location of driver, and URL of the database. This method also
     * creates the Statement object to be used for queries ans updates on the database.
     * @param driver A String containing the location of the database driver.
     * @param URL A String containing the location of the database on a netowrk.
     * @param user A String containing the username of the database account.
     * @param pass A String containing the password of the database account.
    public void connect(String driver, String URL, String user, String pass){
        try{
            Class.forName(driver);
            con = DriverManager.getConnection(URL, user, pass);
            statement = con.createStatement();
        catch (ClassNotFoundException cExp){
            System.out.println("Cannot find class for driver");
        catch (SQLException sqle){
            System.out.println("Error opening table or creating statement!: " + sqle.getMessage());
            sqle.printStackTrace();
            System.exit(0);
     * The method closeConnection is used to close the active connection
     * to the database.
     * @return A boolean containing the status of the connection, True if closed
     * false if open.
    public boolean closeConnection(){
        boolean isClosed = false;
        try{
            con.close();
            isClosed = con.isClosed();
        catch(SQLException sqle){
            System.out.println("Error closing connection!" + sqle.getMessage());
        //finally{
        return isClosed;
     * The method rollBack is used to execute a rollback statement on
     * the database, to undo any changes since the last commit.
     * @return void
    public void rollBack(){
        try{
            con.rollback();
        catch(SQLException sqle){
            System.out.println("Could not execute a  Rollback statement!" + sqle.getMessage());
            sqle.printStackTrace();
     * The method commit is used to execute a commit statement on the
     * database, to make any changes final.
     * @return void
    public void commit(){
        try{
            statement.executeUpdate("commit");
        catch (SQLException sqle){
            System.out.println("Could not execute a commit statement!" + sqle.getMessage());
            sqle.printStackTrace();
     * The method query is used to exceute a query statement on the
     * database to get back some results.
     * @param query A String containing the query to be executed on the database
     * @return a ResultSet containing the results.
    public ResultSet query(String query){
        results = null;
        try{
            //System.out.println("query: "+query);
            results = statement.executeQuery(query);
        catch(SQLException sqle){
            System.out.println("Could not execute a query statement!" + sqle.getMessage());
            sqle.printStackTrace();
        //finally{
        return results;
     * The method update is used to persist or remove information
     * from the database.
     * @param update String containing the update string to be exceuted;
    public void update(String update){
        try{
            statement.executeUpdate(update);
        catch(SQLException sqle){
            System.out.println("Could not execute an update statement!" + sqle.getMessage());
            sqle.printStackTrace();
}//end classmy web.xml file to initialize with the database is as follows
<servlet>
          <servlet-name>Connection</servlet-name>
          <servlet-class>servlets.ConnectionServlet</servlet-class>
          <init-param>
               <param-name>url</param-name>
               <param-value>jdbc:mysql://localhost/TICKETTRACK</param-value>
          </init-param>
          <init-param>
               <param-name>driver</param-name>
               <param-value>com.mysql.jdbc.Driver</param-value>
          </init-param>
          <init-param>
               <param-name>user</param-name>
               <param-value>---</param-value>
          </init-param>
          <init-param>
               <param-name>password</param-name>
               <param-value>---</param-value>
          </init-param>
          <load-on-startup>1</load-on-startup>
     </servlet>
the ConnectionServlet.java is
package servlets;
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
import java.sql.*;
import java.util.*;
import problemDomain.*;
import brokers.*;
* Title:
* Description:      This servlet is used to create a connection with .
* @author
* @version 1.0
public class ConnectionServlet  extends HttpServlet{
    private UserBroker uBroker;
    private TicketBroker tBroker;
    private CompanyBroker cBroker;
    public void init() throws ServletException{
        ServletConfig config = getServletConfig();
        String user = config.getInitParameter("user");
        String pass  = config.getInitParameter("password");
        String url  = config.getInitParameter("url");
        String driver = config.getInitParameter("driver");
        uBroker = UserBroker.getUserBroker();
        tBroker = TicketBroker.getTicketBroker();
        cBroker = CompanyBroker.getCompanyBroker();
        uBroker.connect(driver,url,user,pass);
        tBroker.connect(driver,url,user,pass);
        cBroker.connect(driver,url,user,pass);
/*  This method is used to close the connection.
*  @param none
*  @return none.
    public void destroy() {
        try{
        }catch(Exception ec){
            System.err.println(ec);
}I hope this is enough information for someone to help out. I'm out of ideas and my searches on the web didn't turn up much.
I was thinking it was something to do with ConnectionPooling but I have never done that, or maybe its something to do with how I set up Connections or maybe its my Tomcat config or something to do with Mysql. I'm not even calling a Connection.close(), maybe that is my problem.
Any help would be greatly appreciated, I'm not just looking for an answer I really would like to know why this occurs and how it can be prevented.
Thanks,

Answer 1

I really appreciate your reply and I can understand what you mean in theory(I think) but to actually implement it I'm having a little trouble.
So for this database pool, in my ConnectionServlet which gets initialized on startup, should I create a Collection of connections for each instance(make them local), and than create another method to retrieve one of these connection when needed and when finished release it back to the collection(close)? Or is there some built in mechanism that can easily do this?
I'm also reading up on that keep-alive you mentioned...it applies to the HTTP Connector element right? Is there a way to tell if this is an issue? I'm using Tomcat 5 and mySQL 3. I was talking with another guy here about using a connector to apache so it will work with the static pages and Tomcat do the servlet stuff, but I'm still trying to grasp all that.
I don't know if this matters but many instances/windows of the web app can be opened at one time with seemingly no problems.
Hope this made sense, like I said I'm pretty new to this so all I'm used to is simple configurations of web apps but hopefully I can advance further.
Thanks again,