如何使用 JDBC 和連接池實現 DAO 管理器？

Question

我的問題如下。 我需要一個作為 Web 系統中數據庫連接的單點工作的類，以避免一個用戶打開兩個連接。 我需要它盡可能優化，它應該管理系統中的每筆交易。 換句話說，只有那個類應該能夠實例化 DAO。 為了讓它更好，它還應該使用連接池！ 我應該怎么辦？

Answer 1

您將需要實現一個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， DAOManager什么都不是。 所以我們至少應該創建幾個。

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 ，它們都只有一個名為data的String字段及其 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(); }

}

您還可以實現從Connection封裝setAutoCommit() 、 commit()和rollback()的方法，以便更好地處理事務。 我還做的是， DAOManager不僅持有一個Connection ，還持有一個PreparedStatement和一個ResultSet 。 因此，當調用close()時，它也會同時關閉兩者。 關閉語句和結果集的快速方法！

我希望本指南可以在您的下一個項目中對您有所幫助！

Answer 2

我認為如果你想用普通的 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 與資源一起使用