Java 代碼重用：操作與上下文重用
目錄
- 功能重用
- 參數化操作
- 上下文重用
- 上下文作為模板方法
- 結束語
我幾乎不需要討論為什麽重用代碼是有利的。代碼重用通常使得程序開發更加快速，並使得 BUG 減少。一旦一段代碼被封裝和重用，那麽只需要檢查很少的一段代碼即可確保程序的正確性。如果在整個應用程序中只需要在一個地方打開和關閉數據庫連接，那麽確保連接是否正常則容易的多。但我確信這些你已經都知道了。
有兩種類型的重用代碼，我稱它們為重用類型：
- 功能重用（Action Reuse）
- 上下文重用（Context Reuse）
第一種類型是功能重用，這是最常見的一種重用類型。這也是大多數開發人員掌握的一種。即重用一組後續指令來執行某種操作。
第二種類型是上下文重用，即不同功能或操作代碼在相同上下文之間，將相同上下文封裝為重用代碼（這裏的上下文指的是一系列相同的操作指令）。雖然它在控制反轉中越來越受歡迎但它並不常見。而且，上下文重用並沒有被明確的描述，因此它並沒有像功能重用一樣被系統的使用。我希望你看完這篇文章之後會有所改變。
功能重用
功能重用是最常見的重用類型。它是一組執行某種操作指令的重用。下面兩個方法都是從數據庫中讀取數據：
public List readAllUsers(){
Connection connection = null;
String sql = "select * from users" public List readUsersOfStatus(String status){
Connection connection = null;
String sql = "select * from users where status = ?";
List users = new ArrayList();
try{
connection = openConnection();
PreparedStatement statement = connection.prepareStatement(sql);
statement.setString(1, status);
ResultSet result = statement.executeQuery();
while(result.next()){
// 重用代碼
User user = new User();
user.setName (result.getString("name"));
user.setEmail(result.getString("email"));
users.add(user);
// END 重用代碼
}
result.close();
statement.close();
return users;
}
catch(SQLException e){
//ignore for now
}
finally {
//ignore for now
}
}對於有經驗的開發人員來說，可能很快就能發現可以重用的代碼。上面代碼中註釋標記的地方是相同的，因此可以封裝重用。這些行是將用戶記錄讀入用戶實例的操作。可以將這些行代碼封裝到他們自己的方法中，例如：
private User readUser(ResultSet result) throws SQLException {
User user = new User();
user.setName (result.getString("name"));
user.setEmail(result.getString("email"));
users.add(user);
return user;
}現在，可以從上述兩種方法中調用readUser()方法（示例顯示第一個方法）：
public List readAllUsers(){
Connection connection = null;
String sql = "select * from users";
List users = new ArrayList();
try{
connection = openConnection();
PreparedStatement statement = connection.prepareStatement(sql);
ResultSet result = statement.executeQuery();
while(result.next()){
users.add(readUser(result))
}
result.close();
statement.close();
return users;
}
catch(SQLException e){
//ignore for now
}
finally {
//ignore for now
}
}readUser()方法也可以在它自己的類中使用私有方法隱藏。
上面就是關於功能重用的內容。功能重用是將一組執行特定操作的指令通過方法或類封裝它們來達到重用。
參數化操作
有時，你希望重用一組指令，但是這些指令在使用的任何地方都不完全相同。例如readAllUsers()和readUsersOfStatus()方法都是打開一個連接，準備一條語句，執行它，並循環訪問結果集。唯一的區別是readUsersOfStatus()在PreparedStatement上設置一個參數。這兩種方法可以合並為一個readUserList()方法，如下所示：
private List readUserList(String sql, String[] parameters){
Connection connection = null;
List users = new ArrayList();
try{
connection = openConnection();
PreparedStatement statement = connection.prepareStatement(sql);
for (int i=0; i < parameters.length; i++){
statement.setString(i, parameters[i]);
}
ResultSet result = statement.executeQuery();
while(result.next()){
users.add(readUser(result)) // 重用
}
result.close();
statement.close();
return users;
}
catch(SQLException e){
//ignore for now
}
finally {
//ignore for now
}
}現在可以像下面這樣從readAllUsers()和readUsersOfStatus()調用此方法：
public List readAllUsers(){
return readUserList("select * from users", new String[]{});
}
public List readUsersWithStatus(String status){
return readUserList("select * from users", new String[]{status});
}我相信你可以找出其他更好的辦法來實現重用操作，並將他們參數化更加可重用。
上下文重用
上下文重用與功能重用略有不同。上下文重用是一系列指令的重用，各種不同的操作總是在這些指令之間進行。換句話說，重復使用各種不同行為之前和之後的語句。因此上下文重用通常會導致控制風格類的反轉。上下文重用是重用異常處理，連接和事務生命周期管理，流叠代和關閉以及許多其他常見操作上下文的非常有效的方法。
這裏有兩個方法都是用InputStream做的：
public void printStream(InputStream inputStream) throws IOException {
if(inputStream == null) return;
IOException exception = null;
try{
int character = inputStream.read();
while(character != -1){
System.out.print((char) character); // 不同
character = inputStream.read();
}
}
finally {
try{
inputStream.close();
}
catch (IOException e){
if(exception == null) throw e;
}
}
}
public String readStream(InputStream inputStream) throws IOException {
StringBuffer buffer = new StringBuffer(); // 不同
if(inputStream == null) return;
IOException exception = null;
try{
int character = inputStream.read();
while(character != -1){
buffer.append((char) character); // 不同
character = inputStream.read();
}
return buffer.toString(); // 不同
}
finally {
try{
inputStream.close();
}
catch (IOException e){
if(exception == null) throw e;
}
}
}兩種方法與流的操作是不同的。但圍繞這些操作的上下文是相同的。上下文代碼叠代並關閉 InputStream。上述代碼中除了使用註釋標記的不同之處外都是其上下文代碼。
如上所示，上下文涉及到異常處理，並保證在叠代後正確關閉流。一次又一次的編寫這樣的錯誤處理和資源釋放是很繁瑣且容易出錯的。錯誤處理和正確的連接處理在JDBC事務中更加復雜。編寫一次並在任何地方重復使用會比較容易。
幸運的是，封裝上下文的方法很簡單。 上下文本身被放入它自己的類中。 在上下文的使用中，不同的操作被抽象到操作接口之中。 然後將每個操作封裝在實現該操作接口的類中。上下文只需要插入一個操作實例。可以通過將操作實例作為參數傳遞給上下文對象構造函數，或者通過將操作實例作為參數傳遞給上下文的 execute 方法來完成。
下面展示了如何將上述示例分隔為上下文和操作。StreamProcessor（操作）作為參數傳遞給StreamProcessorContext的processStream()方法。
// 流處理插件接口
public interface StreamProcessor {
public void process(int input);
}
// 流處理上下文類
public class StreamProcessorContext{
// 下面將 StreamProcessor processor 操作實例作為參數
public void processStream(InputStream inputStream, StreamProcessor processor) throws IOException {
if(inputStream == null) return;
IOException exception = null;
try{
int character = inputStream.read();
while(character != -1){
processor.process(character);
character = inputStream.read();
}
}
finally {
try{
inputStream.close();
}
catch (IOException e){
if(exception == null) throw e;
throw exception;
}
}
}
}現在可以像下面示例一樣使用StreamProcessorContext類打印出流內容：
FileInputStream inputStream = new FileInputStream("myFile");
// 通過實現 StreamProcessor 接口的匿名子類傳遞操作實例
new StreamProcessorContext()
.processStream(inputStream, new StreamProcessor(){
public void process(int input){
System.out.print((char) input);
}
});或者像下面這樣讀取輸入流內容並添加到一個字符序列中：
public class StreamToStringReader implements StreamProcessor{
private StringBuffer buffer = new StringBuffer();
public StringBuffer getBuffer(){
return this.buffer;
}
public void process(int input){
this.buffer.append((char) input);
}
}
FileInputStream inputStream = new FileInputStream("myFile");
StreamToStringReader reader = new StreamToStringReader();
new StreamProcessorContext().processStream(inputStream, reader);
// do something with input from stream.
reader.getBuffer();正如你所看到的，通過插入不同的StreamProcessor接口實現來對流做任何操作。一旦StreamProcessorContext被完全實現，你將永遠不會有關於未關閉流的困擾。
上下文重用非常強大，可以在流處理之外的許多其他環境中使用。 一個明顯的用例是正確處理數據庫連接和事務（open - process - commit()/rollback() - close()）。 其他用例是 NIO 通道處理和臨界區中的線程同步（lock() - access shared resource - unlock()）。 它也能將API的已檢查異常轉換為未檢查異常。
當你在自己的項目中查找適合上下文重用的代碼時，請查找以下操作模式：
- 常規操作之前（general action before）
- 特殊操作（special action）
- 常規操作之後（general action after）
當你找到這樣的模式時，前後的常規操作就可能實現上下文重用。
上下文作為模板方法
有時候你會希望在上下文中有多個插件點。如果上下文由許多較小的步驟組成，並且你希望上下文的每個步驟都可以自定義，則可以將上下文實現為模板方法。模板方法是一種 GOF 設計模式。基本上，模板方法將算法或協議分成一系列步驟。一個模板方法通常作為一個單一的基類實現，並為算法或協議中的每一步提供一個方法。要自定義任何步驟，只需創建一個擴展模板方法基類的類，並重寫要自定義的步驟的方法。
下面的示例是作為模板方法實現的 JdbcContext。子類可以重寫連接的打開和關閉, 以提供自定義行為。必須始終重寫processRecord(ResultSet result)方法, 因為它是抽象的。此方法提供不屬於上下文的操作，在使用JdbcContext的不同情況下的操作都不相同。這個例子不是一個完美的JdbcContext。它僅用於演示在實現上下文時如何使用模板方法。
public abstract class JdbcContext {
DataSource dataSource = null;
// 無參數的構造函數可以用於子類不需要 DataSource 來獲取連接
public JdbcContext() {
}
public JdbcContext(DataSource dataSource){
this.dataSource = dataSource;
}
protected Connection openConnection() throws SQLException{
return dataSource.getConnection();
}
protected void closeConnection(Connection connection) throws SQLException{
connection.close();
}
// 必須始終重寫 processRecord(ResultSet result) 方法
protected abstract processRecord(ResultSet result) throws SQLException ;
public void execute(String sql, Object[] parameters) throws SQLException {
Connection connection = null;
PreparedStatement statement = null;
ResultSet result = null;
try{
connection = openConnection();
statement = connection.prepareStatement(sql);
for (int i=0; i < parameters.length; i++){
statement.setObject(i, parameters[i]);
}
result = statement.executeQuery();
while(result.next()){
processRecord(result);
}
}
finally {
if(result != null){
try{
result.close();
}
catch(SQLException e) {
/* ignore */
}
}
if(statement != null){
try{
statement.close();
}
catch(SQLException e) {
/* ignore */
}
}
if(connection != null){
closeConnection(connection);
}
}
}
}這是擴展 JdbcContext 以讀取用戶列表的子類：
public class ReadUsers extends JdbcContext{
List users = new ArrayList();
public ReadUsers(DataSource dataSource){
super(dataSource);
}
public List getUsers() {
return this.users;
}
protected void processRecord(ResultSet result){
User user = new User();
user.setName (result.getString("name"));
user.setEmail(result.getString("email"));
users.add(user);
}
}下面是如何使用 ReadUsers 類：
ReadUsers readUsers = new ReadUsers(dataSource);
readUsers.execute("select * from users", new Object[0]);
List users = readUsers.getUsers();如果ReadUsers類需要從連接池獲取連接並在使用後將其釋放回該連接池，則可以通過重寫openConnection()和closeConnection(Connection connection)方法來插入該連接。
註意如何通過方法重寫插入操作代碼。JdbcContext的子類重寫processRecord方法以提供特殊的記錄處理。 在StreamContext示例中，操作代碼封裝在單獨的對象中，並作為方法參數提供。實現操作接口StreamProcessor的對象作為參數傳遞給StreamContext類的processStream(...)方法。
實施上下文時，你可以使用這兩種技術。JdbcContext類可以將實現操作接口的ConnectionOpener和ConnectionCloser對象作為參數傳遞給execute方法，或作為構造函數的參數。就我個人而言，我更喜歡使用單獨的操作對象和操作接口，原因有兩個。首先，它使得操作代碼可以更容易單獨進行單元測試；其次，它使得操作代碼在多個上下文中可重用。當然，操作代碼也可以在代碼中的多個位置使用，但這只是一個優勢。畢竟，在這裏我們只是試圖重用上下文，而不是重用操作。
結束語
現在你已經看到了兩種不同的重用代碼的方法。經典的功能重用和不太常見的上下文重用。希望上下文的重用會像功能重用一樣普遍。上下文重用是一種非常有用的方法，可以從 API 的底層細節（例如JDBC，IO 或 NIO API等）中抽象出代碼。特別是如果 API 包含需要管理的資源（打開和關閉，獲得並返回等）。
persistence/ORM API、Mr.Persister 利用上下文重用來實現自動連接和事務生命周期管理。 這樣用戶將永遠不必擔心正確打開或關閉連接，或提交或回滾事務。Mr.Persister 提供了用戶可以將他們的操作插入的上下文。 這些上下文負責打開，關閉，提交和回滾。
流行的 Spring 框架包含大量的上下文重用。 例如 Springs JDBC 抽象。 Spring 開發人員將其使用上下文重用作為“控制反轉”。 這不是 Spring 框架使用的唯一一種控制反轉類型。 Spring 的核心特性是依賴註入 bean 工廠或“應用程序上下文”。 依賴註入是另一種控制反轉。
參考文章：http://tutorials.jenkov.com/ood/code-reuse-action-and-context-reuse.html#closing-notes
Java 代碼重用：操作與上下文重用