【问题标题】：How do I implement a DAO manager using JDBC and connection pools?如何使用 JDBC 和连接池实现 DAO 管理器？
【发布时间】：2012-09-30 12:08:33
【问题描述】：

我的问题如下。我需要一个作为 Web 系统中数据库连接的单点工作的类，以避免一个用户打开两个连接。我需要它尽可能优化，它应该管理系统中的每笔交易。换句话说，只有那个类应该能够实例化 DAO。为了让它更好，它还应该使用连接池！我该怎么办？

【问题讨论】：

标签： java jdbc connection-pooling dao genericdao

【解决方案1】：

您需要实施 DAO 管理器。我从this website 获得了主要思想，但是我自己实现了解决一些问题。

第 1 步：连接池

首先，您必须配置一个连接池。连接池是一个连接池。当您的应用程序运行时，连接池将启动一定数量的连接，这样做是为了避免在运行时创建连接，因为这是一项昂贵的操作。本指南不是为了解释如何配置一个，所以去看看吧。

作为记录，我将使用 Java 作为我的语言并使用 Glassfish 作为我的服务器。

第二步：连接数据库

让我们从创建一个DAOManager 类开始。让我们给它在运行时打开和关闭连接的方法。没什么太花哨的。

public class DAOManager {

    public DAOManager() throws Exception {
        try
        {
            InitialContext ctx = new InitialContext();
            this.src = (DataSource)ctx.lookup("jndi/MYSQL"); //The string should be the same name you're giving to your JNDI in Glassfish.
        }
        catch(Exception e) { throw e; }
    }

    public void open() throws SQLException {
        try
        {
            if(this.con==null || !this.con.isOpen())
                this.con = src.getConnection();
        }
        catch(SQLException e) { throw e; }
    }

    public void close() throws SQLException {
        try
        {
            if(this.con!=null && this.con.isOpen())
                this.con.close();
        }
        catch(SQLException e) { throw e; }
    }

    //Private
    private DataSource src;
    private Connection con;

}

这不是一个非常花哨的课程，但它将成为我们要做的事情的基础。所以，这样做：

DAOManager mngr = new DAOManager();
mngr.open();
mngr.close();

应该在一个对象中打开和关闭与数据库的连接。

第 3 步：将其设为单点！

现在，如果我们这样做呢？

DAOManager mngr1 = new DAOManager();
DAOManager mngr2 = new DAOManager();
mngr1.open();
mngr2.open();

有些人可能会争辩说，“你到底为什么要这样做？”。但是你永远不知道程序员会做什么。即使这样，程序员也可能在打开新连接之前关闭连接。另外，这对应用程序来说是一种资源浪费。 如果您确实希望有两个或更多打开的连接，请到此为止，这将是每个用户一个连接的实现。

为了使它成为一个单点，我们必须将这个类转换成一个单例。单例是一种设计模式，它允许我们拥有任何给定对象的一个且只有一个实例。所以，让我们让它成为一个单例！

我们必须将public 构造函数转换为私有构造函数。我们必须只给调用它的人一个实例。然后DAOManager 就变成了工厂！
我们还必须添加一个新的private 类，它实际上将存储一个单例。
除此之外，我们还需要一个 getInstance() 方法，该方法将为我们提供一个可以调用的单例实例。

让我们看看它是如何实现的。

public class DAOManager {

    public static DAOManager getInstance() {
        return DAOManagerSingleton.INSTANCE;
    }  

    public void open() throws SQLException {
        try
        {
            if(this.con==null || !this.con.isOpen())
                this.con = src.getConnection();
        }
        catch(SQLException e) { throw e; }
    }

    public void close() throws SQLException {
        try
        {
            if(this.con!=null && this.con.isOpen())
                this.con.close();
        }
        catch(SQLException e) { throw e; }
    }

    //Private
    private DataSource src;
    private Connection con;

    private DAOManager() throws Exception {
        try
        {
            InitialContext ctx = new InitialContext();
            this.src = (DataSource)ctx.lookup("jndi/MYSQL");
        }
        catch(Exception e) { throw e; }
    }

    private static class DAOManagerSingleton {

        public static final DAOManager INSTANCE;
        static
        {
            DAOManager dm;
            try
            {
                dm = new DAOManager();
            }
            catch(Exception e)
                dm = null;
            INSTANCE = dm;
        }        

    }

}

当应用程序启动时，只要有人需要一个单例，系统就会实例化一个DAOManager。非常简洁，我们创建了一个接入点！

但是单例是一种反模式，因为原因！ 我知道有些人不喜欢单身人士。然而，它很好地解决了这个问题（并且已经解决了我的问题）。这只是实现此解决方案的一种方式，如果您有其他方式欢迎提出建议。

第 4 步：但出了点问题……

是的，确实有。 单例只会为整个应用程序创建一个实例！这在很多层面上都是错误的，尤其是如果我们有一个应用程序将是多线程的网络系统！那我们该如何解决呢？

Java 提供了一个名为ThreadLocal 的类。 ThreadLocal 变量的每个线程将有一个实例。嘿，它解决了我们的问题！ See more about how it works，您需要了解它的用途，以便我们继续。

然后让我们创建我们的INSTANCE ThreadLocal。这样修改类：

public class DAOManager {

    public static DAOManager getInstance() {
        return DAOManagerSingleton.INSTANCE.get();
    }  

    public void open() throws SQLException {
        try
        {
            if(this.con==null || !this.con.isOpen())
                this.con = src.getConnection();
        }
        catch(SQLException e) { throw e; }
    }

    public void close() throws SQLException {
        try
        {
            if(this.con!=null && this.con.isOpen())
                this.con.close();
        }
        catch(SQLException e) { throw e; }
    }

    //Private
    private DataSource src;
    private Connection con;

    private DAOManager() throws Exception {
        try
        {
            InitialContext ctx = new InitialContext();
            this.src = (DataSource)ctx.lookup("jndi/MYSQL");
        }
        catch(Exception e) { throw e; }
    }

    private static class DAOManagerSingleton {

        public static final ThreadLocal<DAOManager> INSTANCE;
        static
        {
            ThreadLocal<DAOManager> dm;
            try
            {
                dm = new ThreadLocal<DAOManager>(){
                    @Override
                    protected DAOManager initialValue() {
                        try
                        {
                            return new DAOManager();
                        }
                        catch(Exception e)
                        {
                            return null;
                        }
                    }
                };
            }
            catch(Exception e)
                dm = null;
            INSTANCE = dm;
        }        

    }

}

我真的很想不这样做

catch(Exception e)
{
    return null;
}

但是initialValue() 不能抛出异常。哦，initialValue() 你的意思是？此方法将告诉我们ThreadLocal 变量将持有什么值。基本上我们正在初始化它。因此，多亏了这一点，我们现在每个线程可以拥有一个实例。

第 5 步：创建 DAO

没有 DAO，DAOManager 什么都不是。所以我们至少应该创建几个。

DAO，“数据访问对象”的缩写，是一种设计模式，它将管理数据库操作的责任交给代表某个表的类。

为了更有效地使用我们的DAOManager，我们将定义一个GenericDAO，它是一个抽象DAO，将保存所有DAO之间的通用操作。

public abstract class GenericDAO<T> {

    public abstract int count() throws SQLException; 

    //Protected
    protected final String tableName;
    protected Connection con;

    protected GenericDAO(Connection con, String tableName) {
        this.tableName = tableName;
        this.con = con;
    }

}

现在，这就足够了。让我们创建一些 DAO。假设我们有两个 POJO：First 和 Second，它们都只有一个名为 String 的字段 data 及其 getter 和 setter。

public class FirstDAO extends GenericDAO<First> {

    public FirstDAO(Connection con) {
        super(con, TABLENAME);
    }

    @Override
    public int count() throws SQLException {
        String query = "SELECT COUNT(*) AS count FROM "+this.tableName;
        PreparedStatement counter;
        try
        {
        counter = this.con.PrepareStatement(query);
        ResultSet res = counter.executeQuery();
        res.next();
        return res.getInt("count");
        }
        catch(SQLException e){ throw e; }
    }

   //Private
   private final static String TABLENAME = "FIRST";

}

SecondDAO 将具有或多或少相同的结构，只是将TABLENAME 更改为"SECOND"。

第 6 步：将经理变成工厂

DAOManager 不仅应该用作单一连接点。其实DAOManager应该回答这个问题：

谁负责管理与数据库的连接？

单个 DAO 不应该管理它们，而是 DAOManager。我们已经部分回答了这个问题，但现在我们不应该让任何人管理与数据库的其他连接，即使是 DAO。但是，DAO 需要连接到数据库！谁应该提供？ DAOManager 确实！我们应该做的是在DAOManager 中创建一个工厂方法。不仅如此，DAOManager 还会将当前连接交给他们！

工厂是一种设计模式，它允许我们创建某个超类的实例，而无需确切知道将返回哪个子类。

首先，让我们创建一个enum 列出我们的表。

public enum Table { FIRST, SECOND }

现在，DAOManager 内部的工厂方法：

public GenericDAO getDAO(Table t) throws SQLException 
{

    try
    {
        if(this.con == null || this.con.isClosed()) //Let's ensure our connection is open   
            this.open();
    }
    catch(SQLException e){ throw e; }

    switch(t)
    {
    case FIRST:
        return new FirstDAO(this.con);
    case SECOND:
        return new SecondDAO(this.con);
    default:
        throw new SQLException("Trying to link to an unexistant table.");
    }

}

第 7 步：将所有内容放在一起

我们现在可以出发了。试试下面的代码：

DAOManager dao = DAOManager.getInstance();
FirstDAO fDao = (FirstDAO)dao.getDAO(Table.FIRST);
SecondDAO sDao = (SecondDAO)dao.getDAO(Table.SECOND);
System.out.println(fDao.count());
System.out.println(sDao.count());
dao.close();

它不是花哨且易于阅读吗？不仅如此，当您调用close() 时，您会关闭DAO 正在使用的每一个连接。 但是怎么做呢？！嗯，他们共享同一个连接，所以这很自然。

第 8 步：微调我们的类

从这里开始，我们可以做几件事。为确保连接已关闭并返回到池中，请在 DAOManager 中执行以下操作：

@Override
protected void finalize()
{

    try{ this.close(); }
    finally{ super.finalize(); }

}

您还可以实现封装Connection 中的setAutoCommit()、commit() 和rollback() 的方法，以便更好地处理您的事务。我还做的是，除了持有Connection，DAOManager 还持有PreparedStatement 和ResultSet。因此，当调用 close() 时，它也会同时关闭两者。关闭语句和结果集的快速方法！

我希望本指南可以在您的下一个项目中对您有所帮助！

【讨论】：

感谢您的精彩回答。我看到Connection 类没有isOpen 方法（Java 1.6）但是有一个isValid 方法。和参数0一样吗？
试试isClosed 方法，它基本上是你指出的方法的逆。至于你的问题，不完全一样。 isValid 不仅验证它是否打开，而且验证它是否有效（这不完全相同 - 尽管连接已打开或找不到服务器，但连接可能已超时）。
看在上帝的份上，不要把这个“解决方案”放在生产环境中：你想有数百个连接泄漏吗？
要改进这种单例模式，您应该将打开和关闭方法声明为同步。
同意@NestorHernandezLoli 不能依赖finalize()。

【解决方案2】：

我认为如果你想在纯 JDBC 中做一个简单的 DAO 模式，你应该保持简单：

      public List<Customer> listCustomers() {
            List<Customer> list = new ArrayList<>();
            try (Connection conn = getConnection();
                 Statement s = conn.createStatement();
                 ResultSet rs = s.executeQuery("select * from customers")) { 
                while (rs.next()) {
                    list.add(processRow(rs));
                }
                return list;
            } catch (SQLException e) {
                throw new RuntimeException(e.getMessage(), e); //or your exceptions
            }
        }

您可以在名为 CustomersDao 或 CustomerManager 的类中遵循此模式，并且可以通过简单的方式调用它

CustomersDao dao = new CustomersDao();
List<Customers> customers = dao.listCustomers();

请注意，我正在使用资源尝试，此代码对于连接泄漏是安全的、干净且简单明了，您可能不想遵循包含工厂、接口和所有管道的完整 DAO 模式，在许多情况下不要增加真正的价值。

我认为使用 ThreadLocals 不是一个好主意，在接受的答案中使用的错误是类加载器泄漏的来源

请记住，始终在 try finally 块中关闭您的资源（语句、结果集、连接）或将 try 与资源一起使用

【讨论】：