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

步骤1：连接池

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

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

步骤2：连接到数据库

让我们从创建一个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();

有人可能会争辩说： “您为什么要这样做？”
。但是，您永远都不知道程序员会做什么。即使那样，程序员也可能在打开新连接之前先关闭连接。另外，这浪费了应用程序资源。
如果您实际上希望拥有两个或多个打开的连接，请在此处停止，这将是每个用户一个连接的实现。

为了使它成为单点，我们将必须将此类转换为 singleton
。单例是一种设计模式，它允许我们只有一个给定对象的一个​​实例。因此，让我们将其设为单例！

• 我们必须将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

DAOManager没有DAO，A 算不了什么。因此，我们至少应该创建其中的几个。

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还可以将当前连接交给他们！

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

首先，让我们创建一个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以便更好地处理交易。我还做的是，不仅持有a
Connection，DAOManager还持有a PreparedStatement和a
ResultSet。因此，调用close()时也会同时关闭两者。关闭语句和结果集的快速方法！

希望本指南对您的下一个项目有帮助！