JAVA在类之间共享MySQL连接

我是Java的新手

我想创建一个小应用程序，它连接到MySQL并执行一些查询

我真正的问题是——连接到mysql，并为其他类保留此连接，而不必一次又一次地打开连接

我阅读了有关MVC和OOP的文档。但我仍然不明白我如何才能解决这个问题

正如我想象的那样，我应该在模型中继承一个数据库类，比如

user

和

messages

from

mypackage

。但我无法想象它会是什么样子

我已经尝试在google中搜索一些示例，但我只找到了一个简单的示例，其中包含一个主类和一个数据库类

所以，我需要一个能为我解释的人

如果有任何帮助，我将不胜感激

用户类

package mypackage;
class user {
    public String getName() {
        // return value from mysql
    }
}

消息类

package mypackage;
class messages {
    public String getMessage() {
        // return value from mysql
    }
}

数据库类

package database;
class db {
        private String dbUri = "jdbc:mysql://";
    private String dbDriver = "com.mysql.jdbc.Driver";
    private Connection connection;

    public boolean connect(String host, String base, String user, String pass)
    {
        try {
            Class.forName(dbDriver);
            String uri = dbUri + host + '/' + base;
            connection = DriverManager.getConnection(uri, user, pass);
            return true;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return false;
            // Could not find the database driver
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
            // Could not connect to the database
        }
    }
}

主类

import mypackage.*;
import database.*;

class main
{
    public static void main(String[] args)
    {
        database db = new database();
                user usr = new user();
                System.out.println(usr.getName());
                messages msg = new messages();
                System.out.println(msg.getMessage());
    }
}

---

您需要以这种方式共享类之间的连接

Provider.java，一个包含许多常量的接口，如

DRIVER CLASS

，

CONNECTION\u URL

、

USERNAME

和

PASSWORD

ConnectionProvider.java，负责返回连接对象的类。它使用单例和工厂方法设计模式

界面：

public interface Provider {
String DRIVER="driver_name";
String CONNECTION_URL="URL";
String USERNAME="";
String PASSWORD="";
}

连接提供程序类：

public class ConnectionProvider {
private static Connection con=null;
static{
try{
Class.forName(DRIVER);
con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD);
}catch(Exception e){}
}

public static Connection getCon(){
    return con;
}    
}

在

Dao

类中，为

连接创建一个对象并使用它

Connection con=ConnectionProvider.getCon();

希望这有帮助
 您需要以这种方式共享类之间的连接

Provider.java，一个包含许多常量的接口，如
DRIVER\u CLASS
、
CONNECTION\u URL
、
USERNAME
和
PASSWORD

ConnectionProvider.java，负责返回连接对象的类。它使用单例和工厂方法设计模式

界面：

public interface Provider {
String DRIVER="driver_name";
String CONNECTION_URL="URL";
String USERNAME="";
String PASSWORD="";
}

连接提供程序类：

public class ConnectionProvider {
private static Connection con=null;
static{
try{
Class.forName(DRIVER);
con=DriverManager.getConnection(CONNECTION_URL,USERNAME,PASSWORD);
}catch(Exception e){}
}

public static Connection getCon(){
    return con;
}    
}

在
Dao
类中，为
连接创建一个对象并使用它

Connection con=ConnectionProvider.getCon();

希望这有帮助
 您的db类已经存储了连接，所以只需创建检索连接的方法即可：

package database;
class Database {
    private String dbUri = "jdbc:mysql://";
    private String dbDriver = "com.mysql.jdbc.Driver";
    private Connection connection;

    public boolean connect(String host, String base, String user, String pass)  {
       try {
            Class.forName(dbDriver);
            String uri = dbUri + host + '/' + base;
            connection = DriverManager.getConnection(uri, user, pass);
            return true;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return false;
            // Could not find the database driver
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
            // Could not connect to the database
        }
    }

    public Connection getConnection() {
        return connection;
    }
}

主要是：

class Main
{
    public static void main(String[] args)
    {
        Database db = new Database();
        if (db.connect(/* parameters for database connection here */)) {
            final Connection conn = db.getConnection();
            // you can use conn for your queries. If they are in other classes, pass connection as parameter.
        }
    }
}

我已经尝试使它简单化，但实际上应该使用工厂和单例模式来创建和存储连接，一旦创建，然后在应用程序中静态地检索它。一旦你对这个概念感到满意，你也应该考虑
注释中建议，例如使用。
您的db类已存储连接，因此只需创建检索方法即可：

package database;
class Database {
    private String dbUri = "jdbc:mysql://";
    private String dbDriver = "com.mysql.jdbc.Driver";
    private Connection connection;

    public boolean connect(String host, String base, String user, String pass)  {
       try {
            Class.forName(dbDriver);
            String uri = dbUri + host + '/' + base;
            connection = DriverManager.getConnection(uri, user, pass);
            return true;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return false;
            // Could not find the database driver
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
            // Could not connect to the database
        }
    }

    public Connection getConnection() {
        return connection;
    }
}

主要是：

class Main
{
    public static void main(String[] args)
    {
        Database db = new Database();
        if (db.connect(/* parameters for database connection here */)) {
            final Connection conn = db.getConnection();
            // you can use conn for your queries. If they are in other classes, pass connection as parameter.
        }
    }
}

我已经尝试使它简单化，但实际上应该使用工厂和单例模式来创建和存储连接，一旦创建，然后在应用程序中静态地检索它。一旦你对这个概念感到满意，你也应该考虑
在评论中建议，例如使用。
注意：这不是对问题的回答，这是对关于单例模式正确示例的后续问题的回答。我知道这在技术上不是这样的。但这个问题其实并不重要

好的，有几种不同的策略来创建一个单例，我选择展示的是经典的单例模式，它适用于任何情况，不管您使用的是什么框架。当然，如果您使用的是依赖项注入/反转控制容器，比如Guice或Spring（bean），那么您应该遵循这些准则，而不是这些准则

首先是守则：

public final class ClassicSingleton {

    private static ClassicSingleton instance; 
    private final String exampleImmutable = "My state cannot be changed.";
    private String exampleMutable = "My state can be changed.";

    private ClassicSingleton() {
    }

    public static ClassicSingleton getInstance() {
        if (instance == null)
            instance = new ClassicSingleton();
        return instance;
    }

    public String getExampleImmutable() {
        return exampleImmutable;
    }

    public String getExampleMutable() {
        return exampleMutable;
    }

    public void setExampleMutable(String exampleMutable) {
        this.exampleMutable = exampleMutable;
    }
}

现在，首先要注意的是它有一个私有构造函数，这是为了防止Java使用默认构造函数。它还确保只有ClassicSingleton类可以创建ClassicSingleton对象。由于这只在一个地方完成，而且这一个地方只被调用一次，所以我们通过代码强制执行，在任何给定的时间，这个对象只能有一个实例。此外，这个特定的实现是惰性实例化的（它是在您第一次需要它时创建的。这是否有用取决于您正在编写的应用程序的类型）

第二点要注意的是，类是final的，您不能从中继承。虽然这在技术上是不可能的（因为构造函数是私有的），但对于完整性来说，这是一个很好的选择

完成它的是静态实例变量和静态访问器，让您获得实例变量。这提供了单例全局可访问性。通常，当类具有
getInstance（）
方法时，可以安全地假设它是单例。这是一种约定

最后，这个例子包含了不可变和可变成员的例子。您需要哪种类型取决于您的具体需要

无论如何，我希望我能帮你澄清一些事情。
注意：这不是对这个问题的回答，这是对关于一个正确的单例模式的后续问题的回答。我知道这在技术上不是这样的。但这个问题其实并不重要

好的，有几种不同的策略来创建一个单例，我选择展示的是经典的单例模式，它适用于任何情况，不管您使用的是什么框架。当然，如果您使用的是依赖注入/控制反转容器，比如Guice或Spring（beans）你应该遵循这些指导方针，而不是这些

首先是守则：

public final class ClassicSingleton {

    private static ClassicSingleton instance; 
    private final String exampleImmutable = "My state cannot be changed.";
    private String exampleMutable = "My state can be changed.";

    private ClassicSingleton() {
    }

    public static ClassicSingleton getInstance() {
        if (instance == null)
            instance = new ClassicSingleton();
        return instance;
    }

    public String getExampleImmutable() {
        return exampleImmutable;
    }

    public String getExampleMutable() {
        return exampleMutable;
    }

    public void setExampleMutable(String exampleMutable) {
        this.exampleMutable = exampleMutable;
    }
}

现在，首先要注意的是，它有一个私有构造函数，这是为了防止Java使用默认构造函数。它还确保只有ClassicSingleton类可以创建ClassicSingleton对象。由于这只在一个位置完成，并且该位置只被调用一次，因此我们通过