java - 如何使用 JDBC 和连接池实现 DAO 管理器？

Question

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

score 94 · Accepted Answer

您将需要实现一个DAO 管理器。我从这个网站获取了主要思想，但是我自己实现了解决一些问题。

第 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 步：但是有一些问题......

是的，确实有。单例只会为整个应用程序创建一个实例！这在很多层面上都是错误的，特别是如果我们有一个应用程序将是多线程的 Web 系统！那我们怎么解决这个问题呢？

Java 提供了一个名为ThreadLocal. 一个ThreadLocal变量每个线程都有一个实例。嘿，它解决了我们的问题！查看更多关于它是如何工作的，你需要了解它的目的，这样我们才能继续。

让我们做我们的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， ADAOManager什么都不是。所以我们至少应该创建几个。

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(); }

}

您还可以实现封装的方法setAutoCommit()，commit()这样您就可以更好地处理您的事务。我还做的是，不仅持有 a ，还持有 a和 a 。因此，在调用它时也会关闭两者。关闭语句和结果集的快速方法！rollback()ConnectionConnectionDAOManagerPreparedStatementResultSetclose()

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

score 7 · Accepted Answer

我认为如果你想用普通的 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 不是一个好主意，在接受的答案中使用的 Bad 是类加载器泄漏的来源

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