實體對象的抽象以及一種基于數據庫的實現

2019-11-18 14:27:20

字體：大中小

來源：轉載

供稿：網友

　　作者：sure160
email: sure160@china.com

簡介：本文探討了關系數據庫中的實體對象在面向對象語言中如何抽象、實現，并提出一種實現方案。
一、為什么要使用實體對象的概念
實體對象指的是可永久存儲的數據對象，通常可以用關系數據庫的一張數據表或一張主表和與之連接的幾張子表來表示。為什么要引入實體對象的概念呢？我可以肯定您是看過關于面向對象優點的長篇大論的，不過我覺得有必要再嘮叨兩句，因為不是所有用C++或java編程的人都是使用面向對象的方式想問題的。

在現實世界中，對象比它的屬性要穩定，所以數據要抽象成對象。比如由于需求的修改，一個圖書治理系統要顯示更多的書目具體信息，圖書的屬性發生了變化，而圖書這個對象并沒有變，和其他對象（例如書架、借閱者）之間的關系也沒有變。用一個數據對象來保存書目信息的程序修改起來要簡單的多。
把實體對象如何永久儲存的方法封裝到對象中可以實現使用對象的外部程序的與數據庫無關，便于程序的移植。
在程序設計中使用實體對象概念把面向對象分析、面向對象設計、面向對象編碼著幾個步驟連貫和一致。
可以減少外部程序中復雜性，使用這些實體對象的程序只需要簡單的調用insert()或update()的方法，而不用去寫討厭的SQL語句。

但是，由于歷史原因，即使象Java這樣的新興語言，也沒有在所有地方完全利用面向對象的思想。讓我們看看JDBC吧，這是一個號稱用對象封裝的數據庫接口。可是它封裝的是什么呢？連接、語句、結果集和存儲過程。這其實并不是我們設計系統所關心的東西，我們關心的是數據對象本身，而不是它從數據庫中提取的方法。當然，JDBC本身也不該受到太多的指責，因為他本來的目標就是封裝、屏蔽關系型數據庫之間的差異，而不是企圖實現一個面向對象的數據庫。

EJB第一次引起我的注重就是因為它提出的Entity Bean，也就是實體對象。它對實體對象提供了一套完整的實現思路，但是我認為它太復雜了，主要原因是EJB想要做的事太多了。大部分情況下我并不需要分布式處理，我也不需要把實體對象存儲到文件中去。我需要的僅僅是在一個本地運行的基于數據庫的程序。

二、EJB如何實現的實體對象
剛才提到了EJB已經實現了實體對象，那么讓我們看看它是如何實現的。EJB中Entity Bean的對象實際上是對數據對象的一種完美的抽象，在這里我們幾乎看不到數據庫治理系統的作用。一個實體對象有幾種狀態，在內存中、在磁盤緩存中、或者在數據庫中，實體對象的這些狀態通常我們是不關心的，EJB的容器在必要的情況下會自動轉換對象的狀態，也就是說自動把它存到數據庫中，或從數據庫中取出。我們要訪問一個數據對象，要向一個對象容器提出申請，由它返回一個對象實例供我們使用。一個Entity Bean對應于數據表中的一行。假如我們訪問的是同一行數據，對象容器返回的是不同的對象，但都指向同一個Entity Bean，并把我們所有的方法請求都發送給這個Entity Bean。實際上EntityBean的容器基本實現了一個面向對象的數據庫。它這種實現方法帶來幾個顯著的問題：

運行效率非常低。JAVA的速度慢是個老問題了，EJB的速度慢不光是因為大量代碼用JAVA實現，而且由于它的結構，要根據數據表中的某一個屬性查出一行數據，必須首先用SQL查詢查找到這一行的主鍵（PRimary Key），然后通過主鍵來找到這個Bean，假如這個Bean不在內存中--很不幸，這種情況經常發生，那么實際上是執行了兩次SQL查詢才找到一行數據。
容器本身要治理事務，以防數據的污讀、污寫、死鎖等等一系列問題。本來DBMS治理這類問題已經有很多年經驗了，已經相當完美的解決了這些問題，可是EJB不得不通過一個Transcation Server來治理這些問題。這使得容器的代碼變得極其復雜，另外編程人員也不得不重新熟悉這些接口。
由于bean 中的數據是否存儲在數據庫里是由容器治理的，那么其他程序訪問數據庫會帶來數據同步的問題。因此，在EJB架構中，外部程序不能直接訪問數據庫，只能通過EJB訪問。

三、我們實現的目標
我們只想把數據庫對象更好的封裝起來，為什么要購買別人昂貴的代碼？為什么要為我們不會用到的分布式去犧牲大量的性能。我們想要盡量使用DBMS的功能，以實現最佳的性能和最簡化的代碼。

事務處理最好還是用DBMS來治理，因為它一向管得很好，而且事務處理的代碼很復雜，我不打算自己來完成。

我不打算用同一個對象來指向數據庫的一行。數據庫的一行數據在程序中可能有多個對象，這些對象都應該是臨時對象，而不是永久對象。他們的共享問題由DBMS本身加鎖來解決。

由于我們只是為訪問DBMS提供了一個接口，外部程序完全可以不通過這個接口來訪問數據庫。

實現后，使用實體對象的代碼要簡單。例如，數據庫里有一個表account，它只有兩個字段accountid和name，我們把它作為一個實體對象Account，假設我們要完成從數據庫查詢、修改、插入，使用它的代碼片段如下：
Connection conn=ConnectionPool.getConn(); //也可以通過標準的DriverManager得到數據庫連接，這是完全一樣的

Conn.setAutoCommit(false); //假如不使用事務，這一行可以省去

Account a1=new Account(conn);

a1.getByAccountId(1); //查找到相應記錄

System.out.println(a1.name);

a1.getByAccountIdForUpdate(1); //假如企圖修改一個對象，必須通過forUpdate系列的方法得到這個對象

a1.name="new name";

a1.update(); //修改原有記錄

Account a2=new Account(conn);

a2.accountId=3;

a2.name="姚大";

a2.insert(); //插入一條新記錄

conn.commit();

實體對象的屬性通過方法修改是比較理想的方式，如用getName()，setName()兩個方法訪問Name屬性。這還可以解決屬性之間相互關聯的問題。例如，表中有一個地區代碼和地區名稱兩個域，必須保持一致，這就可以考慮在屬性設置方法中實現。在這里我們為了簡單，直接通過屬性修改，在一般情況下，我覺得也是可以接受到。

有一點必須注重的就是多線程程序所帶來的數據完整性問題。對于我們常使用的從數據庫讀取數據到對象中->修改對象屬性->更新到數據庫這個流程，非常輕易出現數據完整性破壞問題。比如一個進程中甲對象讀取數據后，另一個進程中乙對象又修改了同一數據，這時甲對象再次更新數據庫會帶來污寫。解決的辦法是對象增加一個方法給數據庫的這條記錄加鎖。例如Account.getByAccountId函數改為Account.getByAccountIdForUpdate，這個函數中相應的sql語句（Oracle數據庫）改為"select AccountId,name from account where accountId=? for update"，這樣數據取出后就自動加鎖，這個鎖將會在事務提交或回滾時釋放。for update在SQLServer相應的語法為holdlock。

說到數據庫加鎖的問題就不能不考慮到數據庫死鎖的可能。想完全避免死鎖是很困難的，只有盡量降低這種可能性。方法是：1、盡量少使用forUpdate這種函數，只有在更改數據庫數據時才使用。查詢的時候不要用，假如查詢后根據某個條件有可能修改，那么在查詢時不加鎖，在修改前重新調用forUpdate函數加鎖。2、盡量以某個特定的順序加鎖。例如有表A和表B，兩個程序都要同時更新這兩個表，最好都是先訪問表A，再訪問表B。

Oracle有個很好的功能就是自動檢測死鎖。假如發生死鎖，會回滾一個事務，并返回一個SQL錯誤，我們的程序要檢測這個異常，處理程序中可能的錯誤。

上面說到的對象中，只有getByXXX（）這樣的方法，這種方法只會返回唯一的對象，假如想要返回一組對象，這時需要一個輔助類來實現。這個輔助類稱為對象瀏覽器EntityBrowser。再實體對象中返回一個對象瀏覽器的方法一般命名為getAllByXXX()

使用對象瀏覽器EntityBrowser要列出所有account表中的id和name的代碼如下，其實這個對象瀏覽器和Java定義的Enumeration接口的最大區別就是它有一個close方法。請看下面的代碼片斷，它輸出所有的Accout對象。

Connection conn=ConnectionPool.getConn();

Account a1=new Account(conn);

EntityBrowser browser=a1.getAll();

System.out.println("==Account List==");

While (browser.hasMoreElement()) {

Account a=(Account)browser.nextElement();

System.out.print(a.accountId);

System.out.print("--");

System.out.println(a.name);

}

browser.close();

以上就是我們要實現的實體對象，下面介紹如何編寫一個實體對象。

四、實現的代碼解釋
首先，下面的代碼定義一個所有實體對象的基礎類EntityObject，這是一個抽象類，不能直接使用，但為其它實體對象定出了一個結構。
Import java.sql.*;
/**所有實體對象基礎類*/
abstract public class EntityObject {
protected java.sql.Connection _conn;
private boolean _dbStored;
/**實體對象需要用一個數據庫連接初始化，這樣可以利用這個連接做事務提交或回滾*/
public EntityObject(Connection conn) {_conn=conn;_dbStored=false;}

/**這個方法用來插入新記錄，子類必須重定義這個方法*/
public void insert() throws SQLException{ _dbStored=true;}

/**這個方法用來修改數據庫原有記錄，子類必須重定義這個方法*/
public void update() throws SQLException {_dbStored=true; }

/**這個方法用來刪除數據庫原有記錄，子類必須重定義這個方法*/
public void delete() throws SQLException {_dbStored=false; }

/**這個方法用來把數據庫select語句得出的結果映射到對象的屬性中去，子類必須重定義這個方法*/
public void _setAttribute(ResultSet rs) throws SQLException {_dbStored=true; }

/**這個方法可以判定這個對象是否已存在數據庫中*/
public boolean isDbStored() {return _dbStored;}
/**這個方法將實體對象設為不存在數據庫中，所有的getByxxx()方法首先要調用這個方法，使本對象無效，才能用select語句得到符合條件的對象*/
public void clearDbStored() {_dbStored=false;}
}

下面我們就可以定義一個實際的實體類。考慮一種簡單情況，實體對象在關系數據庫中只用一張表表示。這樣的實體對象定義最簡單。例如，數據庫里有一個表account，它只有兩個字段accountid和name，下面定義它的實體類。實體類必須重載insert,update,_setAttribute方法，然后根據需要增加getByXXX()方法，根據某個屬性從數據庫查找一個對象。

Import java.sql.*;
public class Account extends EntityObject {
/*這里定義實體對象類所有的屬性*/
public int accountId;
public String name;
//最好將實體對象中的屬性全部定義成私有，然后定義getXXX(), setXXX()兩個方法來訪問這個屬性，這樣的封裝性最好，但略過于麻煩。假如數據結構預料會經常修改，最好用這個辦法。否則，定義成公有屬性也可。
Public Account(Connection conn){ super(conn); }
//重定義這個方法，執行實際的sql命令
public void insert() throws SQLException {
PreparedStatement ps=_conn.prepareStatement ("insert into account(accountid,name) values(?,?)");
ps.setInt (1,accountId);
ps.setString (2,name);
ps.execute();
ps.close();
super.insert(); //注重，重載insert方法必須要有這一句
}
//重定義這個方法，執行實際的sql命令
public void update() throws SQLException {
PreparedStatement ps=_conn.prepareStatement ("update account set accountid=?, name=? Where accountid=?");
ps.setInt(1,accountId);
ps.setString(2,name);
ps.setInt(3,accountId);
ps.execute();
ps.close();
super.update(); //注重，重載update方法必須要有這一句
}
//重定義這個方法，執行實際的sql命令
public void delete() throws SQLException {
if (isDbStored()) {
PreparedStatement ps=_conn.prepareStatement("delete account where accountid = ? ");
ps.setInt(1,accountId);
ps.execute();
ps.close();
}
super.delete();
}
//下面這個方法把一個ResultSet轉換成對象中的屬性，下面所有的getByXXX方法都會用到這個方法。
public void _setAttribute(java.sql.ResultSet rs) throws SQLException {
accountId=rs.getInt(1);
name=rs.getString(2);
super._setAttribute(rs); //注重，重載_setAttribute方法必須要有這一句
}
//根據條件取得對象
public boolean getByAccountId(int id) throws SQLException {
clearDbStored();
PreparedStatement ps=_conn.prepareStatement ("select AccountId,Name from account where AccountId=?");
//這里的select語句得到的結果集必須與上面的_setAttribute方法假定的結果集一致
ps.setInt(1,id);
ResultSet rs=ps.executeQuery();
if (rs.next())
_setAttribute(rs);
rs.close();
ps.close();
return (isDbStored());
}
//根據條件取得對象并企圖修改
public boolean getByAccountIdForUpdate(int id) throws SQLException {
clearDbStored();
PreparedStatement ps=_conn.prepareStatement ("select AccountId,Name from account where AccountId=? for update");
ps.setInt(1,id);
ResultSet rs=ps.executeQuery();
if (rs.next())
_setAttribute(rs);
rs.close();
ps.close();
return (isDbStored());
}
}

上面說到的對象中，只有getByXXX（）這樣的方法，這種方法只會返回唯一的對象，這時，也不用保存數據庫結果集，假如出現返回一組對象的情況，就不能不保存結果集了，這時需要一個輔助類來實現。這個輔助類稱為對象瀏覽器，下面定義對象瀏覽器。

import java.sql.*;
/**所有實體對象的瀏覽器的父類*/
abstract class EntityBrowser {
protected ResultSet _rs;
protected Connection _conn;
protected boolean _hasMoreElement;
/**瀏覽器是否還有下一個記錄*/
public boolean hasMoreElement() throws SQLException{
return _hasMoreElement;
}
/**返回下一個記錄，子類必須重載這個函數*/
abstract public Object nextElement() throws SQLException;
/**關閉這個瀏覽器*/
public void close () throws SQLException{
_rs.getStatement().close();
}
/**瀏覽器構造函數，指定一個數據庫連接*/
public EntityBrowser(ResultSet rs) throws SQLException {
_rs=rs;
_conn=_rs.getStatement().getConnection();
_hasMoreElement=_rs.next();
}
//子類重載nextElement（）時調用這個方法
protected Object _nextEntityObj(EntityObject eo) throws SQLException {
if (_hasMoreElement) {
eo._setAttribute(_rs);
} else eo=null;
_hasMoreElement=_rs.next();
return (eo);
}
}

有了EntityBrowser類后，我們來修改剛才定義的Account類。第一步是要在Account類里定義一個私有的EntityBrowser子類，這個子類只要定義一個構造函數并重載nextElement()方法即可。這里使用了在一個類里定義另一個類的技巧，這個技巧在java的容器類庫中經常使用。第二步是在Account類中增加一個方法getAllByXX()，返回一組實體對象的方法名常用getAll打頭。請看以下修改的代碼片段。

import java.sql.*;
public class Account extends EntityObject {
。。。
/*以下是新修改的代碼*/
//定義一個子類
private class AccountBrowser extends EntityBrowser {
AccountBrowser (ResultSet rs) throws SQLException { super(rs); }
Public Object nextElement() throws SQLException{
Account ac=new Account(_conn);
return (_nextEntityObj(ac));
}
}
//下面是實體對象的方法
public EntityBrowser getAll() throws SQLException {
PreparedStatement ps=_conn.prepareStatement("select AccountId,Name from account ");
ResultSet rs=ps.executeQuery();
return (new AccountBrowser(rs));
}
public EntityBrowser getAllByName(String name) throws SQLException {
PreparedStatement ps=_conn.prepareStatement(“select AccountId,Name from account where name like ?”;
ps.setString(1,name);
ResultSet rs=ps.executeQuery();
return (new AccountBrowser(rs));
}

接下來，討論一下數據表的連接關系，關系數據庫主要有一對一，一對多，多對多，多對一的關系。比如教師和學生之間的教課關系，這是一種多對多的關系。有的關系是有自己的屬性，比如教課時間，我們可以把所有的關系都看作一個實體對象。但是為了簡化程序，對于那些沒有自己屬性的一對一，一對多關系我們可以把它簡化成父、子表的關系。表示數據庫中的主表和子表有兩種方法。

一種方法把子表和主表看作一個實體對象，子表用Vector或HashTable這樣的Collection定義成主表的一個屬性，在_setAttribute方法中，再執行一次sql查詢，把查詢出的子表數據放入collection中。同時還要修改insert,update方法，使得主表的實體對象每次數據插入或修改時都要刪除并重新插入子表的數據。這里實際上把子表看作主表的一種附屬數據結構，而不是獨立的對象，子表的數據庫操作全部由主表來完成。

另一種方法是把子表看作一個單獨的實體類，實際上這時不存在主表和子表的概念了。只有兩個實體對象，他們之間是一種關聯的關系。主表通過getXXByXX（）的方法來返回一個子表類的Browser。可以通過定義主表的一個方法insertXX（）, 調用子表的insert()來插入一個新的子表項目;定義deleteXXX()來刪除子表項目。至于更新子表數據，可以直接調用子表實體類的update()方法，不需要使用主表類的任何方法。

對于一個視圖，也可以參照定義實體類的方法定義一個視圖類，不過要盡量少用視圖類，因為視圖類和其他實體對象雖然語法上看不出關聯，但語義上實際上是有關聯的。一個實體類的修改經常要修改所有相關的視圖類，這對于數據封裝是很不利的。只有出于性能的考慮我們才使用它。

最后，探討一下數據庫事務的概念。事務是建立在數據庫連接的基礎上的，可以一次提交或回滾一系列操作。要實現事務，必須把數據庫連接的自動提交屬性設為false。java缺省的連接都是自動提交的，實現事務必須強制執行一個conn.setAutoCommit(false)。假如連接不是自動提交的，那么要注重，每當一個事務完成時必須執行commit或rollback，就算是select語句也必須提交事務。而且事務最好能盡早提交，比如每次select后提交，這樣可以減少數據庫資源的占用。

上一篇：實現Swing的JTables和Excel間的復制和粘貼功能

下一篇：實現Java與C語言接口