我的问题如下。我需要一个类，作为Web系统中数据库连接的单点，以避免一个用户有两个打开的连接。我需要它尽可能优化，它应该管理系统中的每个事务。换句话说，只有该类应该能够实例化DAO。为了使其更好，它还应该使用连接池！我该怎么办？
您将需要实现一个 DAO 管理器。我从这个网站获得了主要思想，但是我制作了自己的实现，解决了一些问题。
首先，您必须配置一个连接池。连接池是连接池。当应用程序运行时，连接池将启动一定数量的连接，这样做是为了避免在运行时创建连接，因为这是一个昂贵的操作。本指南并不是要解释如何配置一个，所以请四处看看。
为了记录在案，我将使用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();
应打开并关闭与对象中数据库的连接。
现在，如果我们这样做会怎样？
DAOManager mngr1 = new DAOManager();
DAOManager mngr2 = new DAOManager();
mngr1.open();
mngr2.open();
有些人可能会争辩说，“你为什么要这样做？但是你永远不知道程序员会做什么。即便如此，程序员也可能在打开新连接之前伪造关闭连接。另外，这是对应用程序资源的浪费。如果您确实希望拥有两个或多个打开的连接，请在此处停止，这将是每个用户一个连接的实现。
为了使它成为单个点，我们必须将此类转换为单例。单例是一种设计模式，它允许我们拥有任何给定对象的一个且只有一个实例。所以，让我们把它变成一个单例！
publicDAOManagerprivategetInstance()让我们看看它是如何实现的。
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
但是单例是一个反模式，因为原因！我知道有些人不会喜欢单例。然而，它很好地解决了这个问题（并且已经解决了我的问题）。这只是实现此解决方案的一种方式，如果您有其他方法，欢迎您提出建议。
是的，确实有。单个实例将仅为整个应用程序创建一个实例！这在很多层面上都是错误的，特别是如果我们有一个Web系统，我们的应用程序将是多线程的！那么，我们该如何解决这个问题呢？
Java 提供了一个名为 的类。变量的每个线程都有一个实例。嘿，它解决了我们的问题！了解更多关于它是如何工作的，你需要了解它的目的，以便我们可以继续。ThreadLocalThreadLocal
让我们做我们的然后。按以下方式修改类：INSTANCEThreadLocal
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
没有 DAO，A 什么都不是。因此，我们至少应该创建其中的几个。DAOManager
DAO，“数据访问对象”的缩写，是一种设计模式，它将管理数据库操作的责任赋予表示某个表的类。
为了更有效地使用我们，我们将定义一个 ，这是一个抽象的DAO，它将保存所有DAO之间的公共操作。DAOManagerGenericDAO
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：和 ，两者都只有一个名为的字段及其 getter 和 setter。FirstSecondStringdata
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"
DAOManager不仅应该起到作为单个连接点的目的。实际上，应该回答这个问题：DAOManager
谁负责管理与数据库的连接？
单个 DAO 不应该管理它们，但是 .我们已经部分回答了这个问题，但现在我们不应该让任何人管理与数据库的其他连接，甚至不应该管理DAO。但是，DAO需要连接到数据库！谁应该提供它？ 事实上！我们应该做的是在 里面做一个工厂方法。不仅如此，而且还会将当前连接交给他们！DAOManagerDAOManagerDAOManagerDAOManager
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.");
}
}
我们现在很高兴去。请尝试以下代码：
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();
它不是花哨且易于阅读吗？不仅如此，当您调用 时，您关闭了DAO正在使用的每个连接。但是如何做到呢？！好吧，他们共享相同的连接，所以这是很自然的。close()
从现在开始，我们可以做几件事。要确保连接已关闭并返回到池，请在 中执行以下操作：DAOManager
@Override
protected void finalize()
{
try{ this.close(); }
finally{ super.finalize(); }
}
您还可以实现封装 的方法，并从 中更好地处理事务。我还做的是，不仅持有 a，还持有 a 和 a 。因此，当调用它时，也会关闭两者。结束语句和结果集的快速方法！setAutoCommit()commit()rollback()ConnectionConnectionDAOManagerPreparedStatementResultSetclose()
我希望本指南可以在您的下一个项目中对您有所帮助！
我认为，如果你想在普通的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是一个好主意，在接受的答案中使用不好是类加载器泄漏的来源
记住总是关闭你的资源（语句，结果集，连接）在尝试最后阻止或使用尝试与资源
