establishing connection to mysql database (question about optimization)

Question

I am implementing a program that needs to establish connection to mysql database. I'm currently connecting independently for each class (like sign up, sign in, show users etc), using the following lines:

Class.forName("com.mysql.cj.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3308/myfirstdb","root");

What I am thinking is to implement a class for the connection and call its default constructor each time. Does it give any advantages/disadvantages or doesn't matter. This is the class:

public class MyConnection {

    private Connection con;

    public MyConnection() {

        //establishing connection
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            con = DriverManager.getConnection("jdbc:mysql://localhost:3308/myfirstdb","root","");
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }

    //for future use
    public Connection getCon() {
        return con;
    }
}

Answer 1

With very rare exceptions, a single connection to the database for the entire program is the "correct" thing to do.

Connecting costs something. All your queries can use that one connection.

Sure, have the "constructor" do the "connect". And have the "destructor" do "disconnect".

The class should be a "singleton" (or equivalent) to avoid accidentally getting two connections.

Your code has public MyConnection() , which begs the user to create multiple connections. That should be private and called only once, such as this way:

public Connection getCon() {
    if (con == NULL) {    // or whatever the syntax is
        MyConnection();   // Here's the _one_ connection
    }
    return con;
}

Then users call getCon() to get the one connection and use it to perform queries.

Beware: If you language facilitates multiple threads, do one of these:

• Do database operations only from one thread, or
• Have (at most) one connection per thread.

PS: I believe this advice applies to any OO language.

As a footnote, establishing two connections in an attempt to get extra performance is likely to be futile. Or, at least, not worth the effort.

Another thing to be aware of... HTTP is, mostly, stateless. So, if you have one web page to "sign up", that will come and go -- one connection with some number of SQLs, then it goes away. Another web page to "sign in" will involve another HTTP request, another connection, etc.

After that, the memory that the user is "signed in" need to be held somewhere:

• In URL parameters -- subject to hacking
• In a cookie -- reasonable for lightweight apps
• Other -- You need security advice if working with sensitive (credit card, health care, etc) info and need to go from web page to web page.

Answer 2

This is a solved problem in Java, don't try to write this yourself. Use a javax.sql.DataSource implementation that is backed by a connection pool (for example Apache DBCP , HikariCP or c3p0 ).

You can then obtain a connection from the data source for a unit-of-work, and close the connection when you're done. Closing the connection will return the connection to the connection pool for re-use, eliminating much of the overhead of opening a connection.