pureQuery 是包含在 Data Studio 中的 IBM 新開發平台，用於開發 Java™ 數據庫訪問應用程序。它簡單的 API 和集成工具不僅提高了數據訪問開發人員的效率，還鼓勵遵守編碼最佳實踐以獲得更好的應用程序性能。Spring 是一個開源的 Java/J2EE 應用程序框架，它提供了更高級的數據訪問特性，比如事務管理、資源管理以及 Data Access Object 層次結構。如果將它與 pureQuery 集成起來，將帶來更簡單的應用程序開發與維護體驗。本教程引導您構建具有 Spring Framework 數據訪問特性的 pureQuery 應用程序。
關於本教程
本教程向您展示如何在 IBM Data Studio 中一步一步創建各種 Java 數據訪問應用程序。分兩種情況講述：一種是有 pureQuery 或 Spring 支持，一種情況是沒有 pureQuery 或 Spring 支持。
學習以下內容：
使用 IBM Data Studio Developer 創建一個簡單的 Java 數據訪問應用程序，並通過它訪問 DB2 示例數據庫
使用 Spring 的 JdbcTemplate 實現相同的 Java 數據訪問應用程序
使用 Spring 通過以下步驟創建一個 Data Studio pureQuery 應用程序：
生成一個 pureQuery 應用程序，並運行它
向生成的 pureQuery 應用程序添加 Spring 數據訪問支持
通過 pureQuery 的靜態綁定特性運行這個應用程序
先決條件
本教程面向以下數據庫編程人員：對 Data Studio 或 Eclipse 環境有一定的了解，但不一定要熟悉 pureQuery 或 Spring Framework。
系統要求
本教程需要您安裝以下產品：
帶有 SAMPLE 數據庫的 IBM DB2 9.5 for Linux, UNIX and Windows
IBM Data Studio Developer V 1.1.x。也可以使用從網上下載的 IBM Data Studio 1.1.x，但它不支持將在最後一部分講述的靜態綁定
Spring Framework 2.0.x with Dependencies
IBM pureQuery 和 Spring 集成工具箱
一個簡單的 Java 數據訪問應用程序
本小節展示如何在 Data Studio 內部創建一個 JDBC 應用程序，然後通過它訪問示例 DB2 數據庫中的帳戶 “ACT” 表。它利用 DAO（Data Access Object）設計模式，在這種模式下，業務應用程序對接口而不是具體對象進行編碼。因此，這實現了業務邏輯和數據訪問的分離。
需要的 4 個文件：
一個保存查詢所返回數據的 bean 類，它代表帳戶業務對象 —— Account.java
聲明應用程序可以調用的數據訪問方法的 DAO（Data Access Object）接口 —— AccountData.java
實現在 DAO 接口中定義的方法的 DAO 實現 —— AccountDao.java
調用方法的應用程序 —— AccountApp.java
如圖 1 所示，應用程序通過調用在接口中聲明的方法訪問數據庫。
圖 1. 結構流程
bean 類
bean 類有三個數據字段（actno、actkwd 和 actdesc），它們代表了來自 ACT 表的三個列。清單 1 展示了保存查詢所返回數據的 bean 類，它代表帳戶業務對象。
清單 1. Account.java
package com.test;
public class Account {
protected short actno;
protected String actkwd;
protected String actdesc;
public Account () {
super();
}
public Account (short actno, String actkwd, String actdesc) {
super();
this.actno = actno;
this.actkwd = actkwd;
this.actdesc = actdesc;
}
public short getActno() {
return actno;
}
public void setActno(short actno ) {
this.actno = actno;
}
public String getActkwd() {
return actkwd;
}
public void setActkwd(String actkwd ) {
this.actkwd = actkwd;
}
public String getActdesc() {
return actdesc;
}
public void setActdesc(String actdesc ) {
this.actdesc = actdesc;
}
}
DAO 接口
DAO 接口聲明了可以通過應用程序調用的方法。在清單 2 所示的簡單示例中只定義了一個方法 getAccounts()，這個方法可以獲取所有來自 ACT 表的行。
清單 2. AccountData.java
package com.test;
import java.util.List;
public interface AccountData {
public String sql = "SELECT * from act";
public List<Account> getAccounts();
}
DAO 實現
通過 DAO 實現可以實現在接口中聲明的方法。在這個示例中，只有一個需要實現的方法 getAccounts()，但仍然需要添加模板 JDBC 代碼，以：
獲得數據庫連接
捕獲 SQL 異常
遍歷結果集
清空資源，比如連接、語句或結果集
清單 3 展示了 getAccounts() 方法的 DAO 實現。
清單 3. AccountDao.java
package com.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class AccountDao implements AccountData{
public List<Account> getAccounts()
{
List<Account> actList = new ArrayList<Account>();
Account act = null;
try{
Connection con = getConnection();
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(sql);
while (rs.next()){
act = new Account(rs.getShort("ACTNO"),
rs.getString("ACTKWD"),
rs.getString("ACTDESC") );
actList.add(act);
}
rs.close();
st.close();
con.close();
return actList;
}
catch (SQLException sqle){
throw new RuntimeException(sqle);
}
}
private Connection getConnection() throws SQLException {
String driver = "com.ibm.db2.jcc.DB2Driver";
String url = "jdbc:db2://localhost:50000/sample";
try{
Class.forName(driver);
}catch(Exception e){
e.printStackTrace();
}
// Replace USERNAME and PASSWORD with your own data
Connection con = DriverManager.getConnection(url,"USERNAME","PASSWORD");
return con;
}
}
應用程序
應用程序首先實例化一個 DAO 對象，然後調用 getAccounts() 方法並將結果輸出到控制台。清單 4 展示了在實例化 DAO 對象之後調用 getAccounts() 方法的應用程序。
清單 4. AccountApp.java
package com.test;
import java.util.List;
public class AccountApp {
public static void main(String [] args) {
AccountData accountData = new AccountDao();
List<Account> actList = accountData.getAccounts();
for (Account act : actList)
System.out.println(" ACTNO=" + act.getActno() +
" ACTKWD="+ act.getActkwd() + " ACTDESC="+act.getActdesc());
}
}
構建並運行應用程序
按照以下步驟創建一個 Data Studio 項目，然後通過這個項目構建並運行應用程序。
創建一個 Data Studio Java 項目。
在菜單欄上導航到 File > New > Project > Java Project。將項目名稱字段改為 DSJdbc。除非特別指明，否則本文中全部采用默認值。
將 JDBC 支持添加到項目。
右鍵單擊項目 DSJdbc 並選擇 Build Path > Configure Build Path…
選擇 Library 選項卡並單擊 Add External Jars…，添加下面的 DB2 JDBC 驅動程序文件。
DB2 INSTALL%\ SQLLIB\java\db2jcc.jar
%DB2 INSTALL%\ SQLLIB\java\db2jcc_license_cu.jar
將源文件添加到項目。
可以從本教程中剪切粘貼 4 個 Java 文件，或者下載本教程的源文件（參見 下載）。
右鍵單擊項目 DSJdbc 並選擇 New > Package。在名稱字段處輸入 com.test。
右鍵單擊剛才創建的包並選擇 Import … > General > File System。更改目錄字段，使它的位置與源文件相同，然後選擇前面創建的 4 個 Java 文件。您所構建的項目應該類似於圖 2。
圖 2. 項目 DSJdbc
運行應用程序：
右鍵單擊 AccountApp.java > Run As > Java Application，將看到類似於圖 3 控制台窗口中的結果。
圖 3. 運行應用程序的結果。
創建一個簡單的 Java 數據訪問應用程序
雖然在 Data Studio 內部創建 Java 數據訪問代碼非常直觀，但在每次實現中都會出現一些重復的代碼，比如獲得連接或捕獲異常的代碼。還有可能出現函數調用結束時資源仍然占用的情況。
用 Spring JdbcTemplate 實現相同的應用程序
通過 Spring JdbcTemplate 的支持可以減少冗余代碼，同時也獲得 Spring 管理特性帶來的好處。圖 4 給出了新的結構流程。
沒有更改的內容：
所有用戶定義接口。
更改的內容：
DAO 實現文件已經變得非常小——已將所有重復的 JDBC 代碼移至 Spring。
由於沒有必要分配和發布 JDBC 資源，不會發生資源洩漏。
不必解釋 SQLExceptions。Spring 已經幫助 DB2 這些主要 DBMS 完成了這個工作。
這個應用程序並不局限於特定的 DBMS 或數據訪問實現。現在它由可以編輯的配置文本文件控制。
將要重用來自最後一節的 Bean 和接口類。需要添加或修改下面的組件：
一個更加簡單的 DAO 實現 —— AccountDao.java
稍微修改應用程序，使它可以加載 Spring 配置文件，而不是直接實例化 DAO 對象 —— AccountApp.java
能夠動態地配置數據源和 DAO 實現的配置文件 —— applicationContext.xml，jdbc.properties。
如圖 4 所示，應用程序只加載了配置文件，並且讓 Spirng 實例化 DAO 實現。Data Source 配置（比如 DBMS 供應商或連接信息）已經從 DAO 實現代碼中移出，並放置到 Spring 配置文件中。
圖 4. Spring 結構的流程
DAO 實現
模板 JDBC 代碼已經替換成 Spring JdbcTemplate。因此，不再需要通過實現代碼來獲得連接、捕獲 SQL 異常、遍歷結果集或清理資源。一個簡單的 queryForList(String sql) 調用返回一個映射列表。可以通過 RowMapper 將每個返回的行映射到 bean 類。清單 5 給出了一個使用 Spring JdbcTemplate 的 DAO 實現。
清單 5. AccountDao.java
package com.test;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class AccountDao extends JdbcDaoSupport implements AccountData{
@SuppressWarnings("unchecked")
public List<Account> getAccounts()
{
JdbcTemplate daoTemplate = this.getJdbcTemplate();
RowMapper mapper = new RowMapper (){
public Object mapRow(ResultSet rs,int rowNum) throws SQLException {
Account act = new Account();
act.setActno(rs.getShort("ACTNO"));
act.setActkwd(rs.getString("ACTKWD"));
act.setActdesc(rs.getString("ACTDESC"));
return act;
}
};
return daoTemplate.query(sql, mapper );
}
}
應用程序
應用程序需要加載 Spring 配置文件，從而啟動 Spring 框架、獲取由該配置定義的 DAO，然後像前面一樣調用 getAccounts() 在接口中聲明的方法。清單 6 展示了這個應用程序。
清單 6. AccountApp.java
package com.test;
import java.util.List;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AccountApp {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(
new String[] {"applicationContext.xml"});
AccountData dao = (AccountData) ac.getBean("ACT_DAO");
List<Account> actList = dao.getAccounts();
for (Account act : actList )
System.out.println(" ACTNO=" + act.getActno() +
" ACTKWD="+ act.getActkwd() + " ACTDESC="+act.getActdesc());
}
}
Spring 配置文件
Spring 使用配置文件初始化並啟動框架。本教程使用一個簡單的配置文件 “applicationContext.xml”（參見清單 7），從屬性文件中獲取數據源信息，以及定義這個應用程序所使用的 DAO 實現類。清單 7 是一個 Spring 配置文件示例。
清單 7. applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<!-- replaces ${...} placeholders with values from properties files -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>jdbc.properties</value>
</list>
</property>
</bean>
<!-- Define datasource -->
<bean id="DB2DataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- Configure DAO -->
<bean id="ACT_DAO" class="com.test.AccountDao">
<property name="dataSource">
<ref bean="DB2DataSource" />
</property>
</bean>
</beans>
清單 8 是一個示例連接屬性文件。
清單 8. jdbc.properties
jdbc.driverClassName=com.ibm.db2.jcc.DB2Driver
jdbc.url=jdbc:db2://localhost:50000/sample:traceFile=C:/sample.log;
traceLevel=-1;traceFileAppend=true;
jdbc.username=USERNAME
jdbc.password=PASSWORD
構建並運行應用程序
根據類似於前面的 “構建並運行應用程序” 小節 的步驟創建一個 Data Studio 項目並運行應用程序。
首先需要下載 Spring Framework 2.0.x with Dependencies，然後解壓縮到本地目錄。本教程使用的是 Spring 2.0，但您也可以使用 Spring 2.5 並相應地更改設置。
根據類似於第一小節的說明創建一個新項目 DSSpring 並添加 JDBC 支持。
將 Spring 庫添加到該項目。
右鍵單擊 DSSpring 項目並選擇 Build Path > Configure Build Path …
單擊 Libraries tab 並選擇 Add External Jars，添加以下 Spring 庫。
%Spring install%/dist/spring.jar
%Spring install%/lib/jakarta-commons/commons-logging.jar
%Spring install%/lib/jakarta-commons/commons-dbcp.jar
%Spring install%/lib/jakarta-commons/commons-pool.jar
根據前一小節的說明，將 4 個 Java 源文件添加到 com.test 包下的“DSSpring”項目。
將配置文件添加到項目。右鍵單擊 DSSpring project 並選擇 Import ... > File System。將字段 “from directory” 更改為配置文件所在的位置。選擇 applicationContext.xml 和 jdbc.properties，然後單擊 Finish。圖 5 展示了這個項目所需要的 Spring 庫和配置文件。
運行應用程序。在 DSSpring 項目中，右鍵單擊 MyApp.java > Run As > Java Application。將在控制台窗口中看到類似於前面小節的結果（圖 3）。
圖 5. 項目 DSSpring
將事務管理添加到應用程序
如本教程開始時所述，除了數據訪問之外，Spring 也支持其他特性，比如事務管理。將清單 9 中的代碼添加到配置文件 applicationContext.xml，啟用 Spring 的聲明性事務管理。
清單 9. 事務管理器
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="DB2DataSource"/>
</bean>
使用 pureQuery 和 Spring Framework
這一節首先展示如何使用 pureQuery 自動生成在前面小節中需要手動創建的代碼，然後介紹如何將 Spring 支持添加到 pureQuery 應用程序。最後，將演示一個獨特的 pureQuery 特性：靜態綁定。
創建一個 pureQuery 應用程序
創建一個連接 DB2 示例數據庫的數據庫連接
啟動 IBM Data Studio 之後，需要創建一個連接示例數據庫的連接。
將 Database Explorer 視圖添加到 Java 透視圖。
導航到 Window > Show View > Other >Data，然後選擇 Database Explorer。
創建一個連接到示例數據庫的連接
展開 Database Explorer 內部的 Connections 節點，如果能夠看到示例數據庫， 就可以進入下一步。否則，右鍵單擊 Database Explorer 內部的 Connections 節點並選擇 New Connections . . .
提供所需的信息，完成 New Connection 向導。
圖 6 展示了 New Connection 對話框。
圖 6. 示例圖
創建一個帶有 pureQuery 支持的 Java 項目
從菜單欄導航到 File > New > Project，然後選擇 Java Project。輸入 PQSpring 作為項目名稱。跟前面一樣，除非特別指定，否則一律使用默認值。單擊 Finish 完成新項目的創建。
右鍵單擊剛才創建的項目並選擇 Add pureQuery Support . . . 。選擇剛才創建的連接 --- Sample --- 作為現有的連接，然後單擊 Finish 完成這個過程。
創建 pureQuery 代碼
展開 Database Explorer 內部的示例數據庫，查找 ATC 表，如圖 7 所示。
圖 7. ACT 表
右鍵單擊 ACT table 並選擇 Generate pureQuery Code …。在 Package 字段，輸入 com.test，然後在 Name 字段輸入 Account。選中 Generate annotated-method interface for table、Generate test class for annotated-method interface for table 和 Include connection information in test 復選框，如圖 8 所示。
圖 8. 為表生成 pureQuery 代碼
單擊 Next 移動到 Bean Fields 對話框，然後選擇 Next 再次導航到 SQL Statements 對話框。在這裡，只需生成可以從 ACT 表選擇所有行的方法，因此選擇 Generate the SQL statements specified below 單選按鈕，然後選擇 Select all rows 復選框，如圖 9 所示。
圖 9. SQL 語句
單擊 Finish 完成代碼生成。現在，已經完成 pureQuery 應用程序，而且不需要編寫任何代碼。
生成的代碼
下面的文件由以上的步驟自動地生成
Account.java —— 保存來自 ACT 表的數據的 bean 類。
AccountData.java —— 僅聲明方法 getAccounts() 的接口。
AccountDataTest.java —— 調用 getAccount() 方法的應用程序。
AccountDataImpl.java —— 在 pureQuerysrc 文件夾下的 DAO 實現。這個文件實現在 AccountData 接口中定義的方法，並且由 pureQuery 生成器在每次更改接口時自動生成（如果開啟 Project Menu 上的 “Build Automatically”）。
運行應用程序
自動生成的應用程序 AccountDataTest.java 需要一個數據庫密碼作為輸入參數。因此，最好創建一個配置來運行這個應用程序，如圖 10 所示。
右鍵單擊 AccountDataTest.java > Run As > Run …
右鍵單擊 Java Application > New
切換到 Arguments 選項卡並輸入密碼作為 Program 參數。現在，需要在 “YourPasswordHere” 字段為數據庫輸入您的個人專用密碼。
應用並運行這個配置。ACT 表中的記錄將顯示在 Console 選項卡裡面。
圖 10. 配置
將 Spring 支持添加到 pureQuery 應用程序
pureQuery 和 Spring 集成工具箱簡介
這個集成工具箱已經通過 Key MOD-415 提交到 Spring Module with Key MOD-415。就像工具箱本身所描述的一樣：“這個特性需求的目標是能夠將 pureQuery 和 Spring 結合使用，從而獲得 Spring 的 Data 訪問特性的優勢，比如 Spring 事務管理、資源管理（連接）以及 Data Access Exception 層次結構”。
它包含 3 個文件：
pureQuerySpring-samples.zip：帶有文檔的示例文件。
pureQuerySpring_src.zip：源代碼文件。
spring-pdq.jar：運行時文件。
將 Spring 支持添加到項目
根據“構建並運行應用程序”小節中的步驟，將 Spring 庫添加到 PQSpring 項目。
右鍵單擊 PQSpring 項目並選擇 Build Path>Configure Build Path . . .
單擊 Libraries tab 並選擇 Add External Jars，添加下面的 Spring 庫。
%Spring install%/dist/spring.jar
%Spring install%/lib/jakarta-commons/commons-logging.jar
%Spring install%/lib/jakarta-commons/commons-dbcp.jar
%Spring install%/lib/jakarta-commons/commons-pool.jar
來自 pureQuery 和 Spring 集成工具箱的一個額外的庫“spring-pdq.jar”也需要添加到構建路徑。最後的項目應該類似於圖 11。
圖 11. 項目 PQSpring
Spring 配置文件
如 前面小節 所述，spring 配置文件 applicationContext.xml 和 jdbc.properties 需要添加到這個項目。在這種情況下，如果您使用相同的連接信息，則 jdbc.properties 就保持不變。需要更改 applicationContext.xml 中的 DAO 定義，表明這是新的 DAO 實現。同樣，用一個 propertyConfigurer bean 來表明屬性文件的位置。這樣做的好處是 DBA 只需要更改屬性文件以連接到其他數據源，而不需要更改應用程序本身。
清單 10 是 Spring 配置文件的一個示例，它使用了來自 pureQuery 和 Spring 集成工具箱的類。
清單 10. applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<!-- replaces ${...} placeholders with values from properties files -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>jdbc.properties</value>
</list>
</property>
</bean>
<!-- Define datasource -->
<bean id="DB2DataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- Configure DAO -->
<bean id="ACT_DATA" class="java.lang.Class"
factory-method="forName">
<constructor-arg value="com.test.AccountData" />
</bean>
<bean id="ACT_DAO"
class="org.springmodules.purequery.PdqAnnotatedMethodFactory"
factory-method="getData">
<constructor-arg ref="ACT_DATA" />
<constructor-arg ref="DB2DataSource" />
</bean>
</beans>
應用程序
接下來將創建一個新的應用程序 SpringTest.java，並通過它加載 Spring 配置文件和調用 DAO 方法。將清單 11 中的代碼添加到 com.test 包下的項目。
清單 11：SpringTest.java
package com.test;
import java.util.Iterator;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
public static void main(String[] args) {
//Load the configuratioin file
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(
new String[] {"applicationContext.xml"});
//Get the DAO object
AccountData accountData = (AccountData)ac.getBean("ACT_DAO");
//Call the getAccounts() method
Iterator<Account> Acts = accountData.getAccounts();
//Print out the results
while (Acts.hasNext ()) {
Account o = Acts.next();
System.out.println("Act No=" + o.getActno() + " key="+o.getActkwd() + " desc="+
o.getActdesc() );
}
}
}
運行應用程序
右鍵單擊 SpringTest > Run As > Java Application。輸出結果顯示在控制台窗口內，類似於圖 12。
現在，已經將 Sring 支持添加到一個現有的 pureQuery 應用程序，但不需要更改任何 pureQuery 代碼。您也可以根據“將事務管理添加到應用程序”小節 的步驟，為這個項目添加事務控制。
圖 12. 來自 PQSpring 的輸出
結合使用靜態 SQL 和 Spring
pureQuery 靜態綁定特性使您能夠將動態的 SQL 替換為靜態的 SQL，從而通過一個基於包的授權機制改善運行時性能並實現更高的安全性。通過 pureQuery，使用靜態或動態的 SQL 已經變成一個運行時決策，而不是設計時決策。按照下面的步驟靜態運行應用程序。
右鍵單擊 PQSpring 項目並選擇 Bind pureQuery Application。輸出控制台會顯示：
Bind pureQuery Application invoked for project PQSpring.
pureQuery Bind completed successfully for com.test.AccountData.
為 SpringTest.java 創建一個運行時配置。將下面的信息添加到 VM 參數：
-Dpdq.executionMode=STATIC
現在的配置應該類似於圖 13。應用並運行這個配置。目前的配置使用的是靜態 SQL。
圖 13. PQSpring 運行配置
結束語
IBM Data Studio 的 pureQuery 特性大大地提高了數據庫編程生產力，同時也改善了運行時性能。通過使用 pureQuery 和 Spring 集成工具箱，可以將 Spring Framework 的特性添加到 pureQuery 應用程序，比如，聲明性事務管理、錯誤處理以及資源管理。
本文配套源碼
