不同的客户端使用相同的连接mysql JSP

Question

I have an JPS Project.

If I have different computers using the system, they use the same MySQL connection.

When the system is running any query and a client tries to make any mysql command, it puts everyone in a queue, the system is very slow.

I want each client has a different connection with mysql.

Sorry if I was not clear enough.

package br.com.scope.model;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;

import br.com.scope.log.LoggerIntegrador;

public class ConexaoMysql {
    private static Connection connection;
    private final static ConexaoMysql conexaoMysql = new ConexaoMysql();
    private static Properties prop;
    private LoggerIntegrador logger;

    private ConexaoMysql() {
        super();
        prop = new Properties();
        Class<? extends ConexaoMysql> cls = this.getClass();
        InputStream is = cls.getResourceAsStream("db.properties");
        try {
            prop.load(is);
        } catch (IOException e) {
            logger = LoggerIntegrador.getInstance();
            logger.error(e.getMessage(), e);
        }
    }

    public static ConexaoMysql getConnection() throws SQLException, ClassNotFoundException, IOException {
        if (connection == null || connection.isClosed()){
            conexaoMysql.abreConexao();            
        }
        return conexaoMysql;
    }

    public static void beginTransaction() throws SQLException, ClassNotFoundException, IOException {
        getConnection();
        connection.setAutoCommit(false);
    }

    public static void commit() throws SQLException {
        connection.commit();
        connection.setAutoCommit(true);
    }

    public static String getDriver() {
        return prop.getProperty("driver");
    }

    public static String getConnectionString() {
        return prop.getProperty("connectionstring");
    }

    public static String getUser() {
        return prop.getProperty("user");
    }

    public static String getPassword() {
        return prop.getProperty("password");
    }

    private void abreConexao() throws ClassNotFoundException, SQLException, IOException{
        Class.forName(getDriver());

        connection = DriverManager.getConnection(
                getConnectionString(), 
                getUser(),
                getPassword());
    }

    public static void fechaConexao() throws SQLException {
        if (!connection.isClosed()) {
            connection.close();           
        }
    }

    public PreparedStatement getPreparedStatement(String sql) throws SQLException {
        return connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
    }

    public static int getId() {
        return conexaoMysql.hashCode();
    }
}

Answer 1

What you're looking for is a connection pool. It is a bounded pool of connections that the clients can take a connection from when they need it, and put it back to when done. This saves you from the overhead or creating and destroying connections all the time. It also makes sure the number of connections grows predictably.

Most containers provide a facility like this eg here's the documentation for configuring a connection pool in Tomcat . Find the one for your container.

If for some reason you can not use that or do not want the container to be in charge, you can use a library that helps you manage a connection pool yourself, in your application. c3p0 is a popular one with many examples on the web.

EDIT: Hikari is the new cool choice for connection pooling.