当前页面位置: » 丰搜网 » 文档中心 » 详细内容
学习jakarta struts(三)
本文是三篇学习struts框架系列文章的最后一篇（原文请见http://www.onjava.com/pub/a/onjava/2001/11/14/jsp_servlets.html）。
在第一篇文章《jakarta struts简介》中，我大致分析了struts框架，讨论了它所能完成的功能，还浏览了组成struts的各个组成部分。在第二篇文章《学习jakarta struts》中，我开始详细描述如何利用struts来构建一个简单应用的过程步骤。而本篇文章将会向大家演示如何将applicationresource文件中的文本信息，通过struts标签在jsp页面中显示出来。
action类是连接struts架构和应用中业务逻辑代码的桥梁。所以你应该尽可能让action类小巧简单，因为真实应用中的逻辑处理应该是由单独分离出来的逻辑层来完成的。如果你正在从事n层应用的开发，你当然希望层与层之间的接口越简单越好。而事实上，action类中的主要方法"perform()"（1.1中为execute()）却有点暗示应该在本方法中做点什么的意思。我们知道，每个action类都需要从 org.apache.struts.action.action 继承而来。在小型应用中，我们的action类很可能就只要继承org.apache.struts.action.action就足够了；而在某些特定的复杂应用中，我就从我们所实现的action类中总结出来了一些通用特性。因此，在我看来，构造一个基类将这些通用特性的代码实现出来，让应用中所用到的所有action类不直接继承org.apache.struts.action.action，而继承这个完成了一些通用特性的基类以实现代码重用，是一个相当不错的设计。我在strutssample中就应用了这种方法，构造了这样的一个基类，该基类的方法在完成复杂逻辑的和简单转发请求的action类中都可以使用。
package com.oreilly.actions;
import java.io.ioexception;
import java.util.properties;
import java.util.resourcebundle;
import java.util.missingresourceexception;
import java.util.enumeration;
import java.util.properties;
import java.rmi.remoteexception;
import javax.ejb.ejbhome;
import javax.ejb.createexception;
import javax.naming.context;
import javax.naming.initialcontext;
import javax.naming.namingexception;
import javax.servlet.servletexception;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import org.apache.struts.action.action;
import org.apache.struts.action.actionservlet;
import org.apache.struts.action.actionform;
import org.apache.struts.action.actionforward;
import org.apache.struts.action.actionmapping;
这个类就是使用struts开发时，所有action类都要继承的基类。它把一些通常在实际应用中最有可能被用到的东西都考虑进来了。就这篇文章而言， 类中一些与struts并不是太紧密相关的方法将只做注释而不会完整的实现，而从事开发工作的你，有兴趣的话，请完成这些方法并应用这个类，将为你在实际项目中的开发快马加鞭。注意，因为所有的action类都要从org.apache.struts.action.action 继承而来，所以我们的这个类同样。
public abstract class abststrutsactionbase extends action {
/ * 定义一些在struts-config.xml中记录在案的
* 全局应用中皆可可通用的forward标识*/
protected static final string success = "success";
protected static final string failure = "failure";
protected static final string error = "error";
protected static final string login = "login";
protected static final string confirm = "confirm";
protected context jndicontext = null;
/**
* 默认构造方法
*/
public abststrutsactionbase() {
}
/**
下面这个查找ejb实例的方法将不会完整实现。
一般来说，action类应该调用实现了应用的商务逻辑的ejb会话bean（或仅仅普通javabean）。在大型项目中，开发人员必须划清层与层之间的界限。在action类中，我们应该拿到获取含有jndi信息的环境的实例，然后通过ejb的jndi名字去查询获取它的home接口。过程并不简单，所以下面这个代码片断只是个给出了必要实现的小例子。
 参数类型string，传入的要查询jndi的名字
 返回类型object，即查找到的home接口
 如果查找失败，抛出namingexception异常
 如果获取资源信息失败，抛出missingresourceexception异常
*/
public object lookup(string jndiname)
throws namingexception, missingresourceexception {
// 为调用ejb对象，通过构建记录jndi信息的properties对象
// 来获得初始环境信息
if (jndicontext == null) {
resourcebundle resource =
resourcebundle.getbundle("strutssample.properties");
properties properties = new properties();
properties.setproperty(
context.initial_context_factory,
resource.getstring(context.initial_context_factory));
properties.setproperty(
context.provider_url,
resource.getstring(context.provider_url));
properties.setproperty(
context.security_principal,
resource.getstring(context.security_principal));
properties.setproperty(
context.security_credentials,
resource.getstring(context.security_credentials));
jndicontext = new initialcontext(properties);
}
注意：在真正的产品中，我们应该在此处考虑代码的健壮性，将代码加入到try/catch块内，并记录所有错误或重要信息到系统log中。而本例中，我们仅仅把异常往外抛，并假定一定会找到ejb对象的home接口并返回。
return (jndicontext.lookup(jndiname));
}
由于action类将是由struts来调用的。所以它的主要方法应该是一个抽象方法，而由每个继承的子类来具体实现，或者在其中做一些所有action都会做的通用机制，例如记录log信息。在本例中，我们一切从简，将其抽象之。
 参数mapping：其类型为actionmapping，将在本action做跳转选择用
 参数actionform：由struts根据本次http请求数据填充完成的actionform对象（可选，如果存在请求数据的话）
 参数request：此action所有处理的本次http请求（对象）
 参数response：此action输出数据所要用到的http响应（对象）
 如果有i/o错误出现，则本方法抛出ioexception异常
 如果处理时发生servlet异常，则本方法抛出servletexception异常
 本方法处理完请求后按照处理逻辑返回相应的页面导向（对象）
public abstract actionforward perform(
actionmapping mapping,
actionform form,
httpservletrequest request,
httpservletresponse response)
throws ioexception, servletexception;
}
或者让这个抽象方法更有用一点，那就在里面干点什么吧，比如像下面这样在其中记录log。
{
actionforward forward = null;
// 只是简单的记录一些提示信息到servlet log
getservlet().log(
"abststrutsactionbase.perform() [action class: "
+ this.getclass().getname()
+ " ]");
getservlet().log(
"abststrutsactionbase.perform() [form class : "
+ (form == null ? "null" : form.getclass().getname())
+ " ]");
}
然后，我们再编写的每个action类都应该从abststrutsactionbase继承，并依照处理逻辑编写各自的perform方法。让我们用loginaction为例，看看具体应该怎么应用吧。
package com.oreilly.actions;
import java.io.ioexception;
import java.rmi.remoteexception;
import javax.ejb.createexception;
import javax.servlet.servletexception;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import org.apache.struts.action.actionerror;
import org.apache.struts.action.actionerrors;
import org.apache.struts.action.actionform;
import org.apache.struts.action.actionmapping;
import org.apache.struts.action.actionforward;
import com.oreilly.forms.loginform;
/*
loginaction 将演示一个action将如何被struts架构所调用
在这个例子中，我们只是简单的演示perform方法是如何调用、执行并返回的
*/
public class loginaction extends abststrutsactionbase {
接下来这个是验证用户的方法，本例中没有具体实现。但一个典型的应用方案是调用javabean或者ejb来完成。用来查找ejb的lookup方法（在基类中完成的）应该在本方法中被调用，其返回一个依据后台数据库验证用户的接口。
 参数类型string，要验证的用户名
 参数类型string，密码
 返回类型boolean，如果验证通过为true，否则为false
public boolean authenticate(string username, string password) {
/* 本方法将先做一个查找动作，获得验证用户的ejb对象的接口并调用
* 由于本例只演示action与商务逻辑层是如何交互的
* 所以具体实现代码本例中就不提供了:)
*/
return (true);
}
接下来我们在loginaction中重载基类的perform方法。
 参数mapping：其类型为actionmapping，将在本action做跳转选择用
 参数actionform：由struts根据本次http请求数据填充完成的actionform对象（可选，如果存在请求数据的话）
 参数request：此action所有处理的本次http请求（对象）
 参数response：此action输出数据所要用到的http响应（对象）
 如果有i/o错误出现，则本方法抛出ioexception异常
 如果处理时发生servlet异常，则本方法抛出servletexception异常
 本方法处理完请求后按照处理逻辑返回相应的页面导向（对象）
public actionforward perform(
actionmapping mapping,
actionform form,
httpservletrequest request,
httpservletresponse response)
throws ioexception, servletexception {
// 先假定验证失败，那么要导向的forward当然是login了（见基类定义的全局变量）
boolean validlogin = false;
actionforward actionforward = mapping.findforward(login);
// 构造出承载actionerror对象的容器——errors，以备错误出现时可用
actionerrors errors = new actionerrors();
// 从由本次请求构造的actionform中提取出所需要的数据
loginform loginform = (loginform)form;
string username = null;
string password = null;
if (loginform != null) {
username = loginform.getusername();
password = loginform.getpassword();
validlogin = authenticate(username, password);
}
if (validlogin) {
// 验证成功了，导向到struts-config.xml中定义的success
actionforward = mapping.findforward(success);
// 存点必要的东东到session，以备后用
request.getsession(true).setattribute("username", username);
} else {
errors.add("login", new actionerror("error.login.authenticate"));
}
// 系统如果用户界面友好一点，我们就应该将错误信息存入request对象中
// 然后到页面，通过在struts的标签显示出来
if (!errors.empty()) {
saveerrors(request, errors);
}
// 本action处理完成，导向到合适的forward
return (actionforward);
}
}
注意，这个loginaction类就是在struts-config.xml中定义的用来处理登录事务的一个具体实现。当这个类被载入并有一个对象实例化后，struts架构就会调用它的perform方法。这个方法是这样声明的：
public actionforward perform(
actionmapping mapping,
actionform form,
httpservletrequest request,
httpservletresponse response)
throws ioexception, servletexception
其中，mapping是一个记录与此action对应的forward导向的对象，form对象封装由客户端提交的此action要处理的数据，还有标准的httpservletrequest对象和httpservletresponse对象。
有了这些对象的辅助，此action就可以拿到需要的东东顺利开工了。我们的例子中，要处理的数据主要是用户名和密码，这些都由form对象提供。实现验证功能是本应用的主要业务逻辑，在方法中的具体实现应该是去取ejb的相应接口来操作或者直接去拿数据库数据来验证。前面那个abststrutsactionbase类中已经实现了一个简单的ejb接口查找动作，所以如果我们是在开发一个基于ejb实现的系统，它的可重用性就非常强了。
由验证方法（authenticate()）的返回值，action要接着做出合理的动作。如果验证通过，就要让用户进入正确的页面，那么我们就将一些后面可能会用到的信息存入request对象（译注：准确的讲，代码中是存到了session对象里，当然session对象是和当前request相关的），并向struts返回success这个forward。这个forward是在struts-config.xml中定义的，然后由actionmapping封装起来，在action处理中可以从中拿出合适的forward做为返回值。如果回头去看看struts-config.xml中的定义，就会知道success这个forward会将用户导向至welcome.jsp这个页面的。如果验证失败，则将一个错误信息存起来，然后导向到一个错误提示页面显示出来。
开发应用的业务逻辑
在一个真实的应用系统中，我们应该将业务逻辑层整合进来了。在我们这个例子里，我们就应该去开发loginaction中的authenticae方法所调用到的ejb了。但是正如你所见的，我们完全可以把这一层暂时屏蔽掉，而利用struts把前端部分构建并能够让它跑起来的。我其实相当推崇的是方法是先将应用框架搭建并运行起来，然后在开发后台实际的业务逻辑层。在应用框架完全恰当的构建起来的时候，后台的开发工作所有做的debug工作也少的多了。而且，业务逻辑的开发也不是本文所要函概的范围，所以此处我们略过，不过我相信你现在一定对应用的全局有了总体的把握了吧！
开发由actionmapping定义的系统工作流程，完成对应的jsp页面
终于可以将所有这些东东整合在一起了。在struts-config.xml配置文件中定义的那些actionmapping，我们要完成这些actionmapping定义用到的jsp页面。本例中，包括login.jsp、welcome.jsp和errorpage.jsp。还有，尽管我们在本例中都是将action处理完成forward到jsp页面，这在这个简单的例子中是再恰当不过的逻辑流程了，而在实际利用struts开发应用中呢，当然可以从action forward到其他的action。我们这个简单的login.jsp页面内容是这样的：
<%@ page language="java" %>
<%@ taglib uri="/web-inf/struts-html.tld" prefix="html" %>
<%@ taglib uri="/web-inf/struts-form.tld" prefix="form" %>
<%@ taglib uri="/web-inf/struts-bean.tld" prefix="bean" %>
<html>
<head>
<title><bean:message key="login.title"/></title>
</head>
<body>
<html:errors/>
<h3>enter your username and password to login:</h3>
<html:form action="login.action" focus="username" >
<html:text property="username" size="30" maxlength="30"/>
<html:password property="password" size="16" maxlength="16" redisplay="false"/>
<html:submit property="submit" value="submit"/>
<html:reset/>
</html:form>
</body>
</html>
struts在
jsp自定义标签库的基础上提供了一套综合各种功能的标签库。利用这些标签库很容易的构建用户界面了。使用这些标签库的好处之一就是可以利用其提供的很多附加功能。比如在一般的
jsp页面的表单里我们可以看到这样常见的
html片断：
<input type="text" name="username" value="">
如果我们使用
struts的标签库的话，就可以改成这样子：
<
html:text property ="username">
不过我们得现在页面中先声明
struts标签库的定义。
<%@ taglib uri="/
web-inf/
struts-
html.tld" prefix="
html" %>
在这个例子中，我们会用到一些
struts标签，但我不准备在此详细讲解
struts各种标签库的用法。相信在你不断使用
struts搭建功能复杂的
jsp页面的过程中，你将会对所使用过的标签越来越熟悉的。到那时，你也将更能体会到
struts标签的益处，利用它们大大的缩短你的开发时间。目前，你可以从
struts developers
guides了解到更多的细节。
在我们这个简单例子中，有两个重点。其一：
<title><bean:message key="login.title"/></title>
这就是在利用我们前面提到的资源文件applicationresource来在页面显示信息，而不是将信息文本硬编码到我们的应用中。
其二：
<
html:errors/>
这就是在页面中显示出actionerrors的信息，也就是我们在loginform的验证方法和loginaction中产生的报错信息的集合对象。
页面中的表单，利用
struts，我们将用如下的标签来定义：
<
html:form action="login.action" focus="username">
这里的login.action，是和
struts-config.
xml中定义actionmapping相匹配的。在页面标签中这样的定义，就将相关的action、actionform和actionforward完整的串了起来。当这个用标签定义的表单提交的时候，
struts中的action
servlet就会将其交由login.action来处理。具体的过程我们下面慢慢深入。
在welcome.
jsp中，我们只演示如何将action中的信息传递到页面加以利用的一般机制：
<html>
<title>welcome to struts</title>
<body>
<p>welcome <%= (string)request.getsession().getattribute("username") %></p>
</p>you have logged in successfully!</p>
</body>
</html>
还记得吗？我们在loginaction中的perform()方法中将username放到了session中哦。
完成系统配置文件
我们已经就
struts-config.
xml谈了好多了。通常，这个文件中的信息会在开发过程中逐渐完善。但是到了开发过程的最后一部，我们更应该回头去检查这个至关重要的配置文件，以保证万无一失：action、
jsp页面还有actionform都应该在文件中正确的定义。此外，我们还不得不说到
web.
xml。这个文件是
jsp容器（例如
tomcat）获取应用相关配置的重要文件。我们这个
strutssample例子所用到的
web.
xml大致是这样的：
<?xml version="1.0" encoding="iso-8859-1"?>
<!--
this is the web-app configuration that allow the strutssample to work under
apache tomcat.
-->
<!doctype web-app
public "-//sun microsystems, inc.//dtd web application 2.2//en"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd";>
<web-app>
<servlet>
<servlet-name>oreilly</servlet-name>
<servlet-class>org.apache.struts.action.actionservlet</servlet-class>
<init-param>
<param-name>application</param-name>
<param-value>com.oreilly.applicationresources</param-value>
</init-param>
<init-param>
<param-name>config</param-name>
<param-value>/web-inf/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>validate</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>oreilly</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
<!-- struts tag library descriptors -->
<taglib>
<taglib-uri>/web-inf/struts.tld</taglib-uri>
<taglib-location>/web-inf/struts.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/web-inf/struts-bean.tld</taglib-uri>
<taglib-location>/web-inf/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/web-inf/struts-html.tld</taglib-uri>
<taglib-location>/web-inf/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/web-inf/struts-logic.tld</taglib-uri>
<taglib-location>/web-inf/struts-logic.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/web-inf/struts-form.tld</taglib-uri>
<taglib-location>/web-inf/struts-form.tld</taglib-location>
</taglib>
</web-app>
这里的<
servlet>标签定义了org.apache.
struts.action.action
servlet，而且在本例中，我们把这个定义的
servlet叫作“oreilly”，并传了两个初始化参数给它：其一是我们为这个应用所需的显示字符串定义的资源文件，其二是指明
struts-config.
xml文件的位置。相信你也注意到了，在<
servlet-mapping>中为这个
servlet指明的相应请求处理串是*.action，这是和我们在页面中的表单定义的提交的url是吻合的。也就是说，我们通过<
servlet-mapping>标签告诉
tomcat，所有后缀为.action的请求都交给“oreilly”这个
servlet来处理。你当然可以指定你喜欢的后缀。在
struts附带的例子中，你可能会看到通常以.do做为后缀，不过我认为.action更明确一些。<welcome-file-list>标签中定义了本应用初始显示页面。最后呢，我们还要把会用到的
struts标签库列在后面。
编译/
测试/发布
到此为止，编译/
测试/发布应用之前的所有工作都完成了。用
ant来编译整个应用是相当容易的。如果你以前没有接触过
ant，那最好把这个研究一下。其实学习和应用
ant来管理一个应用编译环境并不难。我把这个编译应用所要用到的build.
xml和例子放到了一起，这篇文章所要用到的所有东东，你都可以点此下载，到时候你到build.
xml所在目录简单执行
ant命令就可以完成编译，并打包成
strutssample.war包。当然要执行
ant，你得先去下载
ant。将
ant下载回来并搭建好环境可能得花十几分钟的时间哦。
本应用的目录结构如下：
strutssample根目录
*.
jsp web-inf目录
struts配置文件（
struts-config.
xml,
web.
xml）
classes目录（还是以
java程序文件包结构为路径）
lib目录（
struts.jar）
拿到了应用的war包，我们就将它放到
tomcat的
webapps路径下，然后启动
tomcat。war包会被自动展开，此应用的上下文环境也会由
tomcat自动建立起来。我们通过
web.
xml告知
tomcat这个应用所需的其他资源在哪里。现在，我们可以通过http://localhost:8080/
strutssample来访问我们的应用了。如果没有特别指定的话，
tomcat默认的端口是8080，我们定义的默认初始页面login.
jsp也将显示出来，现在我们来试试吧。
结论
通过本系列的文章，我们利用
struts从应用需求开始，一步步将整个应用搭建起来。和普通的
jsp技术相比，通过
struts开发的应用涉及到更多的与之相关的各类文件，也正是依靠各类文件，我们才可能构建一个适合开发复杂应用的mvc架构。我们的第一个
struts应用花了如此多的时间，是为了要弄清楚
struts的各个部分到底是如何工作的。
希望本系列
struts文章，能够帮助你了解
struts是由哪些部分构成的，它们能够完成什么，也希望介绍一个比较好的开发流程可供你参考。
struts才诞生不久，我有信心它将成为我们构建
j2ee应用的优秀工具。
sue spielman是on
java.com的副编辑，主要擅长于
jsp和
servlet技术，她还是switchback software llc公司的总裁和高级技术咨询专家。
