Java Web实践专题——信息显示

关注

最新推荐文章于 2026-08-05 00:49:41 发布 435 阅读 AI 写同款· GEO 优化 ›

经典的显示方法

本章主要介绍如果控制页面的输出，如何控制查询结果的显示，不可否认的是Web应用的是很多功能都要显示数据。

向用户输出的信息包括静态页面和动态页面：静态页面就是我们编写好的html文件，不包含任何的处理代码，我们不管什么时候访问这些页面效果都是一样的，除非把页面替换了；动态页面也就是包含了动态信息的页面，这些页面在不同的运行时刻或者由不同的人访问结果都可能不一样，也就是说它的内容会发生变化。

静态页面主要是由美工来完成的，程序员可以不关心。

动态页面在运行过程中会发生变化，但是如果注意的话，这些变化并不是完全没有规律，例如，在一个学生成绩管理系统中，有一个页面用于显示某个学生的信息，这个页面不同的学生访问的时候，看到的结果不一样，但是不能否认的是，不管哪个学生访问，查看的都还是成绩，不同的是每个学生看到的都是自己的成绩。也就是说，动态页面不是完全动态的，而是由静态的格式和动态的信息组成的。我们所关注的是动态信息的输出。

在Web应用中，动态页面的动态信息主要包括以下几个方面：

Ø 查询的结果

查询的结果可以是单个的信息，例如某个人的信息，记录的个数等，也可以是批量的信息，例如用户列表，图书列表等。基本的信息的输出，我们在第一部分进行介绍，批量信息的输出我们在第三部分进行介绍。

Ø 执行状态信息

为了系统界面友好，通常系统执行的结果都应该对用户进行反馈，例如添加信息是否成功，查询到的信息有多少条等。这些内容在第一部分介绍。

Ø 执行的错误信息

在执行的过程中可能会有一些异常产生，例如当用户注册的时候，输入的信息格式可能不合适，用户ID可能已经存在。应该把这些错误信息告诉用户。这部分内容在第一部分进行介绍。

Ø 根据不同的条件进行不同的显示

系统中不同的用户权限可能不同，所以在访问相同的页面的时候看到的结果也是不同的。有些页面对于登陆用户和非登陆用户来说看到的是不一样的。这部分内容在第二部分进行介绍。

基本信息的输出

假设我们要输出的基本信息包括以下几种类型：

异常信息：通常保存在request对象中，假设名字为myexception，类型为Exception，当然在我们的实际应用中，可以构造自己的异常类型，在使用上没有任何区别。

执行状态信息：通常使用字符串表示执行的状态，然后把字符串保存在request对象中，这里假设我们的状态信息的名字是status，类型是String。

查询的结果（单个的变量）：通常保存在request对象中，假设名字为result，类型为String。

查询的结果（对象）：通常保存在request对象中，假设名字为resultobject，类型为Calendar，在实际的应用中应该是我们自己的类型。

其它的一些变量：例如session中的信息、application中的信息、当前页面的信息、请求信息、请求头信息等。我们通过下面的代码完成以上信息的保存：

String result = "平均成绩为75";

//表示查询的结果

Calendar c = Calendar.getInstance();

//表示查询的对象

String status="操作完成";

//表示查询的结果

Exception myexception= new Exception("异常信息:我们假设的异常!");

//表示异常信息

String sessionInfo = "这是session中的信息！";

//表示session中保存的一般信息

String applicationInfo = "这是application中的信息！";

//表示application中存储的一般信息

String requestInfo = "这是request中的信息！";

//表示request中存储的一般信息

request.setAttribute("result",result);

//把查询结果保存到request中

request.setAttribute("resultojbec",c);

//把查询的对象结果保存在request中

request.setAttribute("status",status);

//把状态信息保存在request对象中

request.setAttribute("myexception",myexception);

//把异常信息保存在request对象中

request.setAttribute("requestinfo",requestInfo);

//request存储一些一般信息

session.setAttribute("sessioninfo",sessionInfo);

//在session中保存一些一般信息

application.setAttribute("applicationinfo",applicationInfo);

//在application中保存一些基本信息

多数情况下我们也是这样处理的，但不一定使用Java脚本存储，可以在Servlet中完成这些工作，或者在Struts应用中的Action中实现。

下面我们分别介绍在3种方式下这些信息如何输出：第一种方式是使用Java脚本进行输出，第二种方式是使用标准标签库进行输出，第三种方式是使用现在比较流行的Struts标签库进行输出。

使用Java脚本输出

使用Java脚本进行输出，主要是通过内部对象out的print进行输出，但是需要使用内部对象request、session、application等的方法获取到相应的信息。除了使用out的println方法之外，可以使用表达式输出，下面的代码演示了两者的用法：

String str = “test”;

out.println(str);

<%=str%>

对于前面定义的信息的获取，使用下面的代码：

使用Java脚本显示信息<br>

<br>

请求头信息:

String pa = request.getHeader("Accept-language");

out.println("使用的语言为："+pa);

<br>请求信息：

String para = request.getParameter("para");

out.println(para);

<br>状态信息：

String gstatus = (String)request.getAttribute("status");

out.println(gstatus);

<br>异常信息：

Exception gexception = (Exception)request.getAttribute("myexception");

out.println(gexception.toString());

<br>查询的结果：

String gresult = (String)request.getAttribute("result");

out.println(gresult);

<br>查询的对象的信息：

Calendar gc = (Calendar)request.getAttribute("resultobject");

out.println("现在是:"+gc.get(Calendar.YEAR)+"年"+(gc.get(Calendar.MONTH)+1)+"月"+gc.get(Calendar.DATE)+"日");

<br>request中的一般信息：

String grequestinfo = (String)request.getAttribute("requestinfo");

<%=grequestinfo%>

<br>session中的一般信息：

String gsessioninfo = (String)session.getAttribute("sessioninfo");

<%=gsessioninfo%>

<br>application中的一般信息：

String gapplicationinfo = (String)application.getAttribute("applicationinfo");

<%=gapplicationinfo%>

需要注意几点：

第一，需要在前面引入java.util.Calendar类；

第二，如果要运行需要把前面的代码放在这段代码之前，或者分别保存两个代码，然后再前面的代码中增加一行<jsp:forward>语句，跳转到后者。

第三，在运行的时候，需要在请求的后面添加“?para=ffff”，其中“ffff”可以随便写，目的是传值，与表单提交的作用是相同的。

第四， request的getHeader方法用于获取请求头信息，参数是请求头中的某个属性，代码中的参数“Accept-language”是指使用的默认语言。

部署、运行程序，在地址栏中输入下面的请求：

http://localhost:8080/display/display.jsp?para=fffff

会得到下面的运行结果：

使用Java脚本显示信息

请求头信息: 使用的语言为：zh-cn
请求信息： fffff
状态信息：操作完成
异常信息： java.lang.Exception: 异常信息:我们假设的异常!
查询的结果：平均成绩为75
查询的对象的信息：现在是:2006 年2月9日
request中的一般信息：这是request中的信息！
session中的一般信息：这是session中的信息！
application中的一般信息：这是application中的信息！

使用标准标签库输出

使用标准标签库进行输出，主要使用标准标签库中的<c:out>标签，但前提需要把标签标签库引入：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

并且要保证相应的tld文件和压缩包文件在相应的位置，如果你使用集成开发环境，这些工作不需要自己动手，系统会自动完成。下面的代码完成了和上面相同的功能：

使用标准标签库显示信息<br>

<br>请求头信息:

${header["accept-language"]}

<br>请求信息：

<c:out value="${param.para}">

</c:out>

<br>状态信息：

<c:out value="${requestScope.status}">

</c:out>

<br>异常信息：

<c:out value="${requestScope.myexception}">

</c:out>

<br>查询的结果：

<c:out value="${requestScope.result}">

</c:out>

<br>查询的对象的信息：

${requestScope.resultobject["time"]}

<br>request中的一般信息：

<c:out value="${requestScope.requestinfo}">

</c:out>

<br>session中的一般信息：

<c:out value="${sessionScope.sessioninfo}">

</c:out>

<br>application中的一般信息：

<c:out value="${applicationScope.applicationinfo}">

</c:out>

这个代码看起来要比使用Java脚本来的简单，但是代价是多了标注标签库的实现文件和tld文件。

主要的代码是两种输出语句：

使用表达式语言：${header["accept-language"]}

使用<c:out>标签：<c:out value="${applicationScope.applicationinfo}"></c:out>

这个运行结果与上面的运行结果基本相同，只是显示时间的地方不太一样，运行的方式相同，运行后的结果为：

使用标准标签库显示信息

请求头信息 : zh-cn
请求信息： fffff
状态信息：操作完成
异常信息： java.lang.Exception: 异常信息 : 我们假设的异常 !
查询的结果：平均成绩为 75
查询的对象的信息： Thu Feb 09 16:23:03 CST 2006
request 中的一般信息：这是 request 中的信息！
session 中的一般信息：这是 session 中的信息！
application 中的一般信息：这是 application 中的信息！

使用Struts标签库输出

如果你使用Struts框架的话，可以使用该框架提供的<bean:write>标签完成上面相同的功能，下面的代码就是使用Struts标签库完成了相同的功能：

使用Struts标签库显示信息<br>

<br>请求头信息:

<bean:header id="blanguage" name="Accept-language"/>

使用的默认语言为:<bean:write name="blanguage"/>

<br>请求信息：

<bean:parameter id="bpara" name="para"/>

<bean:write name="bpara"/>

<br>状态信息：

<bean:write name="status"/>

<br>异常信息：

<bean:write name="myexception"/>

<br>查询的结果：

<bean:write name="result"/>

<br>查询的对象的信息：

<bean:write name="resultobject" property="time"/>

<br>request中的一般信息：

<bean:write name="requestinfo"/>

<br>session中的一般信息：

<bean:write name="sessioninfo"/>

<br>application中的一般信息：

<bean:write name="applicationinfo"/>

使用<bean:write>标签完成输出，同样需要引入声明自定义标签库：

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

运行过程和运行结果和使用标准标签库完全相同。

3种输出方式的比较

上面的3种方式把JSP的输出信息基本上都包含了，从代码上来看，第一种使用嵌入Java脚本的方式，代码量比较大，并且程序的结构不如后两者清晰，但是也有它的好处，就是非常灵活。

使用标准标签库和Struts标签库，从本质上说没有太大的区别，都是采用自定义标签库来减少界面中的代码，方便用户便写代码。两者在使用的时候也有一些细微的差别。标签标签库与表达式语言结合，代码看起来更简单，并且不管访问什么信息，采用的格式基本上是相同的。但是Struts标签库，在访问page、request、session和application范围内的变量比较方便，并且不需要指定是哪个作用范围内的变量，但是访问Cookie、Header、Parameter信息的时候，就不是非常灵活。

实现条件性的输出

条件性输出，也就是在满足一定条件才输出，或者不输出。条件性输出是比较基本的功能。

假设我们要完成这样的功能：有一个学习网站，某个网页上面显示了一些主题，包括Java、JSP和J2EE相关的多个主题，如果没有任何控制我们将看到最左边的图所示的界面，我们希望进行控制，如果用户选择Java，只显示与Java相关的主题，如果用户选择Jsp，则显示与JSP相关的主题，如果用户选择J2EE则显示与J2EE相关的主题，如果用户不选择，则显示全部主题。下图中间和右边显示了另外两种情况。

在没有添加控制代码之前界面的代码如下：

<%@ page contentType="text/html; charset=GBK" %>

<html>

<head>

<title>

controlleddisplay

</title>

</head>

<h4>

选择性输出测试

</h4>

<h6>面向对象编程</h6>

<h6>JavaBean</h6>

<h6>Servlet</h6>

<h6>Web应用</h6>

<h6>EJB应用</h6>

</body>

</html>

下面我们仍然分别采用Java脚本、标准标签库和Struts标签库实现以上功能，希望读者不要考虑这里的逻辑和需求是否合理，主要是介绍怎样进行控制性的输出。

用Java脚本实现条件性的输出

使用Java脚本，主要通过Java语言本身提供的if语句，这个基本语法比较简单，但是对于初学者来说，主要问题，在于Java代码与html代码之间的配合不太好理解。

例如，初学者可能会写下面的代码：

if(para==null||para.length()==0||para.equalsIgnoreCase("java"))

{

<h6>面向对象编程</h6>

}

这样的代码，在运行的时候会报错。因为在脚本（“<%”和“%>”）中只能出现Java代码。

还有一种错误，如果if条件满足的时候，要执行的语句只有一句，可能会写成：

if(para==null||para.length()==0||para.equalsIgnoreCase("java"))

同样这时候会出错。怎么处理呢？一个非常简单的方法，分两步走：第一步，不管是Java代码，还是html代码，先按照逻辑写出来，例如：

if(para==null||para.length()==0||para.equalsIgnoreCase("java"))

{

<h6>面向对象编程</h6>

}

第二步，如果是Java脚本使用“<%”“%>”括起来，就可以了：

if(para==null||para.length()==0||para.equalsIgnoreCase("java"))

{

<h6>面向对象编程</h6>

}

下面代码使用Java脚本完成控制性的输出，代码本身不难理解，所以没有给出太多解释。

<%@ page contentType="text/html; charset=GBK" %>

<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>

<head>

<title>

controlleddisplay

</title>

</head>

String para = request.getParameter("para");

//通过request的getParameter方法获取用户的控制条

<h4>

选择性输出测试

</h4>

if(para==null||para.length()==0||para.equalsIgnoreCase("java"))

{

<h6>面向对象编程</h6>

}

if(para==null||para.length()==0||para.equalsIgnoreCase("jsp"))

{

<h6>JavaBean</h6>

<h6>Servlet</h6>

}

if(para==null||para.length()==0||para.equalsIgnoreCase("j2ee"))

{

<h6>Web应用</h6>

<h6>EJB应用</h6>

}

</body>

</html>

使用标准标签库实现条件性的输出

使用标签库的主要作用也就是把if语句隐藏起来，由标准标签库来实现，我们需要做的是调用标准标签库。

标准标签库中实现条件性输出可以通过<c:if>标签完成的。<c:if>的基本格式如下：

<c:if test=”expression” var=”varname” scope=”scopevalue”/>

或者

<c:if test=”expression” var=”varname” scope=”scopevalue”></c:if>

其中，test后面是逻辑表达式，var用于定义变量，可以把test的结果保存到该变量中，scope指定该变量的作用范围。

下面的就是使用标准标签库中的<c:if>标签实现的条件性输出的完整代码：

<%@ page contentType="text/html; charset=GBK" %>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>

<head>

<title>

controlleddisplay

</title>

</head>

<h4>

选择性输出测试

</h4>

<c:if test="${param.para==null || param.para=='' || param.para=='java'}">

<h6>面向对象编程</h6>

</c:if>

<c:if test="${param.para==null || param.para=='' || param.para=='jsp'}">

<h6>JavaBean</h6>

<h6>Servlet</h6>

</c:if>

<c:if test="${param.para==null || param.para=='' || param.para=='j2ee'}" var="j2ee">

</c:if>

<c:if test="${j2ee}">

<h6>Web应用</h6>

<h6>EJB应用</h6>

</c:if>

</body>

</html>

如果是在多个条件中选择的话，可以使用<c:choose>标签，与java中的switch语句的作用非常像。下面是使用<c:choose>实现的完整的代码：

<%@ page contentType="text/html; charset=GBK" %>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>

<head>

<title>

controlleddisplay

</title>

</head>

<h4>

选择性输出测试

</h4>

<c:choose>

<c:when test="${param.para==null || param.para=='' || param.para=='java'}">

<h6>面向对象编程</h6>

</c:when>

<c:when test="${param.para==null || param.para=='' || param.para=='jsp'}">

<h6>JavaBean</h6>

<h6>Servlet</h6>

</c:when>

<c:when test="${param.para==null || param.para=='' || param.para=='j2ee'}">

<h6>Web应用</h6>

<h6>EJB应用</h6>

</c:when>

<c:otherwise>

你选择的信息不正确

</c:otherwise>

</c:choose>

</body>

</html>

使用Struts标签库实现条件性的输出

Struts标签库关于判断的标签比较多：

<logic:empty> 判断是否为空

<logic:notEmpty> 判断是否不为空

<logic:present>判断是否存在

<logic:notPresent>判断是否不存在

<logic:match>判断是否匹配

<logic:notMatch> 判断是否不匹配

<logic:greaterThan>判断是否大于

<logic:greaterEqual>判断是否大于等于

<logic:equal>判断是否等于

<logic:notEqual>判断是否不等

<logic:lessThan>判断是否小于

<logic:lessEqual>判断是否小于等于

这些标签的用法基本相同，前面4个判断某个变量存在不存在，某个变量是否为空，后面8个是判断某个变量与某个值之间的关系，关系从标签的名字上能够比较明显的看出。

这些标签的值的来源可以是多种情况：

请求参数，使用parameter确定，例如：

<logic:match value=”zhangsan” parameter=”pp”>

Cookie信息，使用Cookie确定，例如：

<logic:match value=”zhangsan” cookie=”user”>

Header信息，使用Header确定，例如：

<logic:match value=”zhangsan” header=”user”>

page、request、session或者application中的信息，通过name确定，如果是某个JavaBean的属性，通过name和property确定，可以通过scope确定哪个范围内的变量，如果不指定，按照page、request、session和application的顺序找，例如：

<logic:match value=”zhangsan” name=”user”>

<logic:match value=”zhangsan” name=”user” property=”username”>

<logic:match value=”zhangsan” name=”user” property=”username” scope=”request”>

第一行代码，使用user变量与“zhangsan”比较，user变量可能是page、request、session也可能是application中的变量。

第二行代码，使用user对象的username属性与“zhangsan”比较，对象也可能是各种作用范围。

第三行代码，同样使用user对象的username属性与“zhangsan”比较，对象是request作用范围的对象。

下面的代码是使用Struts标签库中的两个标签完成条件性输出的完整代码：

<%@ page contentType="text/html; charset=GBK" %>

<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<html>

<head>

<title>

controlleddisplay

</title>

</head>

<h4>

选择性输出测试

</h4>

<logic:notPresent parameter="para">

<h6>面向对象编程</h6>

<h6>JavaBean</h6>

<h6>Servlet</h6>

<h6>Web应用</h6>

<h6>EJB应用</h6>

</logic:notPresent>

<logic:present parameter="para">

<logic:match value="java" parameter="para">

<h6>面向对象编程</h6>

</logic:match>

<logic:match value="jsp" parameter="para">

<h6>JavaBean</h6>

<h6>Servlet</h6>

</logic:match>

<logic:match value="j2ee" parameter="para">

<h6>Web应用</h6>

<h6>EJB应用</h6>

</logic:match>

</logic:present>

</body>

</html>

查询数据的显示

前面介绍的信息的显示通常都是少量的信息的显示，而很多时候查询到的数据是批量的，这时候我们就必须使用循环来处理，我们可以使用在JSP嵌入Java脚本的方式嵌入for循环，或者while循环，同时在JSP的标准标签库中也提供了相应的标签来实现循环的功能，现在比较成熟的Struts中提供了相应的标签。

这一节内容，我们仍然通过这3种方式来分别实现对批量数据的显示。在开始具体的数据显示之前，我们需要进行一些准备工作，准备工作主要的目的就是获取要显示的数据，如果你对数据获取本身不感兴趣，可以跳过前面的准备工作部分，但是需要知道在显示之前，request中应该有ArrayList对象，名字是books，里面的对象类型是Book，有4个属性：bookid，bookname，price和author，其中只有price是float类型，其它都是String类型。

具体的准备工作包括以下几个方面：

（0）声明：因为此处的内容主要关注显示，所以其它代码中可能会存在不合理的地方。

（1）数据库准备：使用mysql数据库

创建数据库：数据库名字是webtest。

创建表：图书表，表结构如下：

create table book

{

bookid varchar(10) primary key,

bookname varchar(50),

price float,

author varchar(10)

}

（2）创建工程，使用Eclipse或者JBuider都可以。

（3）创建Web应用，这里Web应用的名字是display，选择使用Struts1.2和JSTL。

（4）创建一个初始界面index.jsp，非常简单，代码如下：

<%@ page contentType="text/html; charset=GBK" %>

<html>

<head>

<title>

index

</title>

</head>

<h1>

<a href="findAction.do">查看所有图书</a>

</h1>

</body>

</html>

完成的主要功能就是通过超链链接到查询图书信息的Action。

（5）创建管理数据库连接的JavaBean，这里使用了包com.li.bo。

package com.li.bo;

import java.sql.*;

public class DBHelper {

private String dbdriver = "com.mysql.jdbc.Driver";

private String url = "jdbc:mysql://localhost:3306/webtest";

private String user = "root";

private String pass = "";

private Connection con;

public DBHelper(String dbdriver,String url,String user,String pass)

{

this.dbdriver = dbdriver;

this.url = url;

this.user = user;

this.pass = pass;

}

public Connection getConnection()

{

try {

Class.forName(dbdriver);

con = DriverManager.getConnection(url,user,pass);

}

catch(Exception e){System.out.println(e.toString());}

return con;

}

public void releaseConnection()

{

try {

con.close();

}

catch (SQLException ex) {

}

（6）创建业务模型Book，包名是com.li.bo。

package com.li.bo;

import java.util.*;

import java.sql.*;

public class Book implements java.io.Serializable

{

private String bookid;

private float price;

private String author;

public Book(){

}

public static ArrayList findAllBooks()

{

ArrayList books = new ArrayList();

//保存所有图书

DBHelper dbh = new DBHelper();

//创建数据库连接Bean

try

{

Connection con = dbh.getConnection();

//获取连接

Statement stmt = con.createStatement();

//创建语句对象

ResultSet rs = stmt.executeQuery("select * from book");

//查询然后获取结果集

while(rs.next()) //对结果集进行遍历

{

String bookid = rs.getString(1);

//获取书号

String bookname = rs.getString(2);

//获取书名

bookname = new String(bookname.getBytes("8859_1"));

//对书名进行编码转化，因为数据库中的编码是8859_1，如果是gb2312，就不需要转换了

float price = rs.getFloat(3);

//获取图书价格

String author = rs.getString(4);

//获取图书作者

author = new String(author.getBytes("8859_1"));

//对作者进行编码转化

Book b = new Book(bookid,bookname,price,author);

//根据这些信息构造图书对象

books.add(b);

//把图书对象添加到图书列表中

}

rs.close();

stmt.close();

dbh.releaseConnection();

}catch(Exception e)

{System.out.println(e.toString());}

return books;

//返回图书列表

}

public Book(String bookid,String bookname,float price,String author)

{

this.bookid = bookid;

this.bookname = bookname;

this.price = price;

this.author = author;

}

private String bookname;

public void setBookid(String bookid) {

this.bookid = bookid;

}

public void setBookname(String bookname) {

this.bookname = bookname;

}

public void setPrice(float price) {

this.price = price;

}

public void setAuthor(String author) {

this.author = author;

}

public String getBookid() {

return bookid;

}

public String getBookname() {

return bookname;

}

public float getPrice() {

return price;

}

public String getAuthor() {

return author;

}

该代码的主要作用是封装图书信息，其中有一个业务方法findAllBooks用于查询数据库中所有的图书，然后以集合的方式把图书列表返回，而不是返回结果集，如果返回结果集，对数据库的连接时间会比较长。

（7）创建查询Action，功能比较简单，代码如下：

package com.li.action;

import com.li.bo.*;

import java.util.*;

import org.apache.struts.action.ActionMapping;

import org.apache.struts.action.ActionForm;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.Action;

public class FindAction

extends Action {

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request,

HttpServletResponse response) {

ArrayList books = Book.findAllBooks();

//查询图书信息

request.setAttribute("books",books);

//把图书信息保存到request对象中

return mapping.findForward("success");

//选择界面对用户进行响应

}

主要功能，调用业务模型Book的静态方法findAllBooks获取所有的图书列表，然后把这个信息保存在request对象中，最后选择结面对用户进行响应。

（8）修改配置文件struts-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<struts-config>

<action-mappings>

</action>

</action-mappings>

<message-resources parameter="ApplicationResources" />

</struts-config>

需要注意的是<action>的配置，path是“/findAction”，就是我们在index.jsp中编写超链的时候使用的名字，另外配置了一个<forward>元素，name属性是success，path是/test.jsp，success是Action中所使用的响应的界面的别名，test.jsp就是用于显示数据的界面。至此我们的准备工作就完成了，虽然比较麻烦，但是如果没有以上这些准备工作，下面的内容就没有办法运行。

使用Java脚本的方式显示数据

因为Java脚本与html代码之间的交叉比较多，所以这个过程我们比较详细的介绍。

首先，我们要知道最终要显示成什么效果，下面就是我们最重要显示的结果，里面的信息都是静态的：