?<generator class="increment" /
>
</id>
<property name="firstName" column="first_name" not-null="true"/
>
<property name="lastName" column="last_name" not-null="true"/
>
</class>
</hibernate-mapping>

2.在web/WEB-INF/ 下的applictionContext.xml 中添加映像。打開文件，找到<property
name= mappingResources >，改成如下：
<property name="mappingResources">
<list>
<value>org/appfuse/model/User.hbm.xml</value>
</list>
</property>

在applictionContext.xml 中，你可以看到數據庫是怎幺工作的，Hibernate 和Spring 是如
何協作的。Eqinox 會使用名為db/appfuse 的HSQL 數據庫。它將在你的ant “db” 目錄下創建，
詳細配置在“How Spring Is Configured in Equinox ” 一節中描述。

3.運行ant deploy reload(Tomcat 正在運行)，在Tomcat 控制臺的日志中可以看到，數據
表正在創建。
INFO - SchemaExport.execute(98) | Running hbm2ddl schema export

INFO - SchemaExport.execute(117) | exporting generated schema to database

INFO - ConnectionProviderFactory.newConnectionProvider(53) | Initializing connection

provider: org.springframework.orm.hibernate.LocalDataSourceConnectionProvider
INFO - DriverManagerDataSource.getConnectionFromDriverManager(140) | Creating new

JDBC connection to [jdbc:hsqldb:db/appfuse]
INFO - SchemaExport.execute(160) | schema export complete
Tip: 如果你想看到更多或更少的日志，修改web/WEB-INF/ classes/log4j.xml 的設置。

4.為了驗證數據庫已經建好，運行 ant browser 啟動hsql console 。你會看到如的HSQL
Database Manager 。
Equinox 中spring 是怎幺配置的

使用Spring 配置任何基于j2ee 的web 程序都很簡單。至少，你簡單的添加Spring 的
ContextLoaderListener 到你的web.xml 中。
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

這是一個ServletContextListener ，它會在啟動web 應用進行初始化。默認情況下，它會

查找web/WEB-INF/applictionContext.xml 文件，你可以指定名為contextConfigLocation 的
<context-param> 元素來進行修改，例如：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/sampleContext.xml</param-value>

</context-param>

<param-value> 元素可以是以空格或是逗號隔開的一系列路徑。在 Equnox 中，Spring
的配置使用了這個Listener 和默認的 contextConfigLocation 。
那幺，Spring 怎幺知道Hibernate 的存在？這就Spring 的魅力所在，它讓依賴性的綁定
變得非常簡單。請參閱applicationContext.xml 的全部內容：

<value>org.hsqldb.jdbcDriver</value>
</property>
<property name="url"
>

<value>jdbc:hsqldb:db/appfuse</value>
</property>
<property name="username"
>

<value>sa</value>
</property>
<property name="password"
>

<value></value>
</property> </bean>
<!-- Hibernate SessionFactory --
>
<bean id="sessionFactory"

class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource"/>

</property>
<property name="mappingResources"
>
<list>

<value>org/appfuse/model/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties"
>
<props>

<prop key="hibernate.dialect"> net.sf.hibernate.dialect.HSQLDialect </prop>

<prop key="hibernate.hbm2ddl.auto">create</prop>
</props>
</property>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->

<bean id="transactionManager"
class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>

</property>
</bean>
</beans>

第一bean 代表HSQL 數據庫，Spring 僅僅是調用LocalSessionFactoryBeanr 的
setDataSource(DataSource) 使之工作。如果你想用JNDI DataSource 替換，可以bean 的定義改
成類似下面的幾行：

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:comp/env/jdbc/appfuse</value>
</property>
</bean>

hibernate.hbm2ddl.auto 屬性在sessionFactory 定義中，這個屬性是為了在應用啟動時自
動創建表，也可能是update 或create-drop 。
最后一個bean 是transactionManager( 你也可以使用JTA transaction) ，在處理跨越兩個

數據庫的分布式的事務處理中尤其重要。如果你想使用jta transaction manager ，將此bean 的
class 屬性改成

org.springframework.transaction.jta.JtaTransactionManager

下面實現UserDAO 類。

用hibernate 實現UserDAO

為了實現Hibernate UserDAO ，需要完成以下幾步：

1.在src/org/appfuse/dao/hibernate( 你要新建這個目錄/包) 新建一個文件
UserDAOHibernate.ava 。這個類繼承了HibernatDaoSupport 類，并實現了UserDAO 接口。
package org.appfuse.dao.hibernate;
// use your IDE to handle imports
public class UserDAOHibernate extends HibernateDaoSupport implements UserDAO
{
private Log log = LogFactory.getLog(UserDAOHibernate.class)
;

public List getUsers()
{
return getHibernateTemplate().find("from User")
;
}

public User getUser(Long id)
{
return (User) getHibernateTemplate().get(User.class, id)
;
}

public void saveUser(User user)
{
getHibernateTemplate().saveOrUpdate(user)
;
if (log.isDebugEnabled())
{

log.debug( userId set to: + user.getID())
;
}
}

public void removeUser(Long id)
{
Object user = getHibernateTemplate().load(User.class, id)
;
getHibernateTemplate().delete(user)
;
}

}

Spring 的HibernateDaoSupport 類是一個方便實現Hibernate DAO 的超類，你可以它的

一些有用的方法，來獲得Hibernate DAO 或是SessionFactory 。最方便的方法是
getHibernateTemplate() ，它返回一個HibernateTempalte 對象。這個模板把檢測式異常
(checked exception) 包裝成實時式異常(runtime exception) ，這使得你的DAO 接口無需拋出
Hibernate 異常。

程序還沒有把UserDAO 綁定到 UserDAOHibernate 上，必須創建它們之間的關聯。

2.在Spring 配置文件(web/WEB-INF/applictionContext.xml) 中添加以下內容：
<bean id="userDAO" class="org.appfuse.dao.hibernate.UserDAOHibernate"
>
<property name="sessionFactory"
>
<ref local="sessionFactory"/
>
</property>
</bean>

這樣就在你的UserDAOHibernate( 從HibernateDaoSupport 的setSessionFactory 繼承)中建
了一個Hibernate Session Factory 。Spring 會檢測一個Session( 也就是，它在web 層是開放的)
是否已經存在，并且直接使用它，而不是新建一個。這樣你可以使用Spring 流行的
“
Open Session in View ” 模式來載入collections 。

進行單元測試，來驗證DAO 的CRUD 操作

在進行第一個測試之前，把你的日志級別從“INFO” 調到“WARN” 。

1.把log4j.xml( 在web/WEB-INF/classes 目錄下)中<level value="INFO"/> 改為<level
value="WARN"/> 。
2.鍵入ant test 來運行UserDAOTest 。如果你有多個測試，你必須用ant test
-Dtestcase=UserDAOTest 來指定要運行的測試。運行之后，你會如下類似的一些日志信息。

創建Manager ，聲明事務處理(create manager and declare
transactions)

J2EE開發中建議將各層進行分離。換言之，不要把數據層(DAOs)和web層(servlets)
混在一起。使用Spring,很容易做到這一點，但使用“業務代理”(business delegate)模
式, 可以對這些層進一步分離。

使用業務代理模式的主要原因是：

●
大多數持久層組件執行一個業務邏輯單元，把邏輯放在一非web類中的最大好處是，
web service或是豐富平臺客戶端(rich platform client)可以像使用servlet一樣
來用同一API。
●
大多數業務邏輯都在同一方法中完成，當然可能多個DAO。使用業務代理，使得你
可以高級業務代理層(level)使用Spring的聲明式業務代理特性。
MyUsers應用中UserManager和UserDAO擁有相同的一個方法。主要不同的是Manager
對于web更為友好(web-friendly)，它可以接受Strings,而UserDAO只能接受Longs, 并且
它可以在saveUser方法中返回一個User對象。這在插入一個新用戶比如，要獲得主鍵，是
非常方便的。Manager(或稱為業務代理)中也可以添加一些應用中所需要的其它業務邏輯。

1.啟動“service”層，在test/org/appfuse/service(你必須先建好這個目錄)中新建
一個UserManagerTest類，這個類繼承了JUnit 的 TestCase類，代碼如下：
package org.appfuse.service;
// use your IDE to handle imports
public class UserManagerTest extends TestCase
{
private static Log log = LogFactory.getLog(UserManagerTest.class)
;
private ApplicationContext ctx;
private User user;
private UserManager mgr;

protected void setUp() throws Exception
{

String[] paths
=
{"/WEB-INF/applicationContext.xml"}
;

ctx = new ClassPathXmlApplicationContext(paths)
;

mgr = (UserManager) ctx.getBean("userManager")
;

}

protected void tearDown() throws Exception
{
user = null;
mgr = null;

}

// add testXXX methods here
public static void main(String[] args)
{
junit.textui.TestRunner.run(UserDAOTest.class)
;
}

在setup方法中，使用ClassPathXmlApplicationContext把applicationContext.xml
載入變量ApplicationContext中。載入ApplictionContext有幾種途徑，從classpath中，
文件系統，或web 應用內。這些方法將在第三章( The BeanFactory and How It Works.)
中描述。

2.輸入第一個測試方法的代碼，來驗證Manager成功完成添加或是刪除User對象
。
public void testAddAndRemoveUser() throws Exception
{
user = new User()
;
user.setFirstName("Easter")
;
user.setLastName("Bunny")
;
user = mgr.saveUser(user)
;
assertTrue(user.getId() != null)
;
if (log.isDebugEnabled())
{
log.debug("removing user...")
;
}

String userId = user.getId().toString()
;
mgr.removeUser(userId)
;
user = mgr.getUser(userId)
;
if (user != null)
{

fail("User object found in database!")
;
}
}

這個測試實際上是一個集成測試(integration test)，而不是單元測試(unit test)。

為了更接近單元測試，可以使用EasyMock或是類似工具來“偽裝”(fake) DAO。這樣，就
不必關心ApplictionContext和任何依賴Spring API 的東西。建議在測試項目依賴
(Hibernate,Spring,自己的類)的內部構件，包括數據庫。第9章，討論重構
UserManagerTest,使用mock解決DAO的依賴性。

3.為了編譯UserManagerTest，在src/org/appfuse/service中新建一個接口─
─UserManager。在org.appfuse.service包中創建這個類，代碼如下：
package org.appfuse.service;
// use your IDE to handle imports
public interface UserManager
{
public List getUsers()
;

public User getUser(String userId)
;
public User saveUser(User user)
;
public void removeUser(String userId)
;
}

4.建一個名為org.appfuse.service.impl的子包，新建一個類實現UserManager 接口
的。
package org.appfuse.service.impl;
// use your IDE to handle imports

public class UserManagerImpl implements UserManager
{
private static Log log = LogFactory.getLog(UserManagerImpl.class)
;
private UserDAO dao;

public void setUserDAO(UserDAO dao)
{
this.dao = dao;
}

public List getUsers()
{
return dao.getUsers()
;
}

public User getUser(String userId)
{
User user = dao.getUser(Long.valueOf(userId))
;
if (user == null)
{

log.warn("UserId '" + userId + "' not found in database.")
;

}
return user;
}

public User saveUser(User user)
{
dao.saveUser(user)
;
return user;
}

public void removeUser(String userId)
{
dao.removeUser(Long.valueOf(userId))
;
}

}
這個類看不出你在使用Hibernate。當你打算把持久層轉向一種不同的技術時，這樣做
很重要。

這個類提供一個私有dao成員變量，和setUserDAO方法一樣。這樣能夠讓Spring能夠
表演“依賴性綁定”魔術(perform “dependency binding” magic)，把這些對象扎在一起。
在使用mock重構這個類時，你必須在UserManager接口中添加serUserDAO 方法。

5.在進行測試之前，配置Spring,讓getBeans返回一個UserManagerImpl類。在
web/WEB-INF/applicationContext.xml文件中，添加以下幾行：
<bean id="userManager" class="org.appfuse.service.UserManagerImpl">
<property name="userDAO">
<ref local="userDAO"/
>
</property>
</bean>
唯一的問題，你還沒有使Spring的AOP,特別是聲明式的事務處理發揮作用
。

6.為了達到目的，使用ProxyFactoryBean代替userManager。ProxyFactoryBean是一
個類的不同的實現，這樣AOP 能夠解釋和覆蓋調用的方法。在事務處理中，使用
TransactionProxyFactoryBean代替UserManagerImpl 類。在context文件中添加下面bean
的定義：
<bean id="userManager"
class="org.springframework.transaction.interceptor.TransactionProxy
FactoryBean">

<property name="transactionManager">

<ref local="transactionManager"/
>
</property>
<property name="target"
>

<ref local="userManagerTarget"/
>
</property>
<property name="transactionAttributes"
>
<props>

<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>

</props>
</property>
</bean>
從這個xml代碼片斷中可以看出，TransactionProxyFactoryBean必須有一
個

transactionManager 屬性設置和transactionAttributes 定義。

7.讓事務處理代理服務器(Transaction Proxy)知道你要模仿的對象：
userManagerTarget。作為新bean的一部分，把原來的userManager bean改成擁有一個
userManagerTarget的id屬性。
編輯applictionContext.xml添加 userManager 和 userManagerTarget 的定義后，
運行ant test -Dtestcase=UserManager ,看看終端輸出：

8.如果你想看看事務處理的執行和提交情況，在log4j.xml中添加
:
<logger name="org.springframework.transaction">
<level value="DEBUG"/>

<!-- INFO does nothing --
>
</logger>

重新運行測試，將看到大量日志信息，如它相關的對象，事務的創建和提交等。測試
完畢，最好刪除上面的日志定義(logger)。

祝賀你！你已經實現了一個web應用的Spring/Hibernate后端解決方案。并且你已經
用AOP和聲明式業務處理配置好了業務代理。了不起，自我鼓勵一下！(This is no small
feat; give yourself a pat on the back!)

對象struts Action 進行單元測試

業務代理和DAO都起作用，我們看看MVC框架吸盤(sucker)的上部。停！不止這些
吧，你可以進行C(Controller),不是V(View)。為了管理用戶建一個Struts Action,繼續進
行驅動測試(Test-Driven)開發。

Equinox是為Struts配置的。配置Struts需要在web.xml 中進行一些設置，并在
web/WEB-INF下定義一個struts-config.xml文件。由于Struts開發人員比較多，這里先使
用Struts。第4 章用Spring進行處理。你想跳過這一節，直接學習Spring MVC方法，請
參考第4章：Spring s MVC Framework。

在test/org/appfuse/web目錄下新建一個文件UserActionTest.java，開發你的第一
個Struts Aciton單元測試。文件內容如下：

package org.appfuse.web;

// use your IDE to handle imports

public class UserActionTest extends MockStrutsTestCase
{

public UserActionTest(String testName)
{
super(testName)
;
}

public void testExecute()
{
setRequestPathInfo("/user")
;
addRequestParameter("id", "1")
;
actionPerform()
;
verifyForward("success")
;
verifyNoActionErrors()
;
}
}

為web 層創建Action 和Model(DynaActionForm)

1.在src/org/appfuse/web下新建一個文件UserAction.java。這個擴展了
DispatchAction，你可以花幾分鐘，在這個類中，創建CRUD方法。
package org.appfuse.web;
// use your IDE to handle imports
public class UserAction extends DispatchAction
{
private static Log log = LogFactory.getLog(UserAction.class)
;

public ActionForward execute(ActionMapping mapping,

?ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception{

request.getSession().setAttribute("test", "succeeded!")
;
log.debug("looking up userId:
" + request.getParameter("id"))
;
return mapping.findForward("success")
;
}

}

2.為了配置Struts,使”/user”這個請求路徑代表其它。在web/WEB-INF/strutsconfig.xml中加入一個action-mapping。打開文件加入：
<action path="/user" type="org.appfuse.web.UserAction">
<forward name="success" path="/index.jsp"/
>
</action>

3.執行命令ant test -Dtestcase=UserAction ，你會看到友好的“BUILD
SUCCESSFUL”
信息。
4.在struts-config.xml中添加form-bean定義。對于Struts ActionForm,使用
DynaActionForm,這是一個javabean，可以從XML定義中動態的創建。
<form-bean name="userForm" type="org.apache.struts.action.DynaActionForm">
<form-property name="user" type="org.appfuse.model.User"/>
</form-bean>
這里沒有使用具體的ActionForm,因為只使用一個User 對象的包裝器。理想情況下，

你可以User 對象，但會失去Struts環境下的一些特性：驗證屬性(validateproperties)，checkbox 復位(reset checkboxs)。后面，將演示用Spring怎幺會更加簡單，

它可以讓你在web層使用 User對象。

5.修改action定義,在request中使用這個form。
<action path="/user" type="org.appfuse.web.UserAction" name="userForm"
scope="request">
<forward name="success" path="/index.jsp"/
>
</action>

6.修改UserActionTest，測試不同的 CRU方法
。
public class UserActionTest extends MockStrutsTestCase
{
public UserActionTest(String testName)
{
super(testName)
; }
// Adding a new user is required between tests because HSQL creates
// an in-memory database that goes away during tests.

public void addUser()
{
setRequestPathInfo("/user")
;
addRequestParameter("method", "save")
;
addRequestParameter("user.firstName", "Juergen")
;
addRequestParameter("user.lastName", "Hoeller")
;
actionPerform()
;
verifyForward("list")
;
verifyNoActionErrors()
;
}

public void testAddAndEdit()
{
addUser()
;
// edit newly added user
addRequestParameter("method", "edit")
;
addRequestParameter("id", "1")
;
actionPerform()
;
verifyForward("edit")
;
verifyNoActionErrors()
;
}
public void testAddAndDelete()
{
addUser()
;

// delete new user
setRequestPathInfo("/user")
;
addRequestParameter("method", "delete")
;
addRequestParameter("user.id", "1")
;
actionPerform()
;
verifyForward("list")
;
verifyNoActionErrors()
;
}

public void testList()
{
addUser()
;
setRequestPathInfo("/user")
;
addRequestParameter("method", "list")
;
actionPerform()
;
verifyForward("list")
;
verifyNoActionErrors()
;
List users = (List) getRequest().getAttribute("users")
;
assertNotNull(users)
;
assertTrue(users.size() == 1)
;
}
}

7.修改UserAction，這樣測試程序才能通過，并能處理(客戶端)請求。最簡單的方法
是添加edit,save和delete方法，請確保你事先已經刪除了execute方法。下面是修改過
的UserAction.java文件。
public class UserAction extends DispatchAction
{
private static Log log = LogFactory.getLog(UserAction.class)
;
private UserManager mgr = null;

public void setUserManager(UserManager userManager)
{
this.mgr = userManager;
}

public ActionForward delete(ActionMapping mapping,
ActionForm form,

HttpServletRequest request,
HttpServletResponse response) throws Exception{
if (log.isDebugEnabled())
{
log.debug("entering 'delete' method...")
;

}
mgr.removeUser(request.getParameter("user.id"))
;
ActionMessages messages = new ActionMessages()
;
messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage

("user.deleted"))
;
saveMessages(request, messages)
;
return list(mapping, form, request, response)
; }

public ActionForward edit(ActionMapping mapping,

?ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{

if (log.isDebugEnabled())
{

log.debug("entering 'edit' method...")
;
}
DynaActionForm userForm = (DynaActionForm) form;
String userId = request.getParameter("id")
;
// null userId indicates an add

if (userId != null)
{
User user = mgr.getUser(userId)
;
if (user == null)
{
ActionMessages errors = new ActionMessages()
;
errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage

("user.missing"))
;
saveErrors(request, errors)
;
return mapping.findForward("list")
; }
userForm.set("user", user)
; }

return mapping.findForward("edit")
;
}

public ActionForward list(ActionMapping mapping,

?ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{

if (log.isDebugEnabled())
{

log.debug("entering 'list' method...")
;
}
request.setAttribute("users", mgr.getUsers())
;
return mapping.findForward("list")
;
}

public ActionForward save(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{

if (log.isDebugEnabled())
{
log.debug("entering 'save' method...")
;
}
DynaActionForm userForm = (DynaActionForm) form;
mgr.saveUser((User)userForm.get("user"))
;
ActionMessages messages = new ActionMessages()
;
messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage

("user.saved"))
;
saveMessages(request, messages)
;
return list(mapping, form, request, response)
; } }
接下來，你可以修改這個類的CRUD方法。

8.修改struts-config.xml，使用ContextLoaderPlugin來配置Spring的UserManager
設置。要配置ContextLoaderPlugin,把下面內容添加到你的struts-config.xml中。
<plug-in className= org.springframework.web.struts.ContextLoaderPlugIn >
<set-property property= contextConfigLocation value= /WEB

INF/applicationContext.xml, /WEB-INF/action-servlet.xml />

</plug-in>

默認情況下這個插件會載入action-servlet.xml文件。要讓Test Action 知道你的
Manager，必須配置這個插件，如同載入applicationContext。

9.對每個使用Spring的action,定義一個type=
org.springframework.web.struts.DelegatingActionProxy 的action-mapping,為每個
Spring action 聲明一個配對的Spring bean。這樣修改一下你的action mapping就能使用
這個新類。
10.為DispatchAction修改action mapping。
為了讓DispatchAction運行，在mapping中添加參數parameter=
“method” , 它表
示(在一個URL 或是隱藏字段hidden field)要調用的方法，同時轉向(forwards)edit和
list forwards(參考能進行CRUD操作的UserAction類).

<action path="/user"
type="org.springframework.web.struts.DelegatingActionProxy" name="userForm"
scope="request" parameter="method">

<forward name="list" path="/userList.jsp"/
>
<forward name="edit" path="/userForm.jsp"/
>
</action>

確保web目錄下已經建好userList.jsp和userForm.jsp兩個文件。暫時不必在文件中
寫入內容。

11.作為插件的一部分，配置Spring,將/user bean設置成“UserManager”。在
we/WEB-INF/action-servlet.xml中添加以下定義。
<bean name="/user" class="org.appfuse.web.UserAction" singleton="false">
<property name="userManager">
<ref bean="userManager"/>
</property>
</bean>
定義中，使用singleton=
false 。這樣就為每個請求，新建一個Action，減少線程

安全的Action需求。不管是Manager還是DAO都有成員變量，可能不需要這些屬性(默認
singleton= true )。

12.在message.properties上配置資源綁定。
在userAction類中，在完成一些操作后，會顯示“成功”或是“錯誤”頁面，這些信
息的鍵可以存放在這個應用的ResourceBundle(或messages.properties文件中)。特別是
:

●
user.saved
●
user.missing
●
user.deleted
把這些鍵存入web/WEB-INF/下的messages.properties文件中。例如
：
user.saved=User has been saved successfully.
user.missing=No user found with this id.
user.deleted=User successfully deleted.

這個文件通過struts-config.xml中的<message-resources>元素進行加載
。
<message-resources parameter="messages"/
>
運行 ant test -Dtestcase=UserAction. 輸出結果如下
：

?

填充JSP 文件，這樣可以通過瀏覽器來進行CRUD 操作

1.在你的jsp文件(userFrom.jsp 和userList.jsp)中添加代碼，這樣它們可以表示
actions的結果。如果還事先準備，在web目錄下建一個文件 userList.jsp。添加一些代碼
你就可以看到數據庫中所有的用戶資料。在下面代碼中，第一行包含(include)了一個文件
taglibs.jsp。這個文件包含了應用所有JSP Tag Library的聲明。大部分是StrutsTag,JSTL和SiteMesh(用來美化JSP頁面)。
<%@ include file="/taglibs.jsp"%
>
<title>MyUsers ~ User List</title>
<button onclick="location.href='user.do?method=edit'">Add User</button>

<table class="list"
>
<thead>

<tr>
<th>User Id</th>
<th>First Name</th>
<th>Last Name</th>

</tr>
</thead>
<tbody>
<c:forEach var="user" items="${users}" varStatus="status"
>
<c:choose>
<c:when test="${status.count % 2 == 0}"
>

<tr class="even"
>
</c:when>
<c:otherwise>

<tr class="odd">
</c:otherwise>
</c:choose>
<td><a href="user.do?method=edit&amp;id=${user.id}">${user.id}</a></ td>

<td>${user.firstName}</td>
<td>${user.lastName}</td>
</tr>
</c:forEach>
</tbody>
</table>

你可以有一行“標題頭”(headings)(在<thead>中)。JSTL 的 <c:forEach>進行結果
迭代，顯示所有的用戶。

2.向數據庫添加一些數據，你就會看到一些真實(actual)的用戶(users)。你可以選擇
一種方法，手工添加，使用ant browse,或是在build.xml中添加如下的target：
<target name="populate">

<echo message="Loading sample data..."/>

<sql driver="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:db/appfuse"

userid="sa" password="">
<classpath refid="classpath"/>
INSERT INTO app_user (id, first_name, last_name) values (5, 'Julie',
'Raible')
;
INSERT INTO app_user (id, first_name, last_name) values (6, 'Abbie',
'Raible')
;
</sql>
</target>

警告:為了使內置的HSQLDB正常工作，從能運行ant的目錄下啟動tomcat。在
Unix/Linux鍵入 $CATALINA_HOME/bin/startup.sh ，在win上 %CATALINA_HOME%
\bin\startup.bat 。

通過瀏覽器驗證JSP 的功能