数据库连接在一段时间后停止，没有明显原因

Question

I deployed my first Java web application a couple of days ago and realized a strange thing was happening. After a period of time all the dynamic content and functionality that relied on a connection to my database (testimonial submission, admin login) stopped working. It seems like this is happening every 24 hours or so. Every morning I realize it isn't working again.

I solve the issue by going in to the Tomcat web application manager and clicking "reload" on the web app in question. Immediately the dynamic features of the website work again.

My server is running Tomcat 7 and MySQL and the web app uses the JDBC driver to establish the connection to the database. I've made no alterations to Apache or Tomcat settings.

I have other web apps written in PHP that work persistently without fault it just seems to be this Java web app that has this problem.

What would cause this to happen and how can I make it so the web app doesn't need to be reloaded before it can establish a database connection again?

EDIT: attached some code for database connection

Database connection

public class DBConnection {
    private static Connection conn; 
    private static final Configuration conf     = new Configuration();
    private static final String dbDriver        = conf.getDbDriver();
    private static final String dbHostName      = conf.getDbHostname();
    private static final String dbDatabaseName  = conf.getDbDatabaseName();
    private static final String dbUsername      = conf.getDbUsername();
    private static final String dbPassword      = conf.getDbPassword();

    public Connection getConnection(){
        try{
            Class.forName(dbDriver);
            Connection conn = (Connection) DriverManager.getConnection(dbHostName + dbDatabaseName, dbUsername, dbPassword);
            return conn;
        } catch(Exception e){
            e.printStackTrace();
        }
        return conn;
    }
    public void disconnect(){

        try{
            conn.close();
        } catch (Exception e){}
    }
}

Controller for login form:

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String form         = request.getParameter("form");
// check login details
if(form.equals("loginForm")){
    String username = request.getParameter("username").trim();
    String password = request.getParameter("password").trim();

    password = loginService.hashPassword(password);
    boolean isValidUser = loginService.checkUser(username, password);

    if(isValidUser){

        Cookie loggedIn = new Cookie("loggedIn", "true");
        loggedIn.setMaxAge(60*60*24);
        response.addCookie(loggedIn);

        out.print("success");

    }else{
        out.print("nope");
    }
}
}

Login service checks login details are correct:

public boolean checkUser(String username, String password){
    boolean isValid = false;
    try{
        sql = "SELECT username, password FROM morleys_user WHERE username=? AND password=? AND isActive=1 LIMIT 1";
        prep = conn.prepareStatement(sql);
        prep.setString(1, username);
        prep.setString(2, password);
        rs = prep.executeQuery();
        if(rs.next()){
            return true;
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        connection.disconnect();
        }
    return isValid;
}

UPDATE

If I understand correctly I should not be handling a direct connection to a database and instead be using a service that will manage connections for me.

This is my example of establishing a DataSource connection to a MysQL database.

Establish a new DataSource instance of this class:

package uk.co.morleys;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

public class DataSourceFactory {

    public static DataSource getMySQLDataSource() {
        Properties props = new Properties();
        FileInputStream fis = null;
        MysqlDataSource mysqlDS = null;
        try {
            fis = new FileInputStream("db.properties");
            props.load(fis);
            mysqlDS = new MysqlDataSource();
            mysqlDS.setURL(props.getProperty("MYSQL_DB_URL"));
            mysqlDS.setUser(props.getProperty("MYSQL_DB_USERNAME"));
            mysqlDS.setPassword(props.getProperty("MYSQL_DB_PASSWORD"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return mysqlDS;
    }

}

Instantiating a new DataSource for checking user login details

public boolean checkUser(String username, String password){
    boolean isValid = false;
    DataSource ds = DataSourceFactory.getMySQLDataSource();
    Connection con = null;
    ResultSet rs = null;
    PreparedStatement ps = null;

    try{
        con = ds.getConnection();
        sql = "SELECT username, password FROM morleys_user WHERE username=? AND password=? AND isActive=1 LIMIT ";
        ps = con.prepareStatement(sql);
        ps.setString(1, username);
        ps.setString(2, password);
        rs = ps.executeQuery();
        if(rs.next()){
            return true;
        }

    }catch(SQLException e){
        e.printStackTrace();
    }finally{
        try {
            if(rs != null) rs.close();
            if(ps != null) ps.close();
            if(con != null) con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
}
    return isValid;
}

Answer 1

Given that you've never heard of a connection pool before I'm assuming that you not are not very effectively managing database resources. The most basic way to access the database is to obtain a connection, execute some statements & close the connection. In the code you provided I don't see you obtaining or closing a connection, so I assume that you create a single connection when you start your application and keep the connection open "forever". After a certain amount of time your MySql server decides to kill the connection as it's been open for too long.

When you create and close a connection each time you need one, you normally won't encounter any connection timeouts, but you might experience a lot overhead from creating a connection each time your application needs one.

This is where a connection pool comes in; a connection pool manages a number of database connections and your application borrows one each time it needs one. By properly configuring your connection pool the pool will normally transparently take care of broken connections (you might for example configure the pool to renew a connection once it's x minutes/hours old).

You also need to pay attention to resource management; eg close a statement as soon as you no longer need it.

The following code demonstrates how your "check user" method can be improved:

public boolean checkUser(String username, String password) throws SQLException {
    //acquire a java.sql.DataSource; the DataSource is typically a connection pool that's set-up in the application of obtained via jndi
    DataSource dataSource = acquireDataSource();
    //java 7 try-with-resources statement is used to make sure that resources are properly closed
    //obtain a connection from the pool. Upon closing the connection we return it to the pool
    try (Connection connection = dataSource.getConnection()) {
        //release resources associated with the PreparedStatement as soon as we no longer need it.
        try(PreparedStatement ps = connection.prepareStatement("SELECT username, password FROM morleys_user WHERE username=? AND password=? AND isActive=1 LIMIT 1");){
            ps.setString(1, username);
            ps.setString(2, password);
            ResultSet resultSet = ps.executeQuery();
            return resultSet.next();
        }
    }
}

Common connections pools are Apache Commons-DBCP and C3P0 .

As managing sql resources can be quite repetitive and cumbersome you might want to consider using a template: for example Spring's JdbcTemplate

Example C3p0 configuration:

public ComboPooledDataSource dataSource(String driver, String url, String username,String password) throws PropertyVetoException {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);

    dataSource.setAcquireIncrement(1);
    dataSource.setMaxPoolSize(100);
    dataSource.setMinPoolSize(1);
    dataSource.setInitialPoolSize(1);
    dataSource.setMaxIdleTime(300);
    dataSource.setMaxConnectionAge(36000);

    dataSource.setAcquireRetryAttempts(5);
    dataSource.setAcquireRetryDelay(2000);
    dataSource.setBreakAfterAcquireFailure(false);

    dataSource.setCheckoutTimeout(30000);
    dataSource.setPreferredTestQuery("SELECT 1");
    dataSource.setIdleConnectionTestPeriod(60);
    return dataSource;
}//in order to do a "clean" shutdown you should call datasource.close() when shutting down your web app.

Answer 2

MySQL times out the connection after some period of time. The standard way to deal with this is to use a properly configured connection pool (with a configured DataSource) instead of using DriverManager directly.

The connection pool will check for and discard "stale" connections.