您将需要实现 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

：

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

您还可以实现封装的方法

setAutoCommit()

，

commit()

并

rollback()

从中封装方法，

Connection

以便更好地处理交易。我还做的是，不仅持有a

Connection

，

DAOManager

还持有a

PreparedStatement

和a

ResultSet

。因此，调用

close()

时也会同时关闭两者。关闭语句和结果集的快速方法！

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