JavaWeb：JSP概述

定义

1.1 JSP (Java Serve Pages)：一种动态网页技术标准。部署在网络服务器上，以Java为脚本语言，根据客户算发送的请求，动态地生成HTML等格式文档，返回客户端。JSP文件（.jsp后缀）在运行时会被编译成Servlet代码。可利用JavaBean和标签库技术复用常用的功能代码。

1.2 TCP/IP (Transmission Control Protocol/Internet Protocol)：传输控制协议/网际协议，在多个不同网络间实现信息传输。TCP/IP协议包含FTP、SMTP、UDP、TCP、IP等。是Internet最基本的协议。是一个四层的体系结构，包含应用层、传输层、网络层和数据链路层，每一次包含不同的协议。

1.3 HTTP (Hypertext Transfer Protocol)：超文本传输协议。一个简单的请求-响应协议，指定了客户端可能发送给服务器什么样的消息以及得到什么样的响应。HTTP协议和TCP/IP技术共同支撑起WWW技术的发展。Web服务器需要监听在80/TCP端口。

1.4 FTP (File Transfer Protocol)：文件传输协议。一种在网络中进行文件传输的广泛使用的标准协议，允许用户通过客户端软件与服务器进行交互，实现文件的上传、下载和其他操作。

1.5 DNS (Domain Name System)：域名系统。是将域名和IP地址相互映射的一个分布式数据库。

1.6 HTML (Hyper Text Markup Language)：超文本标记语言，标准通用标记语言下的一个应用。包括一系列标签，可以将网络上的文档格式统一。是标记语言，不是编程语言。
注意将HTTP和HTML区分开！

1.7 超链接：从一个网页指向另一个目标的连接关系，这个目标可以是另一个网页、也可以是相同网页上的同位置，可以是一个图片、电子邮件地址、文件、应用程序。而在一个网页中用来超链接的对象，可以是一段文本或一个图片。当浏览者单击已链接的文字或图片，链接目标将显示在浏览器上，并根据目标的类型来打开或运行。

1.8
Javac：JDK中用来编译Java源文件的工具。
Javap：Java类文件的反汇编器。
Javah：用于生成C语言头文件的工具。

1.9
B/S结构 (Browser/Server)：浏览器/服务器模式。一种网络结构模式。Web浏览器是客户端最主要的应用软件，这种模式统一了客户端，将系统功能实现的核心部分集中到服务器上，简化了系统的开发、维护和使用。客户机上只要安装一个浏览器，如Edge、Chrome等，服务群安装Sql Server、MYSQL、Oracle等数据库，浏览器通过Web Server同数据库进行数据交互。
C/S结构 (Client/Server)：客户端/服务群模式。应用程序最大的特点是在没和用户端安装程序。特点是用户端程序一致，便于控制，服务器端和用户本地数据容易交互，通信速度快。缺点是每个用户都要安装客户端，比较繁琐，且不能很好地跨系统平台。

1.10 WEB-INF：Java文件代码的编译输出目录。由以下部分组成：lib目录，存放.jar或.zip文件（目录WEB-INF\lib）；web.xml，Web应用初始化配置文件。WEB-INF内的文件对用户不可见。JSP文件通常位于WEB-INF文件夹之外。

1.11 J2EE (Java 2 Platform Enterprise Edition)：Java 2企业版，是一个用于开发企业级应用的中间件基础架构。

1.12 Cookie：存储在用户本地终端上的数据。通常用户存储特定用户的会话信息，每个用户的Cookie是独立的，因此无法通过Cookie在不同用户间共享数据。可以保存在硬盘上或内存里。Cookie永远不会以任何方式执行，不会造成严重的安全威胁。Cookie数据存储功能由浏览器提供，所有Cookie功能都必须要有浏览器支持才行。【概念与使用：Cookie为浏览器提供的 功能，是一种可将联机用户的数据存储在客户端计算机上的技术，要运用Cookie必须先建立一个Cookie对象来存储字符串数据，再将Cookie对象传送到客户端。】

1.13 JavaBean：一种特殊的Java程序，用于包装特定的功能的程序代码，可以被JSP网页重复使用，本身无法独立运行，是JSP网页程序组件化的核心。

1.14 JSTL (JSP Standard Tag Library)：JSP标准标签库，提供给Java Web开发人员一个标准通用的标签库。

1.15 tld文件：jsp自定义web标签库，包含标签的名称、描述、搬到、使用方式等。主要存放在WEB-INF目录下。

1.16 BeanUtils：BeanUtils是Apache commons组件的成员之一，主要用于简化JavaBean封装数据的操作。它可以给JavaBean封装一个字符串数据，也可以将一个表单提交的所有数据封装到JavaBean中。

1.17 常量：常量是用来代替一个数或字符串的名称。

1.18 窗口对象：窗口对象是一种顶级对象，可以用这个对象去发现窗口的URL或构造按钮，在浏览器中模拟Back和forward按钮，这几个按钮通过用户的网络冲浪历史记录转到不同的URL。

1.19 数据库管理系统：数据库管理系统是用来操纵和管理数据库的系统软件。

1.20 Parameter对象：一个Parameter对象代表了一个因为参数化查询或存储过程而与Command对象相关的参数或参量，很多Provider支持带参数的命令。

1.21 Session对象：JSP里有很多内部对象，Session对象就是其中之一，它用来保存每个用户的信息，以便跟踪每个用户的操作状态。其中Session信息保存在容器里，Session的id保存在客户机的Cookie中。

属性

2.1 Web结构的两个主要部分：浏览器、服务器。

2.2 网络上通用的三种通信协议：HTTP、FTP、MAIL。（MAIL有疑问）

2.3 静态网页*.html中的脚本代码只能在客户端运行。

2.4 JSP和Servlet的主要区别：JSP侧重于视图，允许Java和HTML组合成一个文件；Servlet侧重于控制逻辑，主要用于生成HTML页面。

2.5 JSP页面转译后，将创建一个servlet文件。JSP的实质是Servlet。

2.6 JSP文件不能脱离服务器单独运行。

2.7 脚本语言通常需要解释器才能运行，不是解释型语言。例：JS,JSP,Python,ASP

2.8 目前在客户端运行的两种主要动态Script语言：JavaScript, VBScript。

2.9 JSP文件的组成：HTML文件，Java程序片段，JSP标记。

2.10 MVC设计模式将应用程序分为：模型，视图，控制器。

2.11 Web应用程序使用的三层体系结构：表示层，业务层，数据层。

2.12 WebContent文件夹主要存放：JSP文件，HTML文件。

2.13 在Eclipse开发项目中，src目录用来存放java源文件。

2.14 Tomcat的全局配置文件，修改Tomcat服务默认使用的端口号的文件：server.xml。

2.15 当多个用户请求同一个JSP页面时，Tomcat服务器为每个客户启动一个线程。

2.16 JDK不是一个Eclipse插件，是Java开发工具包，是Java开发环境的核心组件。

2.17 要根据Eclipse版本选择相应版本JDK。

2.18 Tomcat可以被视作一个单独的Web服务器，是由Apache开发的一个Servlet容器。

2.19 除了开发工具外，还要安装一个支持Java Servlet的Web服务器，或在现有Web服务器上安装Servlet软件包。

2.20 Tomcat是一个流行的开源Servlet容器，它实现了Java Servlet和JavaServer Pages (JSP) 规范。

2.21 JSP的三个指令元素：<%@page%>，<%@include%>，<%@taglib%>。

2.22 JSP中的forward标签用于将请求转发给其他JSP页面（简写：页面跳转）。

2.23 <%@include%>只允许包含静态文件，<jsp:include>允许包含静态和动态文件。

2.24 动作元素<jsp:setProperty>作用为设置javabean对象的属性。

2.25 在JSP页面中，列表框的name属性值为“city”，且允许多选，若要一次性读取所有选中项并存放于数组str中，则对应的java语句为String[] str=request.getParameterValues("city");。

2.26 <jsp:forward...>标记的page属性值，可以是相对路径也可以是静态路径。

2.27 response.sendRedirect(“”)方法，可以实现本网站内的页面跳转，也可以用于夸网页跳转，可以在URL中附加查询参数。

2.28 response.addHeader方法，用于向HTTP响应头中添加额外的头部信息，而非修改。

2.29 在Web程序中，Cookie保存在客户端，session保存在服务器端。

2.30 可以在不同用户间共享数据的方法：文件系统、数据库、ServletContext对象。

2.31 Servlet API中用于处理Cookie的核心类：Javax.sevlet.http.Cookie。

2.32
获取Cookie：request.getCookies
发送Cookie：response.addCookie

2.33 实现会话追踪的四种方式：使用持续Cookie、重写包含额外参数的URL、建立含有数据的隐藏表单字段、使用内建session对象（最常用）。

2.34 大多数Web应用框架中，session默认使用Cookie技术进行会话追踪。

2.35 设置session访问超时时间的方法：setMaxInactiveInterval()。

2.36 sessionID将通过会话来维持。

2.37 编写一个简单的JavaBean类可以遵循以下步骤：
（1）类必须用public修饰。
（2）类必须有一个无参的构造方法。
（3）所有的属性必须私有化。
（4）私有化的属性必须通过public的方法进行访问。

2.38 JavaBean可以保存状态。

2.39 静态类只能实例化一次，普通类可以有多个实例化对象。JavaBean是一个类，遵循前述规则。

2.40 JavaBean是一种java，通过封装属性和方法成为具有某种功能或者出于某个业务的对象，简称Bean。

2.41 在Tomcat中，所有编译好的JavaBean都需要放在某个应用目录下的WEB-INF/classes目录之下。

2.42 JSP开发网站的两种模式：jsp+javabean、jsp+javabean+servlet。

2.43 如果你想用JavaBean设计一个网站计数器，那么该Bean的scope应当设为application。

2.44 按功能JavaBean可以分为可视化JavaBean和非可视化JavaBean。

2.45 如何在网站中载入JavaBean：<jsp:useBean id=id-name scope=scope-name class=class-name />。

2.46 JavaBean可以声明哪些不同的生命周期：request、session、page、application。

2.47 JavaBean程序除了必须有一个无传入值的建构式之外，还必须是一个公开的类，并以set及get开头的方法来设置于取得属性。

2.48 字节流类为处理字节式输入输出提供了丰富的环境，字节流的处理单元为1个字节。
字符流提供了处理任何类型输入输出操作的功能，字符流的处理单元为2个字节的Unicode字符。

2.49 JSP网页使用File类之前，将载入的命名空间：java.io。

2.50 文件上传通常需要post方法而非get。

2.51 处理表单数据使用multipart/form-data类，而非HttpRequest。

2.52 Java中的四个输入/输出抽象类：InputStream、OutputStream、Writer、Reader。

2.53 JSP应用程序配置文件的根元素：<web-app>。

2.54 JDBC的主要任务：与数据库建立连接、发送SQL语句、处理结果。

2.55 (JDBC)想创建一个不敏感可滚动且不可更新的结果集，参数选择：Result.TYPE_SCROLL_INSENSITIVE、Result.CONCUR_READ_ONLY。

2.56 (JDBC)在可更新的结果集中插入一条新纪录，首先要将游标移动到一个可更新得到行，调用moveToInsertRow()。

2.57 sun开头的是access数据库加载的驱动。

2.58 数据库服务与Web服务器需要部署在同一台计算机上。

2.59 数据库连接池配置繁琐，所以应该利用数据库连接池来优化数据库连接的管理，而不是在每页上都重新建立连接。

2.60 Java中以字节流InputStreamOutStream来读写二进制数据和字符数据，他们都包含在java.io中。

2.61 一般互联网软件开发分为五个基本阶段：规划、设计、建设和测试、投入使用、运行和维护。

2.62 一个Servlet可以映射多个路径。

2.63 Servlet可以在以下三个不同作用域存储数据：请求HttpServlet、会话HttpSession、上下文ServletContext。

2.64 如果某个类要成为Servlet，则它应该继承HttpServlet、GenericServlet接口、Servlet类。

2.65 在Web容器中，Http请求与响应对象实例：HttpServletRequest、HttpServletResponse。（是Java Servlet Api的核心部分）

2.66 ServletContext比Session范围要大。

2.67 转发步骤：在Servlet中得到RequestDispatch对象，再调用该对象的forward方法。

2.68 Servlet中的两种异常处理机制：程序式异常处理机制声明式异常处理机制。

2.69 对Web应用来说，驻留在服务器内，在源数据和目的数据间对Web请求和Web响应的头属性和内容体进行操作的一种特殊Web组件：过滤器。

2.70 过滤器对象使用FilterChain对象调用过滤器链中的下一个过滤器或者是目标资源。

2.71 在J2EE中，使用Servlet过滤器时，需要在web.xml通过<filter-mapping>元素将过滤器映射到Web资源。

2.72 在一个Filter中，处理filter业务的是doFilter(ServletRequest request, ServletResponse response, FilterChain chain)。

2.73 EL中，隐含对象param与paramValues可直接用来存取表单传递的参数。

2.74 系统初始化数据存放于WEB-INF文件夹的web.xml，隐含对象initParam可用来对其进行访问。

2.75 JSTL提供的标签分为五大类：核心标签、i18n国际化格式标签、SQL标签、XML标签、函数标签。

2.76 在JSTL核心标签中，网页数据的存取操作行为是由out、set、remove三个标签所设置的。

2.77 在JSTL中，<c:url>用来设置一个超级链接。

2.78 在JSTL中，流程控制标签用来控制程序运行的流程，<c:choose>搭配<when>与<otherwise>，来进行多重判断。

2.79 在JSTL中，<c:forEach>标签通过属性值begin、end、step控制循环的间隔数及起始与结束值。

2.80 在JSTL中，<c:out>标签使用value属性表示要输出的内容。

2.81 在JSTL中，<c:set>标签的作用：将EL表达式的值存储在一个变量中。

2.82 在JSTL中，与存活期范围有关的四个隐含对象分别为：pageSource、requestScope、sessionScope、applicationScope。

2.83 Tomcat服务器默认的HTTP端口为8080。

2.84 数据库设计的原则：数据独立性、数据完整性、数据一致性、数据冗余最小化、数据安全性、性能优化。

2.85 系统功能结构图的设计原则：分解-协调原则、自顶向下原则、信息隐蔽与抽象原则、一致性原则、明确性原则、模块化设计原则。

简述

3.1 URL与通信协议的差异：

1. URL (Uniform Resource Locator)：全球资源定位器。是可以从互联网上得到资源的位置和方法的一种表示，是互联网上的标准资源地址。互联网上每个文件都有唯一URL。当用户想要打开远程网站主机上的网页时，必须指定其URL，即网址。
2. 通信协议：在网络上彼此通信必须遵循的沟通方式。只有双方都使用相同的通信协议，才能建立连接通道。

3.2 客户端与服务器端网页语言的不同：

1. 在客户端执行的网页语言内嵌在HTML中，这类文件通常扩展名为.html。当浏览器向服务器请求打开网页时，服务器会将整份网页传送至客户端，由浏览器进行网页程序解释操作，并将结果显示在浏览器窗口中。
2. 在服务器端执行的网页语言必须由服务器中的解释器来做解释操作，最后再将解释的结果以HTML的格式传送至客户端，直接显示在浏览器中。服务器端网络语言得到出现，才真正实现了让用户通过网络与网站进行沟通的目的。

3.3 JSP页面访问数据库的过程

1. 用户通过浏览器指定URL，向网页服务器请求特定的网页内容。
2. 服务器加载指定的JSP网页，用网页解释器解读其中的JSP程序代码。
3. 根据JSP代码中运算逻辑，存取数据库内容，建立所需的内容信息。
4. 处理好的数据用于创建HTML抢野，返回至客户端的网页浏览器进行解释。
5. 浏览器取得文件，解释其中HTML即Script代码。
6. 显示网页。

3.4 HTML网页，JavaScript网页，JSP网页运作上的差异：

1. HTML网页只能提供静态的多媒体信息，无法与联机用户做数据交换等动态交流。
2. JavaScript内嵌于网页上，与HTML混用创造动态网页效果，目前浏览器普遍支持这一网页语言，可以有效地进行一些客户端的网页工作。
3. HTML网页和JavaScript网页只运行在浏览器端。
4. 执行JSP页面时，把JSP文件先翻译为Servlet形式的Java类型字节码文件，然后通过Java虚拟机运行。JSP网页运行在服务器端。

3.5 Java相关技术：Servlet，JavaBean，JSP之间的关联与运作：

1. 每个JSP页面在被系统调用之前，必须先被Servlet容器解析成一个Servlet文件。Servlet是一种纯粹以Java语言编写，符合标准规范的Java应用程序，在网站服务器运行的时候被加载，在客户端浏览器针对服务器提出内容要求时，作出动态响应。Servlet用于创建动态网页的功能强大，但不易开发，因此发展出JSP这一服务器端网页技术。当浏览器请求JSP网页时，文本文件被编译成Servlet加载，然后产生动态网页内容。
2. JavaBean是一组包含特定功能的Java组件。当一个JSP网页需要引用此功能时，直接引用相关JavaBean组件即可。JavaBean最重要的概念在于将程序逻辑与创建页面的程序代码分开，网页只负责收集数据及页面元素的放置，而JavaBean组件包含更重要的逻辑运算。这样使JSP页面更便于维护和建构。

3.6 客户端与服务器端在网页结构中所扮演的角色：

1. 要打开和浏览网页上的网页文件，必须通过浏览器程序，而使用浏览器打开网页的这一端，称为客户端。网站为上线用户提供打开网页的服务，因此用户也可称为客户。
2. 提供浏览器服务的一方称作服务器端。用来放置这些网页信息的计算机，称为服务器。服务器并不只存放网页信息，任何可提供网络服务的计算机都是服务器，例如提供网页信息的称为网页服务器，提供文件上传与下载的称为文件服务器。

3.7 为什么在客户端双击.jsp文件不能运行JSP？

jsp文件本身是一种html+jsp标签+java代码的集成技术，jsp文件运行在服务端，所以需要web容器才能运行，浏览器才可以访问jsp网页。

3.8 安装JDK有什么用？是否需要掌握JDK命令的使用方法？

1. JDK是java软件开发包的简称，要想开发java程序就必须安装JDK。没有JDK则无法编译java程序。
2. 在集成开发环境中，不需要掌握JDK命令的使用方法。

3.9 Tomcat服务器的优点：

1. Tomcat运行时占用系统资源小，扩展性好，支持负载均衡与邮件服务等开发应用系统常用的功能；
2. Tomcat是一个开源的服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP程序的首选。

3.10 如何在HTML网页中嵌入JSP程序代码？怎样定义JSP中的声明区和嵌入区？

1. 在JSP网页中必须在<%与%>符号间嵌入程序代码。
2. JSP声明的语法格式为：
	<%! declaration;[declaration;]... %>
	<%! 声明;[声明;]... %>
  脚本代码的语法格式如下：
	<% code fragment %>
	<% 代码 %>

3.11 JSP的三个指令元素及其用途：

1. page指令：可用来设置JSP网页的特性，如：编码方式、引用类、缓冲区等。
2. include指令：可用来将HTML、文本文件或JSP程序加载当前的JSP网页。
3. taglib指令：可用来引用一个自定义的标签库。

3.12 JSP中include指令与include动作的区别是什么？

1. include指令是指把其他页面Java代码加进来，跟本页面代码合并在一起，相当于将源码从其他页面复制过来，再编译。由于本页面已经编译过了，以后其他页面更改时，本页面不改变。
2. <jsp:include>动作是指两个页面的代码运行完后，再把其他页面运行后的HTML结果页面加到本页面HTML结果页面中来，所以是运行时包含，并且还可以传递参数给被包含的页面。

3.13 JSP网页可以使用的特殊操作元素有哪些？其中<jsp:forward>与<jsp:param>操作元素各有什么功能？

1. 可使用的特殊操作元素有<jsp:param>、<jsp:include>、<jsp:forward>、<jsp:plugin>。
2. <jsp:forward>可将当前浏览器显示网页的网址重新导向新的网址。
3. <jsp:param>主要用来传递参数给JSP程序，而由程序取得参数值。

3.14☆ 编写一个JSP程序，计算10!，并显示出结果。要求先声明计算阶乘的方法，再调用该方法，最后再页面上输出结果。

<%@ page contentType="text/html; charset=gb2312"%>
<html>
<body bgcolor=cyan>
<font size=5>
	<!--<%! %>用于声明变量或定义函数-->
	<%!long jiecheng(int n){
		long p=1;
		for(int i=1; i<=n; i++){
			p=p*i;
		}
		return p;
	}%>
	<%
		/*采用递归方法计算10!的阶乘
		int digui(int x){
			int z;
			if(x == 1) z=1;
			else z=x*digui(x-1);
			return z;
		}*/
	%>
	<p>10的阶乘是</p><%=jiecheng(10)%>
</font>
</body>
</html>

3.15☆ 在JSP页面中编写静态包含文件，要求程序包含两个文件，主文件静态包含一个能够计算数据的算术平方根的页面。

<!--文件staticinclude.jsp-->
<%@ page contentType="text/html; charset=gb2312"%>
<html>
<body>
<font size=5>
	<p>请输入正整数</p>
	<form>
		<p><input type=text nam=zhengshu>
		<p><input type=submit name=submit value=提交>
	</form>
	<%
		if(request.getParameter("zhengshu")!=null){
			try{
				int i=integer.parseInt(request.getParameter("zhengshu"));
				您输入的数是：<%=i%><br>
				它的平方根是：<%=Math.sqrt(i)%>
			}
			catch(Exception e){
				out.print(e.getMessage();)
			}
		}
	%>
</font>
</body>
</html>


<!--主文件main.jsp-->
<%@ page contentType="text/html; charset=gb2312"%>
<html>
<body>
<font size=5>
	此页面静态包含staticinclude.jsp页面
	<%@include file="staticinclude.jsp" %>
</font>
</body>
</html>

3.16☆ 编写动态页面并传递数据。要求程序包含两个文件，主文件加载次文件，并将随机产生的0-1之间的数据传递给它，并在页面上显示出来。

<%@ page contentType="text/html; charset=gb2312" %>
<html>
<body bgcolor=cyan>
<font size=8>
	<%
		String str=request.getParameter("number");
		if(str==null) str="0";
		double n=Double.parseDouble(str);
	%>
	<p>您传过来的数值是：</p><%=n%>
</font>
</body>
</html>

3.17☆ 计算三角形的面积。由用户输入三角形的三条边，判断这三条边能否构成一个三角形，若能构成三角形，输出三角形的面积。

<%@ page contentType="text/html; charset=gb2312"%>
<% request.setCharacterEncoding("gb2312"); %>
<html>
<body bgcolor=cyan>
<font size=5>
	请输入三角形的三条边
	<form method=post name=three>
	<p><input type=text name=first required="required" value=<%=request.getParameter("first")%>><br>
	<p><input type=text name=second required="required" value=<%=request.getParameter("second")%>><br>
	<p><input type=text name=third required="required" value=<%=request.getParameter("third")%>><br>
	<p><input type=submit name=submit value=提交></p>
	<!--<%! %>用于声明变量或定义函数-->
	<!--一个JSP文件中即使用多个 <% %> 或 <%! %> 分隔开的代码，它们本质上是在同一上下文中的-->
	<%!
		String f,s,t,sub,msg;
		double f1,s1,t1,area,length,p;
	%>
	<%
		f=request.getParameter("first");
		s=request.getParameter("second");
		t=request.getParameter("third");
		sub=request.getParameter("submit");
		if(sub!=null && sub.equals("提交")){
			if("".equals(f) || f==null){
				msg += "请重新输入第一条边！"+"<br>";
			}
			try{
				f1=Double.parseDouble(f);
			}
			catch(Exception e){
				msg += "您输入的第一条边有误"+e.getMessage()+"<br>";
			}
			if("".equals(s) || s==null){
				msg += "请重新输入第二条边！"+"<br>";
			}
			try{
				s1=Double.parseDouble(s);
			}
			catch(Exception e){
				msg += "您输入的第二条边有误"+e.getMessage()+"<br>";
			}
			if("".equals(t) || t==null){
				msg += "请重新输入第三条边！"+"<br>";
			}
			try{
				t1=Double.parseDouble(t);
			}
			catch(Exception e){
				msg += "您输入的第三条边有误"+e.getMessage()+"<br>";
			}
			if(msg!="" || msg!=null){
				out.print(msg);
				return;
			}
			
			if((f1+s1>t1) && (f1+t1>s1) && (s1+t1>f1)){
				//海伦公式
				p=(f1+s1+t1)/2;//半周长
				area=Math.sqrt(p*(p-f1)*(p-s1)*(p-t1));
				length=f1+s1+t1;
	%>
	<p>三角形的面积是：<%=area%></p><br>
	<p>三角形的周长是：<%=length%></p><br>
	<%
			sub=null;
			}else{
				out.print("您输入的三条边长不构成三角形，请重新输入");
			}
		}
	%>
	
</font>
</body>
</html>

3.18 JSP中的内建对象包含哪些？简述这些对象在JSP的主要功能。

1. request：取得客户端数据与系统的信息。
2. response：响应客户端信息。
3. application：记录与处理上线者共享的数据。
4. session：记录与处理上线者的个别数据。
5. out：控制数据输出的操作。
6. config：取得JSP编译后Servlet的信息。
7. pageContext：存取与处理系统运行时期的各项信息。
8. page：表示当前的JSP网页。

3.19 response.sendRedirect()和动作元素<jsp:forward>的区别是什么？

1. response.sendRedirect()会在客户端呈现跳转后的URL地址，这种跳转称为客户端跳转。使用response.sendRedirect()将重定向的URL发送到客户端，浏览器再根据这个URL地址重新发起请求。此时的request和response都和第一次不同。
2. 使用动作元素完全是在服务器上进行，浏览器地址保持不变，这种称为服务器跳转。没有产生新的request和response，可以用request来传递参数。
3. response.sendRedirect()想带参数的话，可以将URL地址写成xxx.jsp?param1=aaa&...。<jsp:forward>能够使用<jsp:param/>标签向目标文件传送参数和值，目标文件必须是动态的，能够处理参数。
4. <jsp:forward>后面的语句不会被执行也不会继续发送到客户端。response.sendRedirect()后面的语句会继续执行，除非前面有return。
5. <jsp:forward>是在服务器内部进行转换，只发送给客户端最后转到的页面，速度较快。response.sendRedirect()需要服务器与客户端之间的往返，可以转到任何页面，包括网络有效域名，速度较慢。

3.20 session对象的生命周期在哪些状况下会结束：

1. 用户关闭当前使用的浏览器程序。
2. 关闭网页服务器。
3. 用户未向服务器提出请求超过预设的时间，Tomcat服务器预设为30分钟。
4. 运行程序结束session。

3.21 application与session对象存储数据变量的方式有？

application：记录联机用户共享的数据。
session：记录联机用户的个别数据。

3.22 Cookie的常见用途

1. 网站浏览人数管理。使用Cookie，网站可以测定多少人访问过，多少是老用户，一个用户多久访问一次网站。通常网站设计者借助后台数据库来实现这一目的。当用户第一次访问，网站在数据库建一个新的ID， 并把ID通过Cookie传给用户。用户再次来访时，网站把用户ID对应的计数加1，得到用户的来访次数或判断用户是新用户还是老用户。
2. 按照用户喜好定制网页外观。有的网站设计者为用户提供了改变网页内容、布局和颜色的权力，允许用户输入自己的信息，通过这些信息定制网页外观。
3. 在电子商务站点中实施购物篮等功能。可以使用Cookie记录用户ID，当你往购物篮里放新东西时，网站能记录下来，买单时网站通过数据库检索你的购物篮的所有选择。

3.23 Cookie如何保存在计算机上？文件如何命名？文件的内容是什么？

默认情况下，Cookie随着用户关闭浏览器自动消失。
如果使用setMaxAge()方法，设置Cookie对象的存在期限，这样Cookie会保存在硬盘中的Cookies文件夹，如“C:\Documents and Settings\Administrator\Cookies”，如文件“administrator@ch06[1].txt”。

3.24☆ 在JSP中使用Cookie，并设置Cookie的存活时间为10分钟。

<%@ page contentType="text/html; charset=gb2312"%>
<html>
<head>
<title>操纵Cookie示例—写入Cookie</title>
</head>
<body>
	<h2>操纵Cookie示例—写入Cookie</h2>
	<%
		try{
			Cookie cookie=new Cookie("mycookie","COOKIE_TEST");
			cookie.setMaxAge(600);
			response.addCookie(cookie);
			out.print("已经把Cookie写入客户端");
		}catch(Exception e){
			System.out.print(e);
		}
	%>
</body>
</html>

3.25 Cookie与session不同点：

session与Cookie同样用来记录上线用户的个别数据。
两者的差异在于session是存在于服务器端，而Cookie则是存在于客户端。

3.26 非MVC模式在JSP开发中的定义及其主要特点

1. 非MVC模式是JSP开发中的一种传统模式。在这种模式下，JSP页面直接调用JavaBeans组件来处理业务逻辑和数据库交互。
2. 非MVC模式的主要特点：
（1）将页面展示和业务逻辑混合在一起，不易于维护。
（2）页面和JavaBeans之间通过使用JSP标签进行交互，耦合度较高。
（3）页面开发者需要对JavaBeans和JSP都很熟悉。

3.27 比较MVC与非MVC模式在Web开发中的不同点

1. 职责分配。
非MVC：所有的逻辑、数据处理和界面渲染都在一个文件中（通常是PHP文件），使代码混杂，难以维护。
MVC：将应用程序分为三个主要部分，模型（M）负责处理数据，视图（V）负责界面展示，控制器（C）负责业务逻辑和用户输入的流程控制。每一部分有明确的职责分配，是代码更加模块化和可维护。
2. 代码重用。
非MVC：不适用。
MVC：模型、视图、控制器可以分别在不同的应用程序中重用，提高了代码可重用性。
3. 分离关注点。
非MVC：否。所有逻辑都在一个文件中，难以分离关注点。
MVC：通过分离模型、视图和控制器，可以轻松实现不同的关注点分离。
4. 测试友好性。
非MVC：不适用。
MVC：模型和视图的高度分离是它们更容易进行单元测试。
5. 扩展性。
非MVC：不适用。
MVC：模型和视图可以独立地进行扩展，增加新的模型或视图不会影响其它部分。
6. 复杂度。
非MVC：简单、容易上手，但是复杂应用开发困难。
MVC：开始时复杂，但是适合大型和复杂的应用开发。

3.28 如何利用File类进行文件目录的操作：

利用File类进行文件目录的操作首先必须建立一个File对象，将所要操作文件或是目录完整路径当作参数传入，当File对象建立后，JSP网页便可以利用这个对象调用File类的所有方法，以进行各种文件目录的操作。

3.29 文件存取操作的操作过程

首先利用File类建立一个参照指定文件的目录的File实体对象，接下来利用FileWriter和FileReader这两个类，进行指定文件的读写，负责将数据写入文件，而FileReader的read则用来读取文件中的数据。

3.30 (JDBC)说明Statement和ResultSet接口的意义，以及它们生成的对象在JSP程序处理数时，分别扮演什么角色

1. Statement：Statement接口主要提供一些运行SQL的方法，以及设置运行SQL后返回ResultSet类型对象的属性。由此接口所生成的对象在JSP中，同样是用来运行各种SQL指令与设置ResultSet对象的属性。
2. ResultSet：ResultSet接口下所定义的方法大都是用来控制ResultSet对象中指针的移动的，以取得其中的数据元素。

3.31 (JDBC)举例说明Statement运行SQL指令的三种方法：

1. execute()：运行一般SQL指令，例如建立数据库、修改数据表等。
2. executeQuery()：运行以SELECT语句开头的描述，同时返回一个包含查看结果的ResultSet对象。
3. executeUpdate()：修改数据表内容，例如新增、删除、修改数据等。

3.32 (JDBC)如何一次运行多段SQL

首先建立一个Statement对象，将多个想要运行的SQL指令以addBatch()方法加到批处理文档中，最后引用executeBatch()方法运行。

3.33 分页显示技术的优劣

1. 使用游标走位，丢弃不属于页面的数据。
2. 使用缓存结果集，一次查询所有数据。
3. 使用数据库提供的定位集SQL语句，返回指定行的数据。

3.34 数据库管理系统的主要功能

1. 数据定义功能。
2. 数据操纵功能。
3. 数据库的运行管理。
4. 数据库的建立和维护。

3.35 Servlet的生命周期

1. 装载Servlet。
2. 创建Servlet实例。
3. Web容器调用Servlet的Init()方法，对Servlet进行初始化。（Init方法只能调用一次）
4. Servlet初始化之后，将一直存在于容器中，service()响应客户端请求。
(1) 如果客户端发送GET请求，容器调用Servlet的doGet方法处理并响应请求。
(2) 如果客户端发送POST请求，容器调用Servlet的doPost方法处理并响应请求。
(3) 或者统一用service()方法处理来响应用户请求。
5. Web容器决定销毁Servlet时，先调用Servlet的destroy()方法，通常在关闭web应用之前销毁Servlet。（destroy方法仅执行一次）
（Web容器是指存放代码的服务器）

一系列事件按先后顺序为：加载类、实例化、初始化、请求处理、销毁。

3.36 Servlet和JSP的关系

Servlet是服务器端运行的一种Java应用程序。当浏览器端有请求则将其结果传递给浏览器。在JSP中使用到的所有对象都将被转换为Servlet或者非Servlet的Java对象，然后被执行，所以执行JSP实际上与执行Servlet是一样的。

3.37 开发一个Servlet所需的步骤

1. 编写Servlet实例。
2. 在web.xml文件中配置该Servlet。
3. 编写其它文件。

3.38 HttpSession接口的功能和使用方法

1. HttpSession接口是Servlet提供会话追踪解决方案。HttpSession对象存放在服务器端，只是对Cookie和url重写技术的封装应用。
2. 使用HttpSession进行会话控制的过程：
(1) 获得一个HttpSession实例对象。
(2) 访问和设置与会话相关关联信息。
(3) 废弃会话数据。

3.39 编写一个利用HttpSession接口的用户登录的Servlet，当用户已经登录时，返回欢迎信息，否则转向登录页面

//第一步：编写Servlet实例SessionServlet.java
package com;

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

//使用HttpSession管理会话的登录Servlet
public class LoginServlet extends HttpServlet{
	protected void doGet(HttpServletRequest request, HttpServletResponse response){
		throws ServletException, IOException{
			doPost(request,response);
		}
	}
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response){
		throws ServletException, IOExcetion{
			response.setContentType("text/html;charset=GB2312");
			PrintWriter out = response.getWriter();
			
			out.printIn("<html>");
			out.printIn("<head>");
			out.printIn("<title>使用HttpSession管理会话的登录页面</title>");
			out.printIn("</head>");
			out.printIn("<body>");
			
			//获取会话对象
			HttpSession session = request.getSession();
			//从会话对象中读取数据
			Boolean isLogin = (Boolean)session.getAttribute("isLogin");
			
			if(isLogin == null){
				isLogin = Boolean.FALSE;
			}
			
			String user = request.getParameter("user");
			String passward = request.getParameter("pass");
			
			if(isLogin.booleanValue()){
				//从会话对象中读取数据
				user = (String)session.getAttribute("user");
				Date loginTime = new Date(session.getCreationTime());
				out.printIn("<h2>欢迎您，"+user+"！</h2>");
				out.printIn("<h2>您的登录时间是："+loginTime+"！</h2>");
			}else if((user != null) && (password != null)){
				//在会话对象中保存数据
				session.setAttribute("user",user);
				session.setAttribute("isLogin",Boolean.TRUE);
				Date loginTime = new Date(session.getCreationTime());
				
				out.printIn("<h2>欢迎您，"+user+"！</h2>");
				out.printIn("<h2>您的登录时间是："+loginTime+"！</h2>");
			}else{
				out.printIn("<h2>请在下面输入登录信息</h2>");
				out.printIn("<form method=\"post\" action=\"login\">");
				
				out.printIn("<table>");
				
				out.printIn("<tr>");
				out.printIn("<td>用户名：</td>");
				out.printIn("<td><input name=\"user\" type=\"text\"></td>");
				out.printIn("</tr>");
				
				out.printIn("<tr>");
				out.printIn("<td>密码：</td>");
				out.printIn("<td><input name=\"cancel\" type=\"reset\" value=\"重置\"></td>");
				out.printIn("</tr>");
				
				out.printIn("</table>");
				
				out.printIn("</form>");
			}
			
			out.printIn("</body>");
			out.printIn("</html>");
		} 
	}
}

<!--第二步：在web.xml文件中配置该Servlet-->
<web-app>
	……
	<!--ServerInfoServlet definition-->
	<servlet>
		<description></description>
		<display-name>getSession</display-name>
		<servlet-name>getSession</servlet-name>
		<servlet-class>com.SessionServlet</servlet-class>
	</servlet>
	<!--SessionServlet definition-->
	<servlet-mapping>
		<servlet-name>getSession</servlet-name>
		<url-pattern>/getSession</url-pattern>
	</servlet-mapping>
	……
</web-app>

3.40 Filter接口、FilterConfig接口和FilterChain接口的功能分别是什么？提供的方法有哪些？

所有的过滤器在开发中必须实现javax.servlet.Filter接口，并且提供一个公开的不带参数的构造方法。接口定义了init()、doFilter()、destroy()三个方法。
当容器对Filter对象进行初始化时，容器调用Filter的init()方法，并传入一个实现FilterConfig接口的对象。Filter可以使用该对象获得一些有用信息。
FilterConfig接口包含以下方法：getFilterName()、getInitParameter()、getInitParameterNames()、getServletContext()。
过滤器对象使用FilterChain对象调用过滤器链中的下一个过滤器或者是调用目标资源。FilterChain接口仅定义一个方法：public void doFilter(ServletRequest req, ServletResponse res)。

3.41 如何编写并配置过滤器

1. 开发jsp页面。
2. 编写过滤器类。
3. 在web.xml文件中添加配置过滤器的代码。
4. 验证过滤器运行效果。

3.42☆ 编写一个过滤器LogFilter.java，对Request请求进行过滤，记录请求的访问时间戳、从请求获取远程地址、从请求获取远程主机名、客户请求的资源URL、客户用的浏览器，并记录到日志文件中。

//编写LogFilter.java
package filter;
import javax.servlet.*;
import java.io.*;
import javax.servlet.http.*;

public class LogFilter Implements Filter{
    FilterConfig filterConfig;

    public void destroy(){}

    public void init(FilterConfig filterconfig){
        this.filterConfig=filterconfig;
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain){
        throws IOException, ServletException{
            long startTime=System.currentTimeMillis();//访问时间戳
            String remoteAddress=request.getRemoteAdd();//从请求获取远程地址
            String remoteHost=request.getRemoteHost();//从请求获取远程主机名
            HttpServletRequest httpRequest=(HttpServletRequest)request;
            String reqURL=httpRequest.getRquestURL();//客户请求的资源URL
            String browser=httpRequest.getHeader("User-Agent");//客户用的浏览器
            chain.doFilter(request.response);
            long endTime=System.currentTimeMillis();
            long workTime=endTime-startTime;
            ServletContext sc=filterConfig.getServletContext();
            sc.log("Request from IP:"+remoteAddress+"("+remoteHost+")"+"Using browser ("+browser+")"+" and wanted to access resource "+reqURL+" and used "+workTime+" ms");
        }
    }
}

<!--在web.xml中添加如下代码部署监听器-->
<web-app>
	……
	<filter>
		<filter-name>LogFilter</filter-name>
		<filter-class>filters.LogFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>LogFilter</filter-name>
		<servlet-name>myServlet</servlet-name>
	</filter-mapping>
	……
</web-app>

3.43 什么是过滤器？什么是监听器？分别应用在哪些方面？

1. 对Web应用来说，过滤器就是驻留在服务器端，在源数据和目的数据间，对Web请求和Web响应的头属性和内容体进行操作的一种特殊Web组件。
2. Servlet监听器是Web应用程序事件模型的一部分，Servlet监听器用于监听一些Web应用中重要事件的发生，监听器对象可以在事件发生前、发生后，Servlet容器就会产生相应的事件，Servlet监听器用来处理这些事件。

3.44
ServletContextListener接口的功能和提供的方法：

ServletContextListener接口的功能和提供的方法：在Web应用程序启动时需要执行一些初始化任务，可以编写实现ServletContextListener接口的监听器类。
ServletContextListener接口中定义了两个事件处理方法，contextInitialize()和contextDestroy()。

ServletContextAttributeListener接口的功能和提供的方法：

ServletContext的属性是由Web应用程序中所有的Servlet所共享的。为保证属性在整个Web应用范围内的一致性，有必要监视ServletContext对象任何属性的改变。ServletContextListener接口就是为这一目的而设立的。
ServletContextAttributeListener接口共提供了三种方法，attributeAdd()、attributeRemoved()、attributeReplaced()。

HttpSessionBindingListener接口的功能和提供的方法：

如果一个对象实现了HttpSessionBindingListener接口，当该对象被绑定到Session中或从Session中删除时，Servlet容器会通知该对象，该对象在接收到通知后做初始化操作或清除状态操作。
HttpSessionBindingListener接口提供如下方法，valueBound()、valueUnbound()、HttpSessionBindingEvent()。

3.45 JSP乱码如何解决，列出几种解决方案

1. JSP页面出现的中英文乱码。
MyEclipse中默认的编码为ISO-8859-1，而ISO-8859-1不支持中文的编码，所以jsp文件内出现中文就不能保存了。只要在页面上加上支持中文的编码格式，如pageEncodeing="gb2312"。
2. 表单提交中文乱码。
Tomcat中，对于以post方式提交的表单编码格式默认为ISO-8859-1，它无法编码中文。需要在取得表单参数时设置编码方式，如request.setCharacterEncoding("gb2312")。

3.46☆ 编写一个监听器ContextListener.java，监听Web应用的启动和停止，并记录到日志文件中

public class ContextListener implements ServletContextListener{
	public void contextInitialized(ServletContextEvent sce){
		ServletContext context=sce.getServletContext();
		context.log(context.getServletContextName()+" initialated.");
	}
}

<web-app>
	……
	<listener>
		<listener-class>
			com.mycompany.servlet.ContextListener
		</listener-class>
	</listener>
	……
</web-app>

1. 在Tomcat中部署包含侦听器的Web应用。
2. 启动Tomcat，则侦听器就会在日志文件中添加一行信息。
3. 关闭Tomcat，侦听器同样会在日志文件中添加一行信息。

3.47 在EL中访问变量的值可以使用如下的EL元素：${变量名}，如果没有指定变量的有效范围，JSP容器会依次到那几个范围内查找该变量？

[pageScope]、[requestScope]、[sessionScope]、[applicationScope]。

3.48 如何用隐含对象获取表单参数

隐含对象param与paramValues被设计用来提供使用request之外的一个选择，这两个最大的好处便是简化了request参数数据的存取。
取值的范例程序：${param.yarValue}
param内容包含当前网页所有的request参数，这段程序代码取的其中名为yearValue的参数值。

EL对象	Request对象
${param.paraName}	request.getParameter(paraName)
${paramValues.paraName}	request.getParameterValues(paraName)

3.49 简述JSTL与一般的JSP技术有何差异

使用JSTL实现动态JSP页面的最大特点在于简单，避免了使用脚本片段带来的许多问题，Web应用开发人员利用JSTL可以取代之间嵌入页面的代码片段，提高程序可读性和可维护性。

3.50 JSTL的优点

1. 在页面里使用JSTL标签可以是美工像处理HTML标签一样对待，增加了可读性。
2. 将业务封装到JSTL可以很方便地重用。
3. 将数据与显示分离。
4. 简化了JSP的Web应用系统的开发，并且使得JSP页面的编程风格同一，易于维护。
5. 可以对其进行自定义扩展。

3.51 在Tomcat中安装使用JSTL的步骤

3.52 在JSTL中，<c:if>和<c:choose>这两种标签都可以用来进行流程判断，请说明它们的差异和用法

1. <c:if>标签用于进行条件判断，只有当其test属性指定的Boolean表达式值为true时才会处理其本体的内容，否则不执行。
2. <c:choose>标记用来处理多个可选条件下的选择。<c:choose>标记需要和<c:when>、<c:otherwise>标记配套使用，并且<c:when>、<c:otherwise>必须依附在<c:choose>标签下。

3.53☆ 使用标准标签库中的<c:foreach>标签、<c:i>标签和<c:out>标签列出1-100中能被2整除不能被3整除的数字。

<html>
<body>
	<c:set var="sum" value="0"/>
	<c:forEach var="s" begin="1" end="100" step="1">
		<c:if test="${s%2==0 && s%3!=0}" var="condition">
			输出：<c:out value="${s}"/>
		</c:if>
	</c:forEach>
</body>
</html>

3.54 说明如何使用JSTL提供电费标签设置联机信息

<!--使用<sql:setDataSource>标记来指定数据源：-->
<sql:setDataSource 
	{ 
		dataSource="dataSource" | url="jdbcUrl"
		[driver="driverClassName"]
		[user="userName"]
		[var="varName"]
		[scope="{page|request|session|application}"]
	}
/>
<!--url属性用于指定链接的url，driver属性用于指定 驱动程序，dataSource属性为数据源。-->

3.55 使用JSTL标准标记库中的标记输出1-100的数字之和。

<body>
	<c:set var="sum" value="0" />
	<c:forEach begin="1" end="100" step="1" varStatus="st">
		<c:set var="sum" value="${sum+st.count}" />
	</c:forEach>
	<c:out value="${sum}" />
</body>

3.56 创建自定义标签有哪几种方式？如何使用自定义标签？

1. 创建自定义标签：
(1) 传统标签的开发；
(2) Simple标签的开发。
2. 在标签库定义完成后，我们就可以在JSP页面中引用自定义标签：
(1) 在JSP文件中通过taglib指令引入标签库；
(2) 在JSP页面通过标签前缀和标签名使用标签。

3.57 列举编写自定义标签的步骤

1. 编写标签处理类。
2. 在tld文件中配置标签。
3. 在web.xml文件中配置标签库信息。
4. 在JSP页面引用标签。

3.58☆ 使用Tag接口编写一个输出welcome的自定义标签

//WelcomeTag.java
package demo.tag;

/**
 * 自定义标签 WelcomeTag
 */

import javax.servlet.jsp.*;
import javax.servlet.jsp.targext.*;
import java.util.Hashtable;
import java.io.Writer;
import java.io.IOException
import java.util.Date;

public class WelcomeTag implements Tag{
	private PageContext pageContext;
	private Tag parent;
	public WelcomeTag(){
		super();
	}
	
	/**
	 * 设置标签的JSP页面上下文
	 */
	public void setPageContext(PageContext pageContext){
		this.pageContext=pageContext;
	}
	
	/**
	 * 设置上一级标签
	 */
	public void setParent(Tag parent){
		this.parent=parent;
	}
	public Tag getParent(){
		return parent;
	}
	
	/**
	 * 开始标签时的操作
	 */
	public int doStartTag(){
		throws JspException{
			return Tag.SKIP_BODY;//返回SKIP_BODY，表示不计算标签体
		}
	}
	
	/**
	 * 结束标签时的操作
	 */
	public int doEndTag(){
		throws JspException{
			try{
				pageContext.getOut().write("Welcome!");
			}catch(Exception e){
				throw new JspTagException("IO Error:"+e.getMessage());
			}
		}
		return Tag.EVAL_PAGE;
	}
	public void release(){
		
	}
}

<!--标签库描述文件mytag.tld-->
……
<tag>
	<name>welcome</name>
	<tag-class>ch15.Welcome</tag-class>
	<body-content>empty</body-content>
</tag>

<!--配置web.xml-->
……
<taglib>
	<taglib-url>/mytag.tld</taglib-url>
	<taglib-location>/WEB-INF/mytag.tld</taglib-location>
</taglib>

<!--JSP页面引用标签 WelcomeTag.jsp-->
<%@page contentType="text/html;charset=gb2312" %>
<%@taglib url="/WEB-INF/mytag.tld" prefix="my" %>

<html>
<body>
<h2>测试自定义标签</h2>
<my:welcome /><br>
<br>
<br>
<my:welcomeloop count="3">
	<p style="color:red;">JSP爱好者</p>
</my:welcomeloop>
<% String outValue=", Welcome!"; %>
<my:mytag b="true">
	<my:mytag2 value="<%=outValue%>">JSP爱好者</my:mytag2>
</my:mytag>
</body>
</html>

3.59☆ 通过继承TagSupper类实现输出welcome的自定义标签

3.60☆ 通过BodyTagSupport类实现welcome的迭代输出

3.61 评价Web服务器性能的步骤

1. 管理多用户的数据库。
2. 管理用户权限及保证数据的安全性。
3. 管理和处理用户的请求，用户请求包括请求队列、响应请求、通知服务完成、返回结果。
4. 维护数据库，包括备份和恢复。

3.62 JavaBean编写要求

1. 所有的JavaBean必须放在一个包（Package）中。
2. JavaBean必须生成public class类，文件名应该与类名称一致。
3. 所有属性必须封装，一个JavaBean类不应有公共实例变量，类变量都为private。
4. 属性值应该通过一组存取方法（getXxx:setXxx）来访问：对于每个属性，应该有一个带匹配共用getter和setter方法的专用实例变量。
5. JavaBean类：须有一个空的构造函数，类中必须有一个不带参数的公用构造器，此构造器也应该通过调用各个属性的设置方法来设置属性的默认值。

3.63 Servlet执行时一般实现哪几个方法：

public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request, ServletResponse response)
public void destroy()

3.64 互联网作为全球信息系统的三大特征

1. Internet中的计算机通过全球性的唯一地址逻辑地连接在一起，这个地址是建立在网间协议（IP）或今后其他协议基础之上的。
2. Internet中的计算机之间的通信使用的是TCP/IP协议。
3. Internet可以为公共用户或个人用户提供高水平的信息服务，这种服务是建立在上述通信及相关的基础设施之上的。

3.65 系统功能结构图设计步骤

1. 从新系统数据流程图出发导出初始结构图。即首先把整个系统看作一个模块，然后对其逐层分解。分解时，要遵守划分模块的基本原则和完成数据流程图所规定的各项任务及其处理顺序。每分解出一层模块，都熬标明信息传递情况并考虑每一模块的实现方法，同时还要考虑系统结构的层数。
2. 对系统结构图进行改进。即从提高模块的对象目标出发，检查每一个模块，是否还可以降低关联度，提高聚合度，如果可以，就要对其改进，直到理想为止。

3.66 Web页面的处理过程

1. 页面的一次往返处理。页面被提交到服务器端，执行响应的事件处理代码，重建页面，然后返回到客户端。
2. 页面重建。每一次页面被请求，或者页面被提交到服务器，运行环境将执行必要的代码，重建整个页面，把结果页面送到浏览器，然后抛弃页面的变量、控件的状态和属性等页面信息。

3.67 纯Servlet方案中存在的问题

1. 开发和维护应用程序的所有部分需要有深厚的Java编程知识。
2. 改变应用程序的外观和风格，或者加入对某种新类型客户机的支持时，都需要重新编译Servlet代码。
3. 很难利用网页开发工具的优势来设计应用程序界面。