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

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

最佳答案

您将需要实现 DAO 经理 .我的主要想法来自 this website ，但是我自己实现了解决一些问题。

步骤 1:连接池

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

作为记录，我将使用 Java 作为我的语言和 玻璃鱼 作为我的服务器。

第二步:连接数据库

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

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;

}

这不是一个很花哨的类(class)，但它将成为我们要做的事情的基础。所以，这样做:

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

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

第 3 步:让它成为一个点!

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

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

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

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

我们必须转换我们的 public构造函数变成私有(private)的。我们必须只为调用它的人提供一个实例。 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变量每个线程将有一个实例。嘿，它解决了我们的问题! 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

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

A DAO, short for "Data Access Object" is a design pattern that gives the responsability of managing database operations to a class representing a certain table.

为了使用我们的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应该回答这个问题:

Who is the one responsible of managing the connections to the database?

个人 DAO 不应该管理它们，但 DAOManager .我们已经部分回答了这个问题，但现在我们不应该让任何人管理与数据库的其他连接，甚至是 DAO。但是，DAO 需要连接到数据库!谁应该提供？ DAOManager的确!我们应该做的是在 DAOManager 里面做一个工厂方法.不仅如此，还有DAOManager还将把当前连接交给他们!

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

首先，让我们创建一个 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()和 rollback()来自 Connection这样您就可以更好地处理您的交易。我还做的是，而不是仅仅拿着 Connection , DAOManager还持有PreparedStatement和一个 ResultSet .因此，在拨打 close() 时它也关闭两者。关闭语句和结果集的快速方法!

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

关于java - 如何使用 JDBC 和连接池实现 DAO 管理器？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12812256/

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

上一篇：delphi - 从 Delphi 中的其他单元定义类型

下一篇：java - 使用 StringTemplate 中的参数调用 Java 函数？