`
lixucheng
  • 浏览: 80288 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论

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

WebJavaStrutsJSPC++ 
阅读更多
经典的显示方法
本章主要介绍如果控制页面的输出，如何控制查询结果的显示，不可否认的是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”是指使用的默认语言。
部署、运行程序，在地址栏中输入下面的请求：
会得到下面的运行结果：
使用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>
<body bgcolor="#ffffff">
<h4>
选择性输出测试
</h4>
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</h6>
</body>
</html>
下面我们仍然分别采用Java脚本、标准标签库和Struts标签库实现以上功能，希望读者不要考虑这里的逻辑和需求是否合理，主要是介绍怎样进行控制性的输出。
用Java脚本实现条件性的输出
使用Java脚本，主要通过Java语言本身提供的if语句，这个基本语法比较简单，但是对于初学者来说，主要问题，在于Java代码与html代码之间的配合不太好理解。
例如，初学者可能会写下面的代码：
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("java"))
{
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
}
%>
这样的代码，在运行的时候会报错。因为在脚本（“<%”和“%>”）中只能出现Java代码。
还有一种错误，如果if条件满足的时候，要执行的语句只有一句，可能会写成：
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("java"))
%>
<h5>Java</h5>
同样这时候会出错。怎么处理呢？一个非常简单的方法，分两步走：第一步，不管是Java代码，还是html代码，先按照逻辑写出来，例如：
if(para==null||para.length()==0||para.equalsIgnoreCase("java"))
{
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
}
第二步，如果是Java脚本使用“<%”“%>”括起来，就可以了：
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("java"))
{
%>
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<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>
<body bgcolor="#ffffff">
<%
String para = request.getParameter("para");
//通过request的getParameter方法获取用户的控制条
%>
<h4>
选择性输出测试
</h4>
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("java"))
{
%>
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
<%
}
%>
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("jsp"))
{
%>
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
<%
}
%>
<%
if(para==null||para.length()==0||para.equalsIgnoreCase("j2ee"))
{
%>
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</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>
<body bgcolor="#ffffff">
<h4>
选择性输出测试
</h4>
<c:if test="${param.para==null || param.para=='' || param.para=='java'}">
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
</c:if>
<c:if test="${param.para==null || param.para=='' || param.para=='jsp'}">
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
</c:if>
<c:if test="${param.para==null || param.para=='' || param.para=='j2ee'}" var="j2ee">
</c:if>
<c:if test="${j2ee}">
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</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>
<body bgcolor="#ffffff">
<h4>
选择性输出测试
</h4>
<c:choose>
<c:when test="${param.para==null || param.para=='' || param.para=='java'}">
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
</c:when>
<c:when test="${param.para==null || param.para=='' || param.para=='jsp'}">
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
</c:when>
<c:when test="${param.para==null || param.para=='' || param.para=='j2ee'}">
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</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>
<body bgcolor="#ffffff">
<h4>
选择性输出测试
</h4>
<logic:notPresent parameter="para">
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</h6>
</logic:notPresent>
<logic:present parameter="para">
<logic:match value="java" parameter="para">
<h5>Java</h5>
<h6>概述</h6>
<h6>基本语法</h6>
<h6>面向对象编程</h6>
<h6>高级特性</h6>
</logic:match>
<logic:match value="jsp" parameter="para">
<h5>JSP</h5>
<h6>概述</h6>
<h6>语法基础</h6>
<h6>JavaBean</h6>
<h6>Servlet</h6>
<h6>JDBC</h6>
</logic:match>
<logic:match value="j2ee" parameter="para">
<h5>J2EE</h5>
<h6>概述</h6>
<h6>Web应用</h6>
<h6>EJB应用</h6>
<h6>相关服务</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>
<body bgcolor="#ffffff">
<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 path="/findAction" type="com.li.action.FindAction">
<forward name="success" path="/test.jsp" />
</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代码之间的交叉比较多，所以这个过程我们比较详细的介绍。
首先，我们要知道最终要显示成什么效果，下面就是我们最重要显示的结果，里面的信息都是静态的：
表格对应的代码如下：
<table border="2" align="center" width="70%">

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics