Servlet基础：接口、类、请求响应、配置、会话追踪、上下文、协作、异常 ■ 学习目标 了解Servlet用途 理解Servlet的生命周期 掌握Servlet的运行环境以及Servlet的体系结构 掌握Servlet的配置与执行 理解如何使用Web程序和Servlet进行交互 了解相关接口 目录： Servlet介绍 什么是Servlet Servlet技术特点 JSP与Servlet 的关系 Servlet的工作原理 Servlet常用接口和类 开发部署一个简单的Servlet Servlet文件创建 @WebServlet Servlet的配置文件 例子 Servlet实现相关的接口和类 Servlet GenericServlet HttpServlet Servlet请求和响应相关 HttpServletRequest接口 HttpServletResponse接口 Servlet配置相关 ServletConfig接口 获取 Servlet 配置信息的例子 Servlet中的会话追踪 HttpSession 接口 Servlet上下文 ServletContext接口 Servlet协作 RequestDispatcher forward()控制页面跳转 include()控制页面包含 Servlet异常相关 声明式异常处理 程序式异常处理 Servlet介绍 Servlet技术是Sun公司提供的一种实现动态网页的解决方案，它是基于Java编程语言的Web服务器端编程技术，主要用于在Web服务器端获得客户端的访问请求信息和动态生成对客户端的响应消息。同时，Servlet技术也是JSP技术的基础。 什么是Servlet Servlet是服务器端的Java小程序，可以被用来通过多种方法扩充一个Web服务器的功能。Servlet可以对客户端的请求进行响应，在默认情况下，Servlet采用一种无状态的请求-响应处理方式。 Servlet主要作用是为了增强Java服务器端功能。 一个Servlet程序就是一个实现了特殊接口的Java类，它由支持Servlet的Web服务器（具有Servlet引擎）调用和启动运行。 一个Servlet程序负责处理它所对应的一个或一组URL地址的访问请求，并用于接收客户端发出的访问请求信息和产生响应的内容。 Servlet程序可以完成的任务： 获取客户端通过HTML的FORM表单递交的数据和URL后面的参数信息 创建对客户端的响应消息内容 访问服务器端的文件系统 连接数据库并开发基于数据库的应用 调用其它的Java类 使用Servlet的基本流程： 客户端通过HTTP提出请求。 Web服务器接收该请求交给Servlet容器，然后再调用Servlet中的方法来处理。如果这个Servlet尚未被加载，Servlet容器将把它加载到Java虚拟机并且执行它。 Servlet将接收该HTTP请求并用特定的方法进行处理：可能会访问数据库、调用Web服务、EJB调用或直接给出结果， 并生成一个响应。 这个响应由Servlet容器返回给Web服务器。 Web服务器包装这个响应，以HTTP响应的方式发送给Web浏览器。 Servlet技术特点 Servlet是用Java编写的，所以它与平台无关。 Servlet是持久的。 Servlet是可扩展的。 Servlet是安全的。 JSP与Servlet 的关系 Servlet是服务器端运行的一种Java应用程序。当浏览器端有请求则将其结果传递给浏览器。 在JSP中使用到的所有对象都将被转换为Servlet或者非Servlet的Java对象，然后被执行，所以执行JSP实际上与执行Servlet是一样的。 Servlet与JSP相比有以下几点区别： 编程方式不同； Servlet必须在编译以后才能执行； 运行速度不同：由于JSP容器将JSP程序编译成Servlet的时候需要一些时间，所以JSP的运行速度比Servlet要慢一些，不过，如果JSP文件能毫无变化的重复使用，它在第一次以后的调用中运行速度就会和Servlet一样了，这是因为JSP 容器接到请求以后会确认传递过来的JSP是否有改动，如果没有改动的话，将直接调用JSP编译过的Servlet类，并提供给客户端解释执行，如果JSP文件有所改变，JSP 容器将重新将它编译成Servlet，然后再提交给客户端； Servlet用来写业务逻辑层是很强大的，但是对于写表示层就很不方便。JSP则主要是为了方便写表示层而设计的。 Servlet的工作原理 Servlet是javax.Servlet包中HttpServlet类的子类，运行在Web服务器的Servlet容器里 Servlet容器：根据Servlet的生命周期的规范，负责执行Servlet对象的初始化、运行和卸载等动作 Servlet的生命周期：Servlet在容器中从创建到删除的过程 Servlet的生命周期可分为下面几个阶段： 装载Servlet Servlet容器启动时自动加载某些Servlet； 在Servlet容器启动后，客户首次向Servlet发出请求； Servlet的类文件被更新后，重新加载Servlet。 实例化一个Servlet实例对象。 调用Servlet的init( )方法进行初始化。 服务方法：容器收到对该Servlet的请求，则调用该Servlet对象的service()方法处理请求。 卸载：当服务器端不再需要该Servlet的时候，服务器调用destroy()方法卸载该Servlet，释放Servlet运行时占用的资源。 Servlet常用接口和类 Servlet接口、GenericServlet类、HttpServlet类 HttpServlet -> extends GenericServlet -> implements Servlet Servlet是最顶层的接口，其提供的方法有 : init(ServletConfig config) : void // 初始化 getServletConfig() : ServletConfig // 取得该Servlet配置信息 getServletInfo() : String // 取得相关信息 service(ServletRequest req, ServletResponse res) : void //核心方法 destroy() : void // Servlet生命周期结束时候执行的方法 显然我们最关心的是service方法，其他的几个方法在实现的时候是千篇一律、无关痛痒的。故提供了GenericServlet类，此类实现了Servlet接口，我们在使用Servlet的时候，只需继承这个类然后覆盖其中的service方法(抛出ServletException、IOException异常)即可。 由于Servlet基本上是在http协议下使用的，故提供了HttpServlet这个类，此类继承自GenericServlet类，我们在使用Servlet时，只需继承HttpServlet类然后覆盖以下方法 : service(HttpServletRequest request , HttpServletResponse response) throws ServletException, IOException 注意：HttpServletRequest和HttpServletResponse分别是从ServletRequest和ServletResponse继承 此外，HttpServlet还提供了doPost和doGet方法，参数和返回值与service方法一样。只是service方法可以针对客户端的任何请求类型(GET和POST)，而doPost和doGet方法分别只能对应客户端的POST方式请求和GET方式的请求。 Servlet的三种实现方式 第一种创建方式：继承HttpServlet（==最优==） 重写doGet(HttpServletRequest request, HttpServletResponse response)方法 重写 doPost(HttpServletRequest request, HttpServletResponse response) 第二种创建方式：实现接口Servlet 重写getServletConfig()方法 重写getServletInfo()方法 重写init(ServletConfig arg0)方法 重写service(ServletRequest request, ServletResponse response)方法 重写destroy() 第三种创建方式：继承GenericServlet类 重写service(ServletRequest request, ServletResponse response)方法 开发部署一个简单的Servlet Servlet文件创建 创建一个Servlet，通常涉及下列4个步骤： 继承HttpServlet抽象类。 重载适当的方法，如覆盖（或称为重写）doGet()方法或doPost()方法。 如果有HTTP请求信息的话，获取该信息。 生成HTTP响应。 HttpServletResponse类对象生成响应，并将它返回到发出请求的客户机上。它的方法允许设置“请求”标题和“响应”主体。“响应”对象还含有getWriter()方法以返回一个PrintWriter类对象。使用PrintWriter的print()方法和println()方法以编写Servlet响应来返回给客户机，或者直接使用out对象输出有关HTML文档内容。 Servlet程序必须通过Servlet引擎来启动运行，并且储存目录有特殊要求，通常需要存储在<WEB应用程序目录>\WEB-INF\classes\目录中。 Servlet程序必须通过@WebServlet注解配置Servlet或者在WEB应用程序的web.xml文件中 进行注册和映射其访问路径，才可以被Servlet引擎加载和被外界访问。 Servlet的生命周期定义了一个Servlet如何被加载、初始化，以及它怎样接收请求、响应请求、提供服务。Servlet的生命周期如图。 @WebServlet @WebServlet注解配置Servlet 从Servlet3.0开始，配置Servlet支持注解方式，但还是保留了配置web.xml方式，所以使用Servlet有两种方式： Servlet类上使用@WebServlet注解进行配置 Servlet3.0 规范可通过Annotation来配置管理Web组件，因此web.xml文件可以变得更加简洁，这也是Servlet3.0 的重要简化。 web.xml文件中配置 Servlet所有版本都支持 @WebServlet常用属性 属性名 类型 描述 asyncSupported Boolean 声明Servlet是否支持异步操作模式，等价于<async-supported> 标签 description String Servlet 的描述信息，等价于<description>标签 displayName String Servlet的显示名称，通常配合工具使用，等价于<display-name>标签 initParams String Servlet的初始化参数，指定一组 Servlet 初始化参数，等价于<init-param> name String Servlet的名称，等价于<servlet-name>。没有显式指定，则该 Servlet 的取值即为类的全限定 urlPatterns String[ ] Servlet的访问URL，指定一组 Servlet 的 URL 匹配模式。等价于<url-pattern>标签 value String[ ] Servlet的访问URL，属性等价于 urlPatterns 属性。两个属性不能同时指定 loadOnStartup int Servlet的加载顺序，等价于<load-on-startup>标签 如果打算使用Annotation来配置Servlet，需要注意以下几点： 不要在web.xml文件的根元素<web-app---/>中指定metadata-complete=“true”； 不要在web.xml文件中配置该Servlet; Servlet 3.0 的部署描述文件 web.xml 的顶层标签<web-app> 有一个 metadata-complete 属性，该属性指定当前的部署描述文件是否是完全的。如果设置为 true，则容器在部署时将只依赖部署描述文件，忽略所有的注解；如果不配置该属性，或者将其设置为 false，则表示启用注解支持（和可插性支持）。 这些属性均为可选属性，但是 vlaue 或者 urlPatterns 通常是必需的，且二者不能共存，如果同时指定，通常是忽略 value 的取值。 loadOnStartup属性：标记容器是否在启动应用时就加载Servlet，默认不配置或数值为负数时表示客户端第一次请求Servlet时再加载；0或正数表示启动应用就加载，正数情况下，数值越小，加载该Servlet的优先级越高； name属性：可以指定也可以不指定，通过getServletName()可以获取到，若不指定，则为Servlet的完整类名，如：cn.edu.njit.servlet.UserServlet urlPatterns/value属性： String[]类型，可以配置多个映射，如：urlPatterns={“/user/test”, “/user/example”} 在使用注解方式时，需要注意：<web-app> </web-app>根元素中不能配置属性metadata-complete="true" ，否则无法加载Servlet。metadata-complete属性表示通知Web容器是否寻找注解，默认不写或者设置false，容器会扫描注解和Web分片，为Web应用程序构建有效的元数据；设置true，表示将由部署描述符为Web程序提供所有的配置信息web.xml中不能再配置该Servlet Servlet的配置文件 在web.xml文件中对Servlet进行配置 Servlet的名称、类和其他选项的配置 配置Servlet时，必须指定Servlet的名称、Servlet的类的路径，可选择性地给Servlet添加描述信息和指定在发布时显示的名称。 <servlet> <description></description> <display-name>Test</display-name> <servlet-name>Test</servlet-name> <servlet-class>com.TestServlet</servlet-class> </servlet> Description元素描述的是Servlet的描述信息 display-name元素描述的是发布时Servlet的名称 Servlet-name元素描述的是Servlet的名称 Servlet-class是Servlet类的路径。 初始化参数 Servlet可以配置一些初始化参数 <Servlet> <init-param> <param-name>number</param-name> <param-value>100</param-value> </init-param> </Servlet> 指定参数number的参数值为100。在Servlet中可以在init()方法体中通过getInitParameter()方法访问这些初始化参数。 启动装入优先权 启动装入优先权通过<load-on-startup>元素指定 <Servlet> <Servlet-name>ServletOne</Servlet-name> <Servlet-class>com.ServletOne</Servlet-class> <load-on-startup>5</load-on-startup> </Servlet> <Servlet> <Servlet-name>ServletTwo</Servlet-name> <Servlet-class>com.ServletTwo</Servlet-class> <load-on-startup>10</load-on-startup> </Servlet> <Servlet> <Servlet-name>ServletThree</Servlet-name> <Servlet-class>com.ServletThree</Servlet-class> <load-on-startup>AnyTime</load-on-startup> </Servlet> ServletOne类先被载入，ServletTwo类则后被载入，而ServletThree类可在任何时间内被载入 Servlet的映射 在web.xml配置文件中可以给一个Servlet做多个映射 可以通过不同的方法访问这个Servlet <servlet-mapping> <servlet-name>Test</servlet-name> <url-pattern>/Test</url-pattern> </servlet-mapping> 若请求的路径中包含/Test，则会访问逻辑名为Test的Servlet。 <Servlet-mapping> <Servlet-name>OneServlet</Servlet-name> <url-pattern>/Two/*</url-pattern> </Servlet-mapping> 若请求的路径中包含/Two/a或/Two/b等符合/Two/*的模式，则同样会访问逻辑名为OneServlet的Servlet。 注意： 在web.xml文件中所有元素出现的次序是有严格限制的 <Servlet>元素必须出现在<Servlet-mapping>元素之前。 例子 package ch10; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.*; // HelloWorld Servlet public class HelloWorld extends GenericServlet { public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<body>"); out.println("<head>"); out.println("<title>Hello World!</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Hello World!</h1>"); out.println("</body>"); out.println("</html>"); } } <!-- HelloServlet definition --> <servlet> <servlet-name>HelloServlet</servlet-name> <servlet-class>ch16.HelloWorld</servlet-class> </servlet> <!-- HelloServlet mapping --> <servlet-mapping> <servlet-name>HelloServlet</servlet-name> <url-pattern>/sayHello</url-pattern> </servlet-mapping> Servlet实现相关的接口和类 Servlet 声明： public interface Servlet 这个接口是所有Servlet必须直接或间接实现的接口 1、init()方法 : init(ServletConfig config) throws ServletException 由 Servlet 容器调用，指示将该 Servlet 放入服务。 Servlet 容器仅在实例化 Servlet 之后调用 init 方法一次。在 Servlet 可以接收任何请求之前，init 方法必须成功完成。 如果 init() 方法抛出 ServletException 或者未在 Web 服务器定义的时间段内返回，那么Servlet 容器无法将 Servlet 放入服务。方法包含 Servlet 的配置和初始化参数的 ServletConfig 对象 。如果发生妨碍 Servlet 正常操作的异常则Throws ServletException 2、service()方法 当一个Servlet对象被初始化后，该对象就活动在容器内，在容器的协助下，接收请求和发送响应。 void service(ServletRequest request，ServletRespone response) 该方法有ServletRequest和ServletResponse两个类型的参数，它们分别是“接收请求”和“响应回复”的句柄。 3、destroy()方法 服务器可以从内存中移除已经加载的Servlet，也可以在所有的线程都完成以后或超过了设定的期限时卸载Servlet。 在将Servlet卸载之前, 调用destroy()方法。 方法的描述为：public destroy() destroy()方法可以通过Servlet容器的垃圾处理器回收资源，并释放其所占的资源和内存，特别是不能被Java垃圾回收机制回收的资源。 4、getServletConfig()方法 此方法返回 ServletConfig 对象，该对象包含此 Servlet 的初始化和启动参数。返回的 ServletConfig 对象是传递给 init 方法的对象。 ServletConfig接口的实现负责存储 ServletConfig 对象，以便此方法可以返回该对象。 5、getServletInfo()方法 此方法返回包含 Servlet 信息的 String，比如作者、版本和版权。 此方法返回的字符串应该是纯文本 GenericServlet 声明： public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable GenericServlet提供了对Servlet接口的基本实现 当创建普通的和HTTP无关的操作时可以通过继承该类创建新的Serlvet GenericServlet 是个抽象类，它的 service()方法是一个抽象方法，GenericServlet 的派生类必须直接或者间接地实现这个方法 HttpServlet 声明： public Abstract class HttpServlet extends GenericServlet implements java.io.Serializable HttpServlet类是抽象类，继承自GenericServlet类 用于快速开发应用于HTTP协议的Servlet类。提供了Servlet接口中具体于HTTP的实现。 一般用户自定义的Servlet都要扩展该类。 HttpServlet类中提供了两个service()的重载方法： public void service(ServletRequest req, ServletResponse res)throws ServletException, java.io.IOException 将接收的req和res转换为HttpServletRequest和HttpServletResponse类型，并分发给受保护的service方法。 protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, java.io.IOException 接收来自public service方法的标准 HTTP 请求，并将它们分发给此类中定义的doXXX方法。 HttpServlet 的子类至少必须重写一个方法，该方法通常是以下这些方法之一： doGet()：处理http的get请求，从http服务器上取得资源。 doPost()：处理http的post请求，主要用于发送HTML文本中FORM的内容。 doHead()：用于处理HEADER请求。 doOptions()：该操作自动决定支持什么HTTP方法 doPut()：处理http的put请求，模仿 ftp发送资源。 doTrace()：处理HTTP的trace请求。 doDelete()：处理http的delete请求，从服务器上移出一个url。 这7个方法都是受保护类型的方法。 当容器为收到一个HttpServlet类型的请求时，该对象中的方法被调用顺序为： 调用public的service()方法。 在把参数分别转换为HttpServletRequest和HttpServletResponse后，这个public的service()方法调用protected的service()方法。 根据HTTP请求方法的类型，protected的service()调用doXXX()方法之一。 Servlet请求和响应相关 HttpServletRequest接口 声明： public interface javax.Servlet.http.HttpServletRequest implements ServletRequest Servlet是请求驱动 Web容器收到一个对Servlet的请求时，就把这个请求封装成一个HttpServletRequest对象 然后把对象传给Servlet的相应服务方法。 获取客户端信息主要是通过调用ServletRequest接口或者子接口HttpRequest提供的方法。 接口中的主要方法如表12-4所示。 HttpServletResponse接口 声明： public interface javax.Servlet.http.HttpServletResponse implements ServletResponse HttpServletResponse接口存放在javax.Servlet.http包内 代表了对客户端的HTTP响应。 HttpServletResponse接口给出了响应客户端的Servlet方法。它允许Serlvet设置内容长度和回应的MIME类型，并且提供输出流ServletOutputStream。 HttpServletResponse接口的主用方法如表12-5所示。 Servlet配置相关 环境API 接口ServletConfig和ServletContext可以获得Servlet执行环境的相关数据。 ServletConfig对象接收Servlet特定的初始化参数， ServletContext接收webapp初始化参数。 mServletConfig用作配置Servlet。 这两个类都在javax.Servlet包中 ServletConfig接口 声明：public interface javax.Servlet.ServletConfig ServletConfig接口用作配置Servlet Servlet配置包括Servlet名字、Servlet的初始化参数和Servlet上下文。 Servlet引擎通过init(ServletConfig config)方法和GenericServlet.getServletConfig()方法获得ServletConfig对象。 这个接口的主要方法如表12-6所示。 方 法 名 作 用 public String getServletName() 返回此 Servlet 实例的名称。该名称可能是通过服务器管理提供的， 在 Web 应用程序部署描述符中分配，或者对于未注册(和未命名)的 Servlet 实例，该名称将是该 Servlet 的类名称 public String getInitParameter(String name) 返回包含指定初始化参数的值的 String，如果参数不存在，则返回 null。该方法从 Servlet 的 ServletConfig 对象获取指定参数的值 public java.util.Enumeration getInitParameterNames() 以 String 对象的 Enumeration 的形式返回 Servlet 的初始化参数的名称， 如果 Servlet 没有初始化参数，则返回一个空的 Enumeration public ServletContext getServletContext() 返回对调用者在其中执行操作的 ServletContext 的引用。调用者用一 个 ServletContext 对象与 Servlet 容器交互 获取 Servlet 配置信息的例子 【例10-4】获取 Servlet 自身信息、服务器端信息、客户端信息。 (1) 编写 Servlet 实例 ServletInfo.java，代码如下： package com; import java.io.*; import java.util.*; import javax.servlet.*; // 获取自身信息的 Servlet public class ServletInfo extends GenericServlet { private Map initParams = new LinkedHashMap(); private String servletName = null; public void init(ServletConfig config) throws ServletException { super.init(config); // 获得初始化参数名称集合 Enumeration paramNames = getInitParameterNames(); // 获得所有参数的初始值 while (paramNames.hasMoreElements()) { String name = (String) paramNames.nextElement(); // 按参数名获得参数的初始值 String value = getInitParameter(name); initParams.put(name, value); } // 获得 Servlet 的名称 servletName = getServletName(); } public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=GB2312"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<body>"); out.println("<head>"); out.println("<title>获取 Servlet 自身的信息</title>"); out.println("</head>"); out.println("<body>"); out.println("<h2>Servlet 自身的信息： </h2>"); out.println("<h4>配置名称： " + servletName + "</h4><br>"); out.println("<h4>初始参数:</h4>"); out.println("<table width=\"350\" border=\"1\">"); out.println("<tr>"); out.println("<td width=\"175\">参数名</td>"); out.println("<td width=\"175\">参数值</td>"); out.println("</tr>"); Set paramNames = initParams.keySet(); Iterator iter = paramNames.iterator(); while (iter.hasNext()) { String name = (String) iter.next(); String value = (String) initParams.get(name); out.println("<tr>"); out.println("<td>" + name + "</td>"); out.println("<td>" + value + "</td>"); out.println("</tr>"); } out.println("</table>"); out.println("</body>"); out.println("</html>"); } } (2) 在 web.xml 文件中配置该 Servlet，代码如下： <web-app> … <!-- GetServerInfo definition --> <servlet> <display-name>ServletInfo</display-name> <servlet-name>ServletInfo</servlet-name> <servlet-class>com.ServletInfo</servlet-class> <init-param> <param-name>Purpose</param-name> <param-value>getServletInfo</param-value> </init-param> <init-param> <param-name>Date</param-name> <param-value>2018-03-27</param-value> </init-param> <init-param> <param-name>Developping tool</param-name> <param-value>MyEclipse</param-value> </init-param> </servlet> <!-- GetServerInfo mapping --> <servlet-mapping> <servlet-name>ServletInfo</servlet-name> <url-pattern>/showServletInfo</url-pattern> </servlet-mapping> … </web-app> <servlet>元素内部使用<init-param>子元素来为 ServletInfo 配置初始化参数。在 ServletInfo.java 的 init()方法中通过 Enumeration paramNames = getInitParameterNames();获得所有参数名字，进 而根据名字获取每个参数的值。 (3) 在 Tomcat 服务器下测试，在浏览器地址栏输入http://localhost:8080/ch10/showServletInfo可以看到 ServletInfo 的信息 【例 10-5】获取服务器信息。在 Servlet 实例中可以获取服务器端信息，并在客户端显示。 (1) 编写 Servlet 实例 ServerInfoServlet.java，代码如下： package com; import java.io.*; import java.util.*; import javax.servlet.*; public class ServerInfoServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet { private Map initParams = new LinkedHashMap(); private String servletName = null; public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=GB2312"); PrintWriter out = response.getWriter(); ServletContext sc = getServletContext(); out.println("<html><body><head>"); out.println("<title>获取服务器端信息</title>"); out.println("</head><body>"); out.println("<h2>服务器端信息： </h2>"); out.println("<table width=\"500\" border=\"1\">"); out.println("<tr>"); out.println("<td width=\"175\">站点名</td>"); out.println("<td width=\"325\">" + request.getServerName() + "</td>"); out.println("</tr>"); out.println("<tr>"); out.println("<td>端口号</td>"); out.println("<td>" + request.getServerPort() + "</td>"); out.println("</tr>"); out.println("<tr>"); out.println("<td>服务器类型</td>"); out.println("<td>" + sc.getServerInfo() + "</td>"); out.println("</tr>"); out.println("<tr>"); out.println("<td>支持 Servlet 版本</td>"); out.println("<td>" + sc.getMajorVersion() + "." + sc.getMinorVersion() + "</td>"); out.println("</tr>"); out.println("<tr>"); out.println("<td>服务器属性</td>"); out.println("<td>"); // 获得服务器属性集合 Enumeration attributes = sc.getAttributeNames(); while (attributes.hasMoreElements()) { String name = (String) attributes.nextElement(); out.println(name); } out.println("</td>"); out.println("</tr>"); out.println("</table>"); out.println("</body>"); out.println("</html>"); } } (2) 在 web.xml 文件中配置该 Servlet，代码如下： <web-app> … <!-- ServerInfoServlet definition --> <servlet> <description></description> <display-name>ServerInfoServlet</display-name> <servlet-name>ServerInfo</servlet-name> <servlet-class>com.ServerInfoServlet</servlet-class> </servlet> <!--ServerInfoServlet mapping --> <servlet-mapping> <servlet-name>ServerInfo</servlet-name> <url-pattern>/ServerInfo</url-pattern> </servlet-mapping> ... </web-app> (3) 在 Tomcat 服务器下测试，在浏览器地址栏输入http://localhost:8080/ch10/ServerInfo可以看到 ServerInfoServlet 的信息 Servlet中的会话追踪 会话是客户端发送请求，服务器返回响应的连接时间段。会话简单地将无状态的HTTP协议转换成高度集成的无缝活动线程，这使得Web应用程序感觉上就像一个应用程序。 Servlet引擎为每个连接分配了唯一的一个ID，并且在建立会话时将它分配给客户端 -> 客户端将该ID发送给所有后续请求的服务器 -> 通知会话结束。 引擎可以将每个请求映射到特定的会话。 javax.Servlet.http.HttpSession接口是Servlet提供会话追踪解决方案。 获得一个HttpSession实例对象 使用HttpServletRequest的getSession()方法访问HttpSession对象。如果系统没有找到与请求关联的会话ID，true表示返回新会话。false表示方法返回null。 语法为：HttpSession session = request.getSession(); 访问和设置与会话相关联信息，维护会话的状态 使用HttpSession的getAttribute()方法和setAttribute(String key，Object value)方法读取和设置当前请求会话数据(即对散列表的操作)，维护会话的状态。 语法为： public Object getAtrribute (string name); public void setAttribute(String name,Object value); `setAttribute`方法会替换任何之前的属性。如果不想被替换，则需要在设置之前使用`removeArrtibute(String key)`方法移除该属性。 废弃会话数据 只移除自己编写的的Servlet创建的数据：removeArrtibute(String key)方法 （web应用程序中删除）删除整个会话：invalidate()方法，可以用该方法注销用户。 （Web服务器中删除）将用户从系统中注销并且删除所有与该会话关联的会话：logout()方法。 会话超时时间间隔 getMaxInactiveInterval()方法和setMaxInactiveInterval()方法读取和设置在没有访问的情况下，会话保存的最长时间。秒为单位。负数表示会话从不超时。超时由服务器来维护。 HttpSession 接口 HttpSession 是 java.Servlet.http 包中的接口， 它封装了会话的概念。 其声明的语法格式如下：public interface javax.Servlet.http.HttpSession HttpSession 接口常用的方法: 类 别 方 法 说 明 getAttribute() 获得一个属性的值 属性 getAttributeNames() 获得所有属性的名称 removeAttribute() 删除一个属性 setAttribute() 添加一个属性 getCreationTime() 获得会话首次的构建时间 会话值 getId() 获得每个会话所对应的唯一标志符 getLastAccessedTime() 获得最后一次访问时间，是毫秒数 getMaxInactiveInterval() 获得最大活动间隔 isNew() 判断 session 是否新 setMaxInactiveInterval() 设置最大的不活动间隔，单位是秒 生命周期 invalidate() 将会话作废，释放与之关联的对象 HttpSession 进行会话控制的过程中使用的方法如下。 获得一个 HttpSession 实例对象。使用 HttpServletRequest 的 getSession()方法访问 HttpSession 对象。如果系统没有找到与请求关联的会话 ID， true 表示返回新会话， false 表示方法返回 null。语法格式如下： HttpSession session = request.getSession(); 在后台，系统从 Cookie 或 URL 重写附加的数据中提取出用户 ID。以 ID 为 key，遍历之前创建的 HttpSession 对象内建的散列表。如果找不到匹配的会话 ID，系统重新创建一个新的会话。默认情况下(不禁用 Cookie)还会创建一个名为 JSESSIONID，值为唯一标识用户表示会话 ID 的输出 Cookie。因为调用 getSession()方法会影响到后面的响应，所以只能在发送任何文档内容到客户端之前调用 getSession()方法。 访问和设置与会话相关联的信息，维护会话的状态。使用 HttpSession 的 getAttribute()方法和 setAttribute(String key， Object value)方法读取并设置当前请求会话数据(即对散列表的操作)，维护会话的状态。语法格式如下： public Object getAttribute (String name); public void setAttribute(String name,Object value); setAttribute()方法会替换任何之前的属性。如果不想被替换，则需要在设置之前使用 removeAttribute(String key)方法移除该属性。 废弃会话数据。 只移除自己编写的 Servlet 创建的数据： removeAttribute(String key)方法。 (在 Web 应用程序中)删除整个会话：可以用invalidate()方法注销用户。 (在 Web 服务器中)将用户从系统中注销并且删除所有与该会话关联的会话： logout()方法。 会话超时时间间隔。 getMaxInactiveInterval()方法和setMaxInactiveInterval()方法读取并设置在没有访问的情况下，会话保存的最长时间，秒为单位。负数表示会话从不超时，超时由服务器来维护。 Servlet上下文 ServletContext接口 声明：public interface javax.Servlet .ServletContext 定义了一个Servlet的环境对象，通过这个对象，Servlet引擎向Servlet提供环境信息。 一个Servlet的环境对象与它所驻留的主机是一一对应的，在一个处理多个虚拟主机的Servlet引擎中，每一个虚拟主机都必须被视为一个单独的环境。 获得ServletContext对象：通过ServletConfig.getServletContext()方法和GenericServlet.getServletContext()方法。 ServletContext对象是服务器上一个Web应用的代表，它的多数方法都是用来获取服务器端信息。 Servlet协作 声明：public interface javax.Servlet. RequestDispatcher 实现Servlet协作，它可以把一个请求转发到另一个Servlet。 定义接收来自客户端的请求并将它们发送到服务器上的任何资源（比如 Servlet、HTML 文件或 JSP 文件）的对象。 Servlet 容器可创建 RequestDispatcher 对象，该对象被用作包装位于特定路径上的服务器资源或通过特定名称给定的服务器资源的包装器。 得到RequestDispatcher对象： 利用ServletContext接口中利用ServletContext接口中getNamedDispatcher(String path)方法 ServletConfig config = getServletConfig(); ServletContext context = config.getServletContext(); RequestDispatcher dispatcher = context.getRequestDispatcher(String path); 利用ServletContext接口中getNamedDispatcher(String path)方法 RequestDispatcher dispacher= getServletConfig().getServletContext().getNamedDispatcher (String path); 利用ServletRequest接口中的getRequestDispatcher(String path)方法 RequestDispatcher dispatcher = request.getRequestDispatcher(String path); RequestDispatcher 声明：public interface javax.Servlet. RequestDispatcher 定义接收来自客户端的请求并将它们发送到服务器上的任何资源（比如 Servlet、HTML 文件或 JSP 文件）的对象。Servlet 容器可创建 RequestDispatcher 对象，该对象被用作包装位于特定路径上的服务器资源或通过特定名称给定的服务器资源的包装器。 forward()控制页面跳转 public void forward(ServletRequest request, ServletResponse response) throws ServletException, java.io.IOException 该方法将请求从一个 Servlet 转发到服务器上的另一个资源（Servlet、JSP 文件或 HTML 文件）。此方法允许一个 Servlet 对请求进行初步处理，并使另一个资源生成响应。在将响应提交到客户端之前（在刷新响应正文输出之前），应该调用 forward。如果已经提交了响应，则此方法抛出 IllegalStateException。在转发之前，自动清除响应缓冲区中未提交的输出。 include()控制页面包含 include()用于在响应中包含其他资源(Servlet，JSP页面或HTML文件)的内容。即请求转发后，原先的Servlet还可以继续输出响应信息，转发到的Servlet对请求做出的响应将并加入原先Servlet的响应对象中 Servlet异常相关 在Servlet中有两种异常处理机制：声明式异常处理和程序式异常处理。 声明式异常处理 声明式异常处理是在web.xml文件中声明对各种异常的处理方法,这是通过<error-page>元素来声明的。<error-page>有两个子元素：子元素<error-code>指定HTTP协议的错误代码或<exception-type>指定异常的类；<location>指定用于响应HTTP错误代码的资源路径，该路径相对于Web应用程序根路径的位置，必须以(/)开头。 声明异常处理的方法： 编写产生异常的Servlet 编写错误处理页面 配置<error-page>元素 运行效果 程序式异常处理 在javax.Servlet包中定义了两个异常类，ServletException和UnavailableException。 javax.Servlet.ServletException类 ServletException类定义了一个通用的异常，常用在init()、service()和doXX()方法中抛出异常，它提供了4个构造方法和1个获得异常原因的方法 javax.Servlet.UnavailableException类 UnavailableException类是ServletException类的子类，是当Servlet或者Filter暂时或永久不能用时，就会抛出这个异常。

JSP中的文件操作：数据流、File类、文件浏览、目录操作、上传下载 ■ 学习目标 了解JSP中的数据流 了解File类 掌握文件相关的操作： 文件读写、上传、下载等 创建、删除目录等 了解SmartUpload上传包的用法 了解Commons FileUpload上传包的用法 目录： 数据流和File类 数据流 File类 读写文本文件 文件的浏览 创建和删除目录 文件的上传和下载 使用jspSmartUpload上传包 1、初始化SmartUpload对象 2、上传 3、存储文件 使用Commons-FileUpload上传包 文件可以永久地存储信息，从本质上讲文件就是存放在盘上的一系列数据的集合。应用程序如果想长期保存数据，就必须将数据存储到文件中，这就涉及到文件的操作。而在编写网站应用程序的过程中，有许多地方要对文件进行操作。 本章将要对JSP中文件操作的应用作一些介绍，如读写文件、上传下载文件、创建删除目录等。 数据流和File类 数据从一个输入源获得。程序的结果被送到输出目的地。这些源和目的地被广泛地定义。例如一个网络连接器，内存缓冲区或磁盘文件可以被输入/输出类熟练地操作，这些外设都由相同的抽象体流(stream)来处理。 流，是一个生产或消费信息的逻辑实体。流通过输入/输出系统与物理设备相连。尽管与之相连的实际的物理设备各不相同，所有的流都以同样的方式运转。 数据流 Java定义了两种数据流：字节流和字符流。 字节流：为处理字节式输入/输出提供了丰富的环境，其处理单元为1个字节，操作字节和字节数组。 InputStream：抽象类是表示字节输入流的所有类的超类。 需要定义 InputStream 的子类的应用程序必须始终提供返回下一个输入字节的方法。 OutputStream：此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。 需要定义 OutputStream 子类的应用程序必须始终提供至少一种可写入一个输出字节的方法 字符流：提供了处理任何类型输入/输出操作的足够的功能，字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串。 Reader：用于读取字符流的抽象类。 子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。用于读取字符流的抽象类。 Writer ：写入字符流的抽象类。 子类必须实现的方法仅有 write(char[], int, int)、flush()和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 一个字节流可以和其他任何类型的对象并用，包括二进制数据。这样的多功能性使得字节流对很多类型的程序都很重要。字节流以InputStream和OutputStream为顶层。InputStream(输入流)是一个定义了流式字节输入模式的抽象类，该类的所有方法在出错条件下引发一个IOException异常。OutputStream(输出流)是定义了流式字节输出模式的抽象类，该类的所有方法返回一个void值并且在出错情况下引发一个IOException异常。 字符流以Reader和Writer为顶层。Reader是定义Java的流式字符输入模式的抽象类，该类的所有方法在出错情况下都将引发IOException异常。Writer是定义流式字符输出的抽象类，所有该类的方法都返回一个void值并在出错条件下引发IOException异常。 File类 文件和目录路径名的抽象表示形式。 用户界面和操作系统使用与系统相关的路径名字符串来命名文件和目录。此类呈现分层路径名的一个抽象的、与系统无关的视图。 抽象路径名有两个组件： 一个可选的与系统有关的前缀 字符串，比如盘符，/表示 中的根目录，\\ 表示 Microsoft Windows UNC 路径名， 零个或更多字符串名称 的序列。 File类：用于文件系统操作的类 Java内建的用来操作文件目录的类File，该类提供新增、删除与修改等操作文件相关功能所需的方法成员。 File类没有指定信息怎样从文件读取或向文件存储； 它描述了文件本身的属性。 File对象用来获取或处理与磁盘文件相关的信息，例如权限、时间、日期和目录路径。另外，File还浏览子目录层次结构。 可以用来生成File对象的构造函数如下: File(String directoryPath) File(String directoryPath, String filename) File(File dirObj, String filename) 其中，directoryPath是文件的路径名，filename是文件名，dirObj是一个指定目录的File对象。 第一个构造函数通过全路径—路径文件名来创建对象，pathname可以是绝对路径也可以是相对路径。 第二个构造函数通过父目录和文件名来创建对象，filename是不含路径的文件名。 第三个构造函数也是通过父目录和文件名来创建对象，但父目录由一个File对象提供。 注意：文件的路径有两种形式，即绝对路径和相对路径。绝对路径包含它所指定的文件的完整路径信息，根据绝对路径就可以惟一定位一个文件。而相对路径是针对“其他某个路径”而言的，这个路径和相对路径共同定位一个文件的位置。 File类位于命名空间java.io，因此在JSP网页使用File类之前，必须利用以下的程序代码，将此命名空间载入： <%@ page import =“java.io.*" %> 方 法 说 明 isDirectory() 返回一个布尔值，true表示为目录，false则表示是文件，借以判断File对象所参考的路径是否为目录 isFile() 返回一个布尔值，true表示为文件，false则表示是目录，借以判断File对象所参考的路径是否为文件 canRead() 返回布尔值，true表示此为允许读取的文件 canWrite() 返回布尔值，true表示此为允许写入的文件 exists() 返回一个布尔值，true表示参考的文件目录存在 getName() 取得File对象所参考的路径底下的目录或文件名称 getPath() 取得File对象所参考的路径字符串 toString() 将File对象转换成为以字符串类型的名称表示 equals() 比较两个File对象是否相等 由于File对象本身仅仅只是参考一个特定的路径，因此上述的路径及文件参数也可能代表一个不存在的文件，在进行文件的操作之前，可以利用exists方法，查看文件是否存在，以判断是否进行相关的文件操作，这一点非常重要，若是尝试存取一个不存在的文件，会让系统产生一个错误的例外对象。 【例7-1】下面的范例演示一个查看文件相关性质的JSP网页实例。查看文件内容(usingFile.jsp) <%@page contentType="text/html"%> <%@page pageEncoding="GB2312"%> <%@page import="java.io.*"%> <html> <head><title>运用 File 对象</title></head> <body> <% // 先在 C：盘下创建文件夹 String thePath="C:\\ch07\\theFile"; File myDir = new File(thePath); File myFile = new File(thePath,"testFile.txt" ); File mynotExistFileFile = newFile(thePath,"notExistFile.txt" ) ; out.println("目录"+thePath+"是否存在:"+myDir.exists()+"<BR>" ); out.println("文件"+thePath+"\\testFile.txt 是否存在:"+myFile.exists()+"<BR>"); out.println("文件"+thePath+"\\notExistFile.txt 是否存在:"+mynotExistFileFile.exists()+"<BR>"+"<BR>"); out.println("文件"+thePath+"\\testFile.txt 是否可读取:"+myFile.canRead()+"<BR> ); out.println("文件"+thePath+"\\testFile.txt 是否可写入:"+myFile.canWrite()+"<BR>"); %> </body> </html> 一般文件的维护操作包含了新增、删除及列举等操作，File类本身也提供了相关功能的方法成员，列举如表所示 方 法 说 明 createNewFile() 创建一个新文件 delete() 删除指定的文件 renameTo() 重新命名文件 setReadonly 将文件对象所参照的文件设为只读 mkdir() 建一指定的目录 mkdirs() 建立指定路径底下的所有目录 1、创建文件与目录文件夹 File类提供一个名称为createNewFile()的方法成员，用以建立File对象参数所指定的文件，以下为引用此方法的程序代码范例片段： boolean blCreate = myFile.createNewFile() ; 由于createNewFile()返回一个布尔值，因此必须利用声明为boolean类型的变量存储运行结果，若是上式blCreate结果值为true，表示文件建立成功；若是false则表示文件建立失败，并且返回一个IOException例外对象，这个情形通常发生在指定的目录底下已经存在所要建立的文件，因此在建立文件之前查看其是否存在是非常重要的操作。 File类另外提供建立目录的方法成员mkdir，必须利用File类的实体对象引用这个方法以建立指定的目录，例如以下的程序代码 File myFile = new File(pathName); bool blMK = myFile.mkdir(); 其中的返回值意义同上述CreateNewFile方法，这里必须注意的是，由于引用这个方法所要建立的是一个目录，因此第1行程序代码中所指定的参数值必须是一个路径而非文件，同时指定建立的目录其上层目录的路径必须是存在的，例如下面的程序代码： boolean blNew; File myDir = new File("C:/testDir/newDir"); blNew = myDir.mkdir(); 其中mkdir()在C:/testDir目录下建立一个新的目录newDir，前提是C:/testDir目录必须存在，否则建立目录的作业将会失败。 另外一个类似mkdir()的方法为mkdirs()，这个方法不同的地方在于若是指定的目录路径不存在，则整个目录结构均将被创建，例如以下的程序代码： File myMkDirs = new File("C:/firstDir/secondDir/thirdDir"); blNew = myMkDirs.mkdirs(); 当网页运行该段程序代码的时候，其中C:/firstDir/secondDir/thirdDir这个路径的文件夹以及子文件夹，都会被建立。 2、删除文件与目录数据夹 删除文件或者是目录非常容易，只要引用File类所提供的方法成员delete() 即可。这个方法将会删除File对象本身所代表的文件或是目录，也就是建立File对象，指定路径底下的文件，或是建立对象时所输入的特定目录路径参数。 delete方法有一个布尔类型的返回值，若是成功删除指定删除文件，则返回值为true，当指定的文件不存在，或是指定的文件删除失败，则返回值为false。 另外必须特别注意的是，delete方法只能删除空目录，若是目录底下存在任何文件或是子目录，删除的操作会失败，并且返回一个代表删除目录失败的false布尔值。 读写文本文件 读写文件是文件操作最基本的内容。 读写文本文件所需的功能，主要由2个类所提供：FileWriter()及FileReader()。 FileReader()则用以读取文件中的数据。 语法如下：FileReader　myFileReader　= new FileReader(strFileName); 必须输入指定操作的文件完整路径名称或是File对象 FileWriter()负责将数据写入文件 语法如下：FileWriter myFileWriter = new FileWriter(fileName); 将数据写入文本文件之前，首先必须建立FileWriter对象，同时传入所要操作的文件完整路径名称字符串. 文件的浏览 【例7-3】浏览当前目录中文件与子目录的例子browserFile.jsp，例子执行后，会在浏览器中输出当前目录中的所有文件和子目录，并对文件和子目录进行统计。 <%@ page contentType="text/html;charset=gb2312"%> <%@ page import="java.io.*"%> <html> <head> <title>文件的浏览</title> </head> <body> <h1>文件的浏览</h1> <%int fcount=0,dcount=0;%> <% String path=request.getRealPath("/"); // 建立当前目录中文件的 File 对象 File d=new File(path); // 取得代表目录中所有文件的 File 对象数组 File list[]=d.listFiles(); out.println("<font color=#ff0000>" + path + "目录下的文件： </font><br>"); // 循环输出当前目录下的所有文件 for(int i=0;i<list.length;i++) { if(list[i].isFile()) { out.println(list[i].getName() + "<br>"); fcount++; } } out.println("<br><font color=#ff0000>" + path + "目录下的目录： </font><br>"); // 循环输出当前目录下的所有子目录 for(int i=0;i<list.length;i++) { if(list[i].isDirectory()) { out.println(list[i].getName() + "<br>"); dcount++; } } %> <hr> <h3>统计结果： </h3> <center> 文件总数： <%=fcount%><br> 目录总数： <%=dcount%><br> </center> </body> </html> 创建和删除目录 【例 7-4】编写一个有关目录的创建与删除的例子 Directory.jsp。本例的效果是，如果没有目录文件就创建一个新的目录文件，如果目录文件存在就删除该目录文件。代码如下： <%@ page contentType="text/html;charset=gb2312"%> <%@ page import="java.io.*"%> <html> <head> <title>目录的创建、检查与删除</title> </head> <body> <% String path = request.getRealPath(""); path = path + "\\text"; // 将要建立的目录路径 File d = new File(path); // 建立代表 uploadFile 目录的 File 对象，并得到它的一个引用 if(d.exists()) { // 检查 uploadFile 目录是否存在 d.delete(); out.println("uploadFile 目录存在，现被删除"); } else { d.mkdir(); // 建立 uploadFile 目录 out.println("uploadFile 目录不存在，现被建立"); } %> </body> </html> 文件的上传和下载 【例7-5】 在这里我们写一个简单的页面uploadfile.jsp，提供一个表单，用户从这里选择文件并把文件上载到服务器。 uploadfile.jsp <%@ page contentType="text/html;charset=gb2312" %> <html> <head><title>上传文件</title></head> <body bgcolor="#ffffff" text="#000000"> <p><b><font size=5>选择要上传文件</font></b></p> <form METHOD="POST" ACTION="uploadfile1.jsp" ENCTYPE="multipart/form-data"> <INPUT TYPE="FILE" NAME="FILE1" SIZE="30"><BR> <INPUT TYPE="SUBMIT" VALUE="开始上传"> </form> </body> </html> 在 uploadfile.jsp 页面中，需要注意的是： <FORM METHOD="POST" ACTION="uploadfile1.jsp" ENCTYPE="multipart/form-data"> 在该语句中， ENCTYPE="multipart/form-data"表示以二进制的方式传递提交的数据。 现在创建处理信息的页面 uploadfile1.jsp， 实现获取文件里面的信息并保存在指定的文件夹upload 内的功能，代码如下： uploadfile1.jsp <%@ page contentType="text/html; charset=GBK" %> <%@ page import="java.io.*"%> <%@ page import="java.util.*"%> <%@ page import="javax.servlet.*"%> <%@ page import="javax.servlet.http.*"%> <html><head><title>upFile</title></head> <body bgcolor="#ffffff"> <% int MAX_SIZE = 102400 * 102400; //定义上载文件的最大字节 String rootPath; // 创建根路径的保存变量 DataInputStream in = null; //声明文件读入类 FileOutputStream fileOut = null; String remoteAddr = request.getRemoteAddr(); //取得客户端的网络地址 String serverName = request.getServerName(); //获得服务器的名字 String realPath = request.getRealPath("/");//取得互联网程序的绝对地址 realPath = realPath.substring(0,realPath.lastIndexOf("\\")); rootPath = realPath + "\\upload\\"; //创建文件的保存目录 out.println("上传文件保存目录为"+rootPath); String contentType = request.getContentType(); //取得客户端上传的数据类型 try{ if(contentType.indexOf("multipart/form-data") >= 0){ in = new DataInputStream(request.getInputStream()); //读入上传的数据 int formDataLength = request.getContentLength(); if(formDataLength > MAX_SIZE){ out.println("<P>上传的文件字节数不可以超过" + MAX_SIZE + "</p>"); return; } byte dataBytes[] = new byte[formDataLength]; //保存上传文件的数据 int byteRead = 0; int totalBytesRead = 0; while(totalBytesRead < formDataLength){ //上传的数据保存在 byte 数组 byteRead = in.read(dataBytes,totalBytesRead,formDataLength); totalBytesRead += byteRead; } String file = new String(dataBytes); //根据 byte 数组创建字符串 String saveFile = file.substring(file.indexOf("filename=\"") + 10); //取得上传数据的文件名 saveFile = saveFile.substring(0,saveFile.indexOf("\n")); saveFile = saveFile.substring(saveFile.lastIndexOf("\\") + 1, saveFile.indexOf("\"")); int lastIndex = contentType.lastIndexOf("="); // 取得数据的分隔字符串 String boundary = contentType.substring(lastIndex + 1,contentType.length()); String fileName = rootPath + saveFile; int pos; pos = file.indexOf("filename=\""); pos = file.indexOf("\n",pos) + 1; pos = file.indexOf("\n",pos) + 1; pos = file.indexOf("\n",pos) + 1; int boundaryLocation = file.indexOf(boundary,pos) - 4; int startPos = ((file.substring(0,pos)).getBytes()).length;//取得文件数据的开始的位置 // 取得文件数据的结束的位置 int endPos = ((file.substring(0,boundaryLocation)).getBytes()).length; File checkFile = new File(fileName); //检查上载文件是否存在 if(checkFile.exists()){ out.println("<p>" + saveFile + "文件已经存在.</p>"); } File fileDir = new File(rootPath);//检查上载文件的目录是否存在 if(!fileDir.exists()){ fileDir.mkdirs(); } fileOut = new FileOutputStream(fileName); //创建文件的写出类 fileOut.write(dataBytes,startPos,(endPos - startPos)); //保存文件的数据 fileOut.close(); out.println("<P><font color=red size=5>" + saveFile + "文件成功上传.</font></p>"); } else { String content = request.getContentType(); out.println("<p>上传的数据类型不是是 multipart/form-data</p>"); } } catch(Exception ex) { throw new ServletException(ex.getMessage()); } %> <a href="uploadfile.jsp">继续上传文件</a> </body> </html> 代码中首先获取了上传文件的相关属性信息和文件内容，然后将获取的信息转换为指定格式的文件保存在服务器上。用 request 对象获取相关信息。 然后在保存文件之前使用 if(checkFile.exists())判断上传文件是否存在，使用 if(!fileDir.exists())判断保存的文件目录是否存在，判断结束后，使用fileOut.write(dataBytes,startPos,(endPos-startPos))语句保存文件信息。 让一个已知文件类型直接提示浏览者下载，而不是用它相关联的程序打开。以下用例子说明如何操作。创建两个 jsp 页面共同完成该功能，一个 Downfile.jsp 页面主要显示指定文件夹 upload 中要下载的文件对象，可以由客户选择其中之一；另一个文件 Downfile1.jsp 从服务器获取相关下载信息，把数据输出到客户端。 Downfile.jsp <%@ page contentType="text/html;charset=GB2312" %> <%@ page import="java.io.File" %> <%@ page import="java.io.FilenameFilter" %> <HTML> <head><title>显示现在文件</title></head> <body> <center> <h3>请选择要下载的文件</h3> <table> <% String path = request.getRealPath("/"); File file1 = new File(path, "\\upload"); String str[] = file1.list(); for (int i = 0; i < str.length; i++) { String ss = str[i]; out.println("<tr><td>" + ss + "</td><td><a href='Downfile1.jsp?name1=" + ss + "'>下载</a></td></tr>"); } %> </table> <center> </body> </HTML> 在该文件中，使用创建的 File 对象调用 list()方法，将指定文件夹 upload 中所有文件显示并可以选择下载保存。 Downfile1.jsp <%@ page contentType="text/html;charset=GB2312" %> <%@ page import="java.io.*" %> <% response.reset(); try { String str = request.getParameter("name1"); //获得响应客户的输出流： str = new String(str.getBytes("iso8859-1"), "gb2312"); String path = request.getRealPath("/"); path = path.substring(0, path.lastIndexOf("\\")); path = path + "\\upload\\"; File fileLoad = new File(path, str);//下载文件位置： response.reset(); OutputStream o = response.getOutputStream(); BufferedOutputStream bos = new BufferedOutputStream(o); byte b[] = new byte[500]; //输出文件用的字节数组,每次发送 500 个字节到输出流： response.setHeader("Content-disposition", "attachment;filename=" + new String(str.getBytes("gb2312"), "iso8859-1")); //客户使用保存文件的对话框 response.setContentType("application/x-tar");//通知客户文件的 MIME 类型： long fileLength = fileLoad.length();//通知客户文件的长度： String length = String.valueOf(fileLength); response.setHeader("Content_Length", length); FileInputStream in = new FileInputStream(fileLoad);//读取文件,并发送给客户下载: int n = 0; while ((n = in.read(b)) != -1) { bos.write(b, 0, n); } bos.close(); } catch (Exception e) { System.out.print(e); } response.reset(); %> 使用jspSmartUpload上传包 首先介绍如何安装所需的包，从网站上下载jspsmartupload.jar这个文件，将此文件放到网站WEB-INF\lib的文件夹下，接下来就可以在JSP网页当中使用此包。 在网页当中引用包的时候，必须以下式将其载入： <%@page import="com.jspsmart.upload.*" %> 上传文件的类是一种JavaBean组件，在使用前要先实例化，代码如下： <jsp:useBean id="theSmartUpload" class="com.jspsmart.upload.SmartUpload" /> 这段语法声明网页当中将以id值theSmartUpload为名称，引用SmartUpload这个组件，进行文件上传操作。 jspSmartUpload提供了相当丰富的功能，其中最简单的方式便是引用SmartUpload类的方法成员，其中包含了3个步骤：初始化、上传和存储文件。 1、初始化SmartUpload对象 在引用SmartUpload之前，必须对其进行初始化，方法initialize()用来完成初始化操作，语法如下(其中的theSmartUpload为SmartUpload的名称，pageContext则是初始化过程所需的对象)： theSmartUpload.initialize(pageContext) ; 初始化完成之后，就可以开始准备上传文件的操作。在此之前，还必须引用setTotalMaxFileSize()方法，设置所允许的文件大小，下面的程序代码设置一个最大为10MB的上传限制。 theSmartUpload.setTotalMaxFileSize(10*1024*1024) ; 2、上传 初始化完成之后，紧接着直接调用upload()，开始进行上传操作，其语法如下：theSmartUpload.upload() ; 需要注意的是，这个方法没有任何参数，它将表单上所有指定的文件直接上传。 3、存储文件 存储文件是上传的最后一个步骤，save()用来指定上传之后文件所要保存的位置，其语法如下(其中的fileSavePath代表上传之后的文件所要存储的位置)： fileCount=theSmartUpload.save(fileSavePath) ; save()方法完成文件的存储工作之后，便会返回一个表示上传文件数目的整数值，上式的fileCount用来存储这个值。 了解相关的基础用法，接下来要说明上传文件的表单，通常必须提供一个文件地址框，让用户输入所要上传的文件名称及完整路径，然后进行上传。一般来说，HTML文件输入方块标签，便可以提供所需的功能，如：<input type=file name=File1 size=50 /> 最后必须注意的是，用来容纳文件标签的表单，其编码格式必须设置为multipart/form-data，才能在文件传输的过程中进行正确的编码，如：<form action=actionpage enctype="multipart/form-data" > 【例7-6】现在来看看一个简单的范例，其中演示了最简单的文件上传功能(注：该代码运行前需要在C盘上创建upload文件夹) 文件上传(FileUpload.html)代码如下： <html> <head> <title>jspSmartUpload</title> <meta http-equiv="Content-Type" content="text/html; charset=gb2312"> </head> <body> upload file<br> <form action="upload.jsp" method="post" enctype="multipart/form-data"> <table> <tr> <td>name: <input type="file" name="file2" size="20"></td> </tr> <tr> <td><input type="submit" value="上传"></td> </tr> </table> </form> </body> </html> upload.jsp 代码如下： <%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %> <%@ page import="com.jspsmart.upload.*" %> <jsp:useBean id="mySmartUpload" scope="page" class="com.jspsmart.upload.SmartUpload"/> <html> <head> <title>上载附件 </title> <meta http-equiv="Content-Type" content="text/html; charset=gb2312"> </head> <body> <% //上载附件 try { mySmartUpload.initialize(pageContext); mySmartUpload.service(request, response); mySmartUpload.upload(); String fn = mySmartUpload.getFiles().getFile(0).getFileName(); mySmartUpload.save("c:\\upload");//文件保存的目录为 upload out.println("已经成功上传了文件"); } catch (Exception e) {%><a href=FileUpload.html>重新上传</a><% e.printStackTrace(); } %> <a href=FileUpload.html>继续上传</a> </body> </html> 使用Commons-FileUpload上传包 Commons FileUpload提供了相当丰富的功能，其中最简单的方式便是采用以下方法进行文件的操作。 DiskFileItemFactory：设置磁盘空间，保存临时文件。这只是一个具类。 DiskFileItemFactory factory=new DiskFileItemFactory(); ServletFileUpload：文件上传的核心类，此类接收request，并解析reqeust。 ServletFileUpload upload=new ServletFileUpload(factory); 进行文件解析后放在List中，因为这个类库支持多个文件上传，因此会把结果保存在List中。 List<FileItem>fileList=upload.parseRequest(request); 获取上传文件，进行分析。 File remoteFile = new File(new String(fileItem.getName().getBytes(),"UTF-8"));

JavaBean与表单处理 ■ 学习目标 了解Model1和Model2的概念 掌握JavaBean的概念 能在Jsp页面中熟练使用JavaBean 了解JavaBean的基本原理 掌握表单操作的相关知识 目录： 非MVC模式（Model1） 单纯的JSP页面编程 JSP+JavaBean编程 MVC模式（Model2） 剖析JavaBean 什么是JavaBean JavaBean的特征 典型JavaBean示意 在JSP中使用JavaBean JavaBean应用案例 <jsp:useBean> <jsp:getProperty> <jsp:setProperty> JavaBean生命周期 使用JavaBean处理表单数据 乱码解决方法汇总 非MVC模式（Model1） 单纯的JSP页面编程 定义：在单纯的JSP编程模式下，通过应用JSP中的脚本标志，可直接在JSP页面中实现各种功能。 优点：逻辑简单，容易理解 缺点： Java代码与HTML耦合 极难维护与扩展 不方便测试 JSP+JavaBean编程 定义：JSP负责表示显示和控制逻辑，JavaBean负责业务逻辑。JSP程序开发经典设计模式之一，适合中小型网站开发。 优点： 纯净的JSP页面 可重用的组件 方便进行调试 易维护易扩展 缺点：表现逻辑和控制逻辑仍未分离 JSP+JavaBean开发模式示意 MVC模式（Model2） MVC（Model-View-Controller，模型—视图—控制器）是一种程序设计概念，它同时适用于简单的和复杂的程序。 使用该模式可将待开发的应用程序分解为3个独立的部分：模型、视图和控制器。 Model（模型）：指的是业务逻辑的代码，是应用程序中真正用来完成任务的部分。 View（视图）：实际上就是程序与用户进行交互的界面，用户可以看到它的存在。视图可以具备一定的功能并应遵守对其的约束，在视图中不应包含对数据处理的代码，即业务逻辑代码。 Controller（控制器）：主要控制用户请求并作出响应。它根据用户的请求选择模型或修改模型，并决定返回怎样的视图。 MVC：JSP+Servlet+JavaBean编程 在JSP+JavaBean设计模式的基础上加入Servlet来实现程序中的控制层。 由Servlet来执行业务逻辑并负责程序的流程控制，JavaBean组件实现业务逻辑，充当着模型的角色，JSP用于页面的显示。 JSP+Servlet+JavaBean模式示意图 剖析JavaBean 什么是组件？ □ 独立的模块 □ 外界不了解其内部实现 □ 外界通过其提供的接口对组件进行访问 □ 可以重用 目前有代表性的组件技术 COM、COM+、JavaBean、EJB等 什么是JavaBean JavaBean是Java的可重用组件技术，实质是一种符合某些命名和设计规范的Java类。 JavaBean通常封装成为具有特定功能或者处理某个业务（如连接数据库，访问数据库等） 应用： JSP页面内可以访问JavaBean的对象以及它的方法。 在JSP的Web应用中集成JavaBean组件，由JavaBean中处理业务逻辑，然后在JSP中调用，而JSP页面着重网页界面的设计，可以实现业务逻辑和前台显示的部分分离。 使用JavaBean的好处 可以使得JSP页面变得清晰； 节省软件开发时间; 降低系统维护的难度 JavaBean的分类 可视的JavaBean：传统的JavaBean应用于可视化界面（如java图形界面中使用的按钮、文本框或列表框等等）。 非可视化的JavaBean：封装逻辑、封装数据，与JSP搭配使用。 JavaBean的特征 通常一个标准的JavaBean有以下特征（编写规范）: 一定使用了package语句进行打包 JavaBean是一个public类型的类 有一个无参数的构造方法 属性一般是私有的（即用private修饰） 对属性值xxx的获取有相应的getXxx()方法，并且此方法是公有的（即用public修饰） 若要获取的属性xxx为boolean类型则可以使用isXxx()方法 对属性值xxx的设置有相应的setXxx()方法，并且此方法也是公有的（即用public修饰） 典型JavaBean示意 UserBean.java package jsp.test; public class UserBean { private String userName; //用户名 private String pwd; //密码 private String name; //真实姓名 private String gender; //性别 private int age; //年龄 private String email; //电子邮件 private String tel; //固定电话 private String mphone; //手机 public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public String getMphone() { return mphone; } public void setMphone(String mphone) { this.mphone = mphone; } public String getName() { return name; } public void setName(String name) { this.name = name; } …… 在JSP中使用JavaBean 一个JavaBean编写完以后，需要将它编译成.class文件，并将此.class文件(连同其目录)放到本次应用的WEB-INF\classes目录之下。 注意：用Eclipse编写会自动地把.class放到相应的class目录下 需要使用以下几个动作元素 <jsp:useBean> 标签： 在网页中创建一个Bean对象 <jsp:setProperty> 标签：用于为Bean对象中的属性赋值 <jsp:getProperty> 标签：用于获取Bean对象中属性的值 JavaBean应用案例 <%@ page pageEncoding="utf-8" %> <%@ page contentType="text/html;charset=utf-8" %> <html> <jsp:useBean id="myBean" scope="request" class="bean.SampleBean"/> 属性sample的初始值：<jsp:getProperty name="myBean" property="sample"/> </p> <jsp:setProperty name="myBean" property="sample" value="Hello.JSP"/> 属性sample的新值：<jsp:getProperty name="myBean" property="sample"/> </html> package bean; public class SampleBean { private String sample = "Hello，World"; public void setSample(String s) { if(s != null) sample = s; } public String getSample() { return sample; } } <jsp:useBean> 该标签用来在JSP页面中创建一个JavaBean实例。 语法如下： <jsp:useBean id=“beanname” class=“package.class” [scope=“page|request|session|application”] /> 其中： id指定该JavaBean的实例变量的名称 scope指定该Bean变量的有效范围，指定Bean在哪种上下文内可用，可以取page，request，session和application四个值之一 page(是默认值)表示该Bean只在当前页面内可用(保存在当前页面的PageContext内) request表示该Bean在当前的客户请求内有效(保存在ServletRequest对象内) session表示该Bean对当前HttpSession内的所有页面都有效 application表示该Bean对所有具有相同ServletContext的页面都有效 scope很重要，是因为 <jsp:useBean> 只有在不存在具有相同id和scope的对象时才会实例化新的对象；如果已有id和scope都相同的对象则直接使用已有的对象，此时 <jsp:useBean> 开始标记和结束标记之间的任何内容都将被忽略 <jsp:getProperty> <jsp:getProperty> 标签用来获取Bean对象的属性值，并显示在页面上，其语法如下： <jsp:getProperty name=“beanname” property=“propertyname” /> name指出了要获取哪个bean的属性值，取值与useBean中 id值相同； property指出要获取该bean的哪个属性值 注意： 在使用 <jsp:getProperty> 之前，必须有由 <jsp:useBean> 所创建的Bean对象 如果使用 <jsp:getProperty> 来检索的值是空值，那么将会产生NullPointerException例外；如果使用程序段或表达式来检索值，那么在浏览器上出现的是将是null(空值) <jsp:setProperty> <jsp:setProperty> 设置Bean对象的属性的语法有多种： 1、简单bean属性设置 <jsp:setProperty name=“beanName” property=“propertyName” value=“propertyValue” /> 其中： name指出是在操作哪个bean property指出对该bean的哪个属性赋值 value用来指定给属性赋的值 例： <jsp:setProperty name="myBean" property="sample" value="Hello，JSP"/> 【例】一个描述学生的beans，在一个JSP页面中获得一个这样的beans，其有效范围是page。在JSP页面中使用动作标签设置、获取该beans的属性。 public class Student { String name=null; long number; double height,weight; public String getName() { return name; } public void setName(String newName) { name=newName; } public long getNumber() {return number; } public void setNumber(long newNumber) { number=newNumber; } public double getHeight() { return height; } public void setHeight(double newHeight) { height=newHeight; } public double getWeight() { return weight; } public void setWeight(double newWeight) { weight=newWeight; } } <%@ page contentType="text/html;charset=utf-8" %> <%@ page import="Student"%> <HTML> <BODY> <Font size=10> <jsp:useBean id="zhang" class="Student" scope="page" > </jsp:useBean> <jsp:setProperty name= "zhang" property="name" value="张小三" /> <P>名字是：<jsp:getProperty name= "zhang" property="name" /> <jsp:setProperty name= "zhang" property="number" value="1999001" /> <P>学号是：<jsp:getProperty name= "zhang" property="number" /> <% double height=1.70; %> <jsp:setProperty name= "zhang" property="height" value="<%=height+0.05%>" /> <P>身高是：<jsp:getProperty name= "zhang" property="height" />米 <jsp:setProperty name= "zhang" property="weight" value="66.65" /> <P>体重是：<jsp:getProperty name= "zhang" property="weight" />公斤 </FONT> </BODY> </HTML> 2、将单个属性值和输入参数关联 <jsp:setProperty name=“beanName” property=“propertyName” param=“paramName” /> 用param代替value表示将一个form表单中传入参数的值赋给bean的某个属性。 其中： name指出是在操作哪个bean property指出对该bean的哪个属性赋值 而param表示传入参数的名字 <html> <form action="test4.jsp"> 姓名：<input type="text" name="user"> 年龄：<input type="text" name="age"> <input type="submit"> </form> </html> package bean; public class TestBean { private String userName; private int age; public int getAge() { return age;} public void setAge(int age) { this.age = age; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } } <%@ page pageEncoding="utf-8" %> <%@ page contentType="text/html;charset=utf-8" %> <html> <jsp:useBean id="myBean" scope="request" class="bean.TestBean"/> <jsp:setProperty name="myBean" property="userName" param=“user”/> <jsp:setProperty name="myBean" property="age" /> <jsp:getProperty name="myBean" property="userName"/> <jsp:getProperty name="myBean" property="age"/> </html> 3、输入参数和bean属性值相同，可以简化 <jsp:setProperty name=“beanName” property=“propertyName” /> 这种用法将form表单中传入参数的值赋给bean的某个属性。 要求：form表单中参数的名称要与propertyName一致 4、将bean的所有属性与表单中参数关联 <jsp:setProperty name=“beanName” property=“*” /> 在这种用法中，JSP容器会一个个检查传入的参数，如果某个传入参数的名字和bean中某个属性的名字相同，则将该参数的值赋给bean中的属性。 使用这种方式可以一次为多个属性赋值 <html> <form action="test3.jsp"> 姓名：<input type="text" name="userName"> 年龄：<input type="text" name="age"> <input type="submit"> </form> package bean; public class TestBean { private String userName; private int age; public int getAge() { return age;} public void setAge(int age) { this.age = age; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } } <%@ page pageEncoding="utf-8" %> <%@ page contentType="text/html;charset=utf-8" %> <html> <jsp:useBean id="myBean" scope="request" class="bean.TestBean"/> <jsp:setProperty name="myBean" property=“*" /> <jsp:getProperty name="myBean" property="userName"/> <jsp:getProperty name="myBean" property="age"/> </html> JavaBean生命周期 scope 属性－表明JavaBean对象存在的范围，可为如下几个值： page（默认）、request、session、Application Page: 保存在pageContext对象中，有page范围的JavaBean实例只能在当前创建这个JavaBean的JSP文件中进行操作，这个实例只有在请求返回给客户端后或者转移到另外的JSP页面后才会释放掉。 page范围的JavaBean常用于进行一次性操作的JavaBean，这样的Bean用的最多，比如大部分表单提交，Bean的一些计算处理等都可以使用page范围的JavaBean Request 有request范围的JavaBean实例可以在处理请求所有JSP页面中都存在，这个对象只有在请求全部处理完毕后才会被释放掉 request范围的JavaBean常用于共享同一次请求的JSP页面中，比如判断用户登录功能，如果用户名密码合法就可以forward到一个合法页面中，否则就forward到一个出错页面，当然转移后的页面仍然能够得到用户的输入。 Session JavaBean对象是保存在session范围的 JavaBean实例的生存周期是整个session，只有当session过期后才能释放掉， 这样常用于共享同一session的JSP页面，比如购物车一般就是放在session中的或者登陆后的用户信息等也可以在session中 application JavaBean对象保存在application对象中， 有application范围的JavaBean对象的生存周期是整个application。这就意味着这样的JavaBean的生存周期是整个应用程序，当web Server停掉才会消失掉。 这样的常用于共享同一application的JSP程序中，比如程序中一些经常用到配置东西如数据库连接URL，全局的计数器或者是聊天室中人员信息等。 使用JavaBean处理表单数据 操纵HTML表单步骤 写JSP原文件，创建一些HTML的表单并命名。 在Java文件里写Bean，定义属性，GET或者SET方法来配合已经被指定好名字的表单。 回到JSP原文件中，增加 <jsp:useBean> 标签来创建一个或者调用一个现成的Bean。 增加 <jsp:setProperty> 标签设置HTML表单中需要SET方法的Bean的属性。 增加 <jsp:getProperty> 标签设置HTML表单中需要GET方法的Bean的属性。 如果需要处理更多的用户数据，用request对象。 eg1. 用户通过form表单提交数据，提交的数据被处理后，再在Jsp文件中显示处理 usingGetParameter.html让用户输入个人信息 usingGetParameter.jsp将其一一输出 eg2. 使用Jsp+JavaBean形式处理表单 showInfo.jsp让用户输入个人信息 服务器取得这些信息之后，利用show.java这个Javabean中的方法将其一一输出 乱码解决方法汇总 页面保存：<%@ page contentType="text/html;charset=utf-8" %> 提交表单页面：<%request.setCharacterEncoding("utf-8");%> cookie保存数据： 写入Cookie nameCookie = new Cookie("name", java.net.URLEncoder.encode(strname)); 读取<%=java.net.URLDecoder.decode(name)%> str.getBytes(“utf-8”)：目的是将str按utf-8取出。 new String(str.getBytes("utf-8"),"ISO-8859-1") 是将取出的utf-8 ，转换为ISO-8859-1（UNICODE）或者 new String (str.getBytes("ISO-8859-1"), “utf-8")

使用Cookie记录信息 学习目标 了解Cookie的基本概念 掌握在JSP中创建Cookie的方法 掌握在JSP中读写Cookie的方法 掌握设置Cookie存在期限的方法 了解Cookie的安全问题 目录： Cookie的概念和特性 什么是Cookie Cookie的常见用途 Cookie的安全问题 在JSP中使用Cookie 创建Cookie 读写Cookie 操作Cookie的常用方法 Cookie对象的应用实例 会话与会话追踪 实现会话追踪的4种方式 Cookies和URL重写 隐藏表单字段 使用内建session对象 内建session对象的生命周期 在web.xml中配置内建session对象的过期时间 设置内建session对象的过期时间 在Web开发中，Http连接无状态 Cookie的概念和特性 Cookie是设计交互式网页的一项重要技术，它可以将一些简短的数据存储在用户的计算机上，这些存放在用户计算机上的变量数据，称为Cookie。当浏览器向服务器提出网页浏览请求时，服务器根据存储在用户计算机上面的Cookie内容，针对此浏览器显示其专门的内容。 什么是Cookie Cookie是一个存储在浏览器目录的文本文件，当浏览器运行时，存储在RAM(随机存储内存)中。一旦用户从该网站或网络服务器退出，Cookie也可存储在计算机的硬驱上。当访客结束其浏览器对话时，即终止所有的Cookie。Cookie是在HTTP协议下，服务器或脚本可以维护客户工作站上信息的一种方式。 有些Cookie是临时的，有些则是持续的。临时的Cookie只在浏览器上保存一段规定的时间，一旦超过规定的时间，该Cookie就会被系统清除。持续的Cookie则保存在用户的Cookie文件中，下一次用户返回时，仍然可以对它进行调用。 Cookie必须在HTML文件的内容输出之前设置；不同的浏览器对Cookie的处理不一致；客户端用户如果设置禁止Cookie，则Cookie不能建立。一个浏览器能创建的Cookie数量最多为300个，并且每个不能超过4KB，每个Web站点能设置的Cookie总数不能超过20个。 Cookie是服务器发送给浏览器的体积非常小的纯文本信息，用户以后访问同一个Web服务器时浏览器会把他们原样发送给服务器。通过让服务器读取他原先保存到客户端的信息，网站能够为浏览者提供一系列的方便，例如在线交易过程中标识用户身份、安全需求不高的场合避免用户重复输入名字和密码、门户网站的主页制定、有针对性地投放广告，等等。 Cookie数据存储的功能由浏览器本身所提供，因此Cookie功能都必须要有浏览器的支持才行，一般通用的浏览器，例如IE都支持此功能。 当用户打开的网页中包含Cookie程序代码，此时服务器端会建立Cookie数据，然后将这个Cookie传送到客户端用户的计算机上。 当Cookie的数据传送至客户端的计算机后，便存储在浏览器中，此时服务器端的网页都可以访问这个Cookie的数据内容，而当用户关闭浏览器的时候，Cookie的数据便会消失。 若服务器在建立Cookie时设置了Cookie的存在时间期限，则用户在关闭浏览器后，Cookie的数据会以文本文件存储在用户的计算机上，只要在设置的时间期限内，当用户连接网页时，服务器端的网页均可使用先前Cookie的内容，等过了所设置的期限，Cookie中的数据便会自动被删除。 Cookie的常见用途 Cookie最根本的用途是帮助Web站点保存有关访问者的信息，是一种保持Web应用程序连续性(即执行“状态管理”)的方法。浏览器和Web服务器除了在短暂的实际信息交换阶段以外总是断开的，而用户向Web服务器发送的每个请求都是单独处理的，与其他所有请求无关。然而在大多数情况下，都有必要让Web服务器在用户请求某个页面时对其进行识别。 Cookie的作用就类似与名片，它提供了相关的标识信息，可以帮助应用程序确定如何继续执行。 Cookie的常见用途如： 网站浏览人数管理 按照用户的喜好定制网页外观 在电子商务站点中实现诸如“购物篮”等功能 Cookies给网站和用户带来的好处非常多： Cookie能使站点跟踪特定访问者的访问次数、最后访问时间和访问者进入站点的路径。 Cookie能告诉在线广告商广告被点击的次数 ，从而可以更精确的投放广告。 Cookie有效期限未到时，Cookie能使用户在不键入密码和用户名的情况下进入曾经浏览过的一些站点。 Cookie能帮助站点统计用户个人资料以实现各种各样的个性化服务。 Cookie的安全问题 Cookie欺骗 Flash的代码隐患 隐私，安全和广告 偷窃Cookie和脚本攻击 网站以外的用户无法跨过网站来获得Cookie信息。 在JSP中使用Cookie Cookie实质是服务器端与客户端之间传送的普通HTTP头，可以保存也可以不保存在客户的硬盘上。如果保存，是每个文件大小不超过4KB的文本文件，多个Cookie可保存到同一个文件中。从编程角度来看，在JSP中，Cookie就是Java提供的一个类。 response对象与request对象均提供与Cookie相关的方法成员，利用这些成员，用户可以很方便地访问指定的Cookie内容。 创建Cookie Cookie是由Javax.servlet.http.Cookie类所衍生出来的对象，建立Cookie的语法如下： Cookie objCookie = new Cookie(indexValue,stringValue) 从上面的语法中可以看出，一个Cookie对象必须包含有一个特定的indexValue索引值与字符串类型的数据内容stringValue。例如： <% Cookie c = new Cookie("mycookie","Cookie Test"); %> 建立了Cookie之后，该Cookie数据还必须传送到客户端，用addCookie()方法发送一个HTTP Header。传送的方式为：response.addCookie(objCookie)。 读写Cookie 写Cookie 对Cookie进行操作首先是将Cookie保存到客户端。在JSP中，利用response对象，通过addCookie()方法将Cookie写入客户端。其语法格式如下：response.addCookie(cookie); 例如： <% // 从提交的HTML表单中获取用户名 String username=request.getParameter(name); Cookie user_name=new Cookie("cookie_name",username); // 创建一个Cookie response.addCookie(user_name); %> 读Cookie 将Cookie保存到客户端，就是为了以后得到其中保存的数据。调用HttpServletRequest的getCookies得到一个Cookie对象的数组。其语法格式如下： Cookie[] 数组变量名＝request.getCookies(); 在客户端传来的Cookie数据类型都是数组类型，因此要得到其中某一项指定的Cookie对象，需要遍历数组来找。JSP将调用request.getCookies()从客户端读入Cookie，getCookies()方法返回一个HTTP请求头中的内容对应的Cookie对象数组。用户只需要用循环访问该数组的各个元素，调用getName()方法检查各个Cookie的名字，直至找到目标Cookie，然后对该Cookie调用getValue()方法取得与指定名字关联的值，可通过如下代码实现： <% Cookie[] Cookies＝request.getCookies(); // 创建一个Cookie对象数组 if(Cookies == null) out.print("none any Cookie "); else { for (int i=0;i< Cookies.length;i++) { // 设立一个循环，来访问Cookie对象数组的每一个元素 if(Cookies[i].getName().equals("cookie_name")) // 判断元素的值是否为username中的值 out.println(Cookies[i].getValue()+"<br>"); } } %> 操作Cookie的常用方法 设置Cookie的存在期限 Cookie可以保持登录信息到用户下次与服务器会话，换句话说，下次访问同一网站时，用户会发现不必输入用户名和密码就已经登录了。而还有一些Cookie在用户退出会话时就被删除了。 Cookie在生成时就会被指定一个Expire值，这就是Cookie的生存周期，在这个周期内Cookie有效，超出周期Cookie就会被清除。有些页面将Cookie的生存周期设置为0或负值，这样在关闭页面时，就马上清除Cookie，不会记录用户信息，更加安全。在默认情况下，Cookie是随着用户关闭浏览器而自动消失的，不过，Cookie也可以设置其存在的期限，让用户下次在打开网页时，服务器端仍然能够取得同样一个Cookie中的数据内容。 设置Cookie变量的有效周期的语法如下：Cookie 名称.setMaxAge(有效周期); 有效周期的时间以秒为单位，时间设置越大，表示Cookie对象的有效时间越长。 <% Cookie cookie = new Cookie(“username”,”liuyongpo”); cookie.setMaxAge(30 * 60); // 设置Cookie的存活时间为30分钟 response.addCookie(cookie); %> 自动保存的Cookie package ch06; import javax.servlet.http.*; public class LongLivedCookie extends Cookie { public static final int SECONDS_PER_YEAR = 60*60*24*365; public LongLivedCookie(String name, String value) { super(name, value); setMaxAge(SECONDS_PER_YEAR); } } 删除Cookie 要删除一个Cookie，必须使用sexMaxAge()方法，并将Cookie的存在期限设为0，语法如下： Cookie 名称.setMaxAge(0); 例如： <% Cookie killMyCookie = new Cookie("mycookie", null); killMyCookie.setMaxAge(0); killMyCookie.setPath("/"); response.addCookie(killMyCookie); %> 获取指定名字的Cookie值 下面的代码可以获取指定名字的Cookie值： public static String getCookieValue(Cookie[] cookies, String cookieName, String defaultValue) { for(int i=0; i＜cookies.length; i++) { Cookie cookie = cookies[i]; if (cookieName.equals(cookie.getName())) return(cookie.getValue()); } return(defaultValue); } Cookie对象的应用实例 从结果可见，同一台机器的不同客户端访问都可以访问服务器保存在本地机器的Cookie。新开启的页面中未保存JSESSIONID的信息。 JSESSIONID就是客户端用来保存sessionid的变量，一般对于Web应用来说，客户端变量都会保存在Cookie中，JSESSIONID也不例外。不过与一般的Cookie变量不同，JSESSIONID是保存在内存Cookie中的，在一般的Cookie文件中看不到。内存Cookie在打开一个浏览器窗口的时候会创建，在关闭这个浏览器窗口的时候也同时销毁。所以session变量不能跨窗口使用，要跨窗口使用就需要手动把JSESSIONID保存到Cookie里面。 只有通过JSESSIONID才能使session机制起作用，而JSESSIONID又是通过Cookie来保存的。如果用户禁用了Cookie，可以通过URL重写来实现JSESSIONID的传递。JSESSIONID通过这样的方式从客户端传递到服务器端，从而标识session。这样在用户禁用Cookie的时候也可以传递JSESSIONID来使用session，只不过需要每次都把JSESSIONID作为参数跟在URL后面传递。 response.encodeURL()和response.encodeRedirectURL()方法。 这两个方法会判断Cookie是否可用，如果禁用了会解析出URL中的JSESSIONID，并连接到指定的URL后面，如果没有找到JSESSIONID会自动生成一个。这两个方法在判断是否要包含JSESSIONID的逻辑上会稍有不同。在调用response.sendRedirect()之前，应该先调用response.encodeURL()和response.encodeRedirectURL()方法，否则可能会丢失session信息。 会话与会话追踪 session，中文经常翻译为“会话”，其本来的含义是指有始有终的一系列动作或消息，比如打电话时从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。 “会话”本义是指从一个浏览器窗口打开到关闭这个期间。 session的含义很多，session tracking(会话追踪)是指一类用来在客户端与服务器之间保持状态的解决方案，简单地说，当一个客户在多个页面间切换时，服务器会保存该用户的信息。 购物车的可能实现方式有哪些？ （==ABCD==） A. cookie B.session C.appliaction D.Database 实现会话追踪的4种方式 会话追踪的实现方式有下列4种方式： 使用持续Cookies(Persistent Cookies) 重写包含额外参数的URL(URL Rewriting) 建立含有数据的隐藏表单字段(Hidden Form Field) 使用内建session对象 使用内建session对象是目前最常用，也最有效的解决方案。 Cookies和URL重写 Cookie是一个小小的文本文件，它是将会话信息记录在这个文本文件内，每个页面都去Cookie中提取以前的会话信息。用户请求到达服务器后，先从Cookie中取出会话信息，这样就实现了会话追踪。 虽然Cookie强大且持续性高，但是由于有些用户因为担心Cookie对个人隐私的威胁，会关闭Cookie，一旦如此，便无法利用Cookie来达到会话追踪的功能。 URL重写是利用get方法，在URL的尾部添加一些额外的参数来达到会话追踪(session tracking)的目的，服务器将这个标识符与它所存储的有关会话的数据关联起来。URL后面用;来分隔JSESSIONID。 使用URL重写的优点是Cookie被禁用或者根本不支持的情况下依旧能够工作。但也有很多缺点： 必须对所有指向某用户的网站的URL进行编码 所有页面必须动态生成 不能使用预先记录下来的URL进行访问，或者从其他网站链接进行访问 隐藏表单字段 隐藏表单字段的方法，是利用HTML内的Hidden属性，把客户端的信息，在用户不察觉的情形下，偷偷地随着请求一起传送给服务器处理，从而实现会话跟踪的任务。然后将重要的用户信息，以隐藏字段的方式传送给服务器。 优点：session数据传送到服务器端时，并不像get方法会将session数据暴露在URL之上。 缺点：一旦session数据存储在隐藏字段中，仍然可以在用户直接查看HTML源文件的时候暴露数据。 使用内建session对象 传统的会话追踪方式使用比较麻烦，JSP使用内建的session对象可以非常方便地实现会话追踪，JSP的会话机制基于Cookie或URL重写技术，融合了这两种技术的优点，当客户端允许使用Cookie时，内建session对象使用Cookie进行会话追踪，如果客户端禁用Cookie，则选择使用URL重写。 获取session对象。例如把购物车作为属性存储在session中，在其他JSP页面中可以通过session再获得购物车。 <% // 在JSP页面中可以直接使用session ShoppingCart cart = (ShoppingCart)session.getAttribute("cart"); %> 内建的session对象是javax.servlet.http.HttpSession类的实例，如果在JavaBean或者Servlet中使用session就需要先从当前的request对象中取得，例如： <% // 得到用户session和购物车 HttpSession session = request.getSession(); ShoppingCart cart = (ShoppingCart)session.getAttribute("cart"); %> 读写session中的数据。向session中存入对象使用setAttribute方法，通过getAttribute方法读取对象。从session返回的值注意要转换成合适的类型，要注意检查结果是否为null。例如下面一段代码： HttpSession session=request.getSession(); SomeClass value=(SomeClass)session.getAttribute("someID"); if(value==null) { value=new SomeClass(…); session.setAttribute("someID",value); } 废弃session数据。调用removeAttribute废弃session中的值，即移除与名称关联的值。调用invalidate废弃整个session，即废弃当前的session。如果用户注销离开站点，注意废弃与用户相关联的所有session。 session的生命周期。由于没有办法知道HTTP客户端是否不再需要session，因此每个session都关联一个时间期限使它的资源可以被回收。 服务器使用URL重写。session默认使用Cookie技术进行会话追踪，如果客户端不接受Cookie的时候，服务器可以利用URL重写的方式将sessionID作为参数附在URL后面，此时须利用response对象内的encodeURL或encodeRedirectURL方法，这两个方法首先判断Cookies是否被浏览器支持；如果支持，则参数URL被原样返回，sessionID将通过Cookies来维持。否则返回带有sessionID的URL。同时需要注意的是，将session的ID以URL的编码方式进行时，需将每一页都编码，才能保留住session的ID。如果遇到没有编码的URL，则无法进行会话跟踪。 内建session对象使用示例。下面是一个记录同一用户到站次数的计数器： <%@ page contentType="text/html;charset=gb2312"%> <html> <title>session记录光临本页面的次数</title> <body> <% String heading = null; Integer accessCount = (Integer) session.getAttribute("accessCount"); if (accessCount == null) { accessCount = new Integer(0); heading = "Welcome, Newcomer"; } else { heading = "Welcome Back"; accessCount = new Integer(accessCount.intValue() + 1); } session.setAttribute("accessCount", accessCount); %> <H1> <% out.println(heading); %> </H1> <H2>以前进入页面次数: <% out.println(accessCount); %> </H2> </body> </html> 内建session对象的生命周期 内建session对象和Cookie一样拥有特定的生命周期。一般来说，内建session对象在一段时间没有作用就会自动失效，也就是服务器会自动控管session的失效时间。除此之外，也可以利用HttpSession类的setMaxInactiveInterval()方法来设定内建session对象的过期时间，服务器就会将session的资源释放掉。另外也可以使用HttpSession类的invalidate()方法，session不论设定多久的时间为过期，都将立即消失。 在web.xml中配置内建session对象的过期时间 session在一段时间没有作用就会自动失效，也就是服务器会自动管控session失效的时间，不过时间的长短通常因JSP容器所设定session失效的时间各有所不同，但是当设计者有特别需求时，也可以手动设定session过期时间。以tomcat为例，用户可以在web.xml中配置内建session对象的过期时间为30分钟。 <web-app> … <session-config> <session-timeout>30</session-timeout> </session-config> … </web-app> 设置内建session对象的过期时间 在服务器上，通过为在站点上的用户创建一个内建session对象保存该用户的信息。当用户第一次访问站点时，分配给用户一个session对象和一个单独的会话ID，这个ID是唯一的。在接下来的请求中，会话ID标识了这个用户，session对象作为请求的一部分发送给Servlet，Servlet能从session对象中读取信息，或者为其添加信息。 一个session可以利用isNew()方法来得知是否为一个新的session。所谓“新”的session，意思是说：它已被服务器产生，但是客户端尚未被告知。 由于没有办法知道HTTP客户端是否不再需要session，因此每个session都关联一个时间期限使它的资源可以被回收。setMaxInactiveInterval()和getMaxInactiveInterval()方法访问超时时间。当客户端完成一个(组)完整的交互过程后，可以使用invalidate()方法使服务器端的session失效，并清除session数据。 <%@ page contentType="text/html;charset=gb2312"%> <html> <title>session的生命周期</title> <body> <% //如果session是新的，设定session的初值 if (session.isNew()) { //设置session若十秒内没有活动则使session过期 session.setMaxInactiveInterval(10); //将此session time out的秒数加入过期时间中 session.setAttribute("expire", "10");%> <H1> <%out.print("session生命周期示例");%> </H1> <% out.print("设定session若十秒钟没有活动则使session过期"+session.getId());} else{ String str_expire_time=(String)session.getAttribute("expire"); //取得session构建的时间 long create_time=session.getCreationTime(); long access_time=session.getLastAccessedTime(); long current_time=System.currentTimeMillis(); long exist_time=(current_time-create_time)/1000; out.print("session已存在"+exist_time+"秒"); //如果session存在的时间超过20秒，则删除session if(exist_time>=20){ out.print("session时间已到...自动失效"); session.invalidate(); } } %> </body> </html> 在web.xml中，<session-timeout>30 </session-timeout>的单位是分钟，session.setMaxInactiveInterval(10)的单位是秒。

JSP内置对象：request、response、out、session、application等内置对象 ■ 学习目标 了解和掌握request请求对象方法 了解和掌握response响应对象方法 了解和掌握out 输出对象方法 了解和掌握session会话对象方法 了解和掌握application 应用程序对象方法 了解pageContext 页面上下文对象方法 了解config配置对象方法 了解page页面对象方法 了解exception例外对象方法 目录： JSP内置对象概述 request与response对象 out对象 session与application对象 config、pageContext以及page对象 exception对象 request对象 response对象 数据输出 缓冲区操作 session对象 session的概念 session对象的id session的有效期限 访问session中的数据 其它session对象的常用方法 application内置对象 存取application中的数据 使用 application 对象取得信息 其他JSP内置对象 pageContext对象 config对象 page对象 Java程序的功能主要是由Java包下的各个类在运行期所产生的对象所提供，并且应用这些对象组织构建程序所需的功能。 所谓JSP内置对象，是指在JSP网页环境之下，用户不需要声明而直接可以在JSP网页中使用的对象。 需要注意的问题是对象名的写法，包括这些对象方法的调用时也要书写正确，因为Java语言本身是大小写敏感的。 JSP内置对象概述 对象名称 衍 生 类 功 能 说 明 request javax.servlet.ServletRequest.HttpServletRequest 取得客户端数据与系统的信息 response javax.servlet.ServletReponse.HttpServletResponse 响应客户端信息 application javax.servlet.ServletContext 记录与处理上线者共享的数据 session javax.servlet.http.HttpSession 记录与处理上线者的个别数据 out javax.servlet.jsp.JspWriter 控制数据输出的操作 config javax.servlet.ServletConfig 取得JSP编译后的Servlet信息 pageContext javax.servlet.jsp.PageContext 存取与处理系统运行时期的各项信息 page java.lang.Object 代表目前的这个JSP网页对象 exception java.lang.Throwable 异常处理机制 request与response对象 JSP网页能够具备与用户互动的功能，关键在于request对象与response对象所提供的功能，request让服务器取得用户在网页表单中所输入的数据内容，response则提供服务器端程序响应客户端信息所需的功能。 request与response对象，是学习建构JSP网页交互功能最重要的两个内置对象，它们与HTML窗体标签有着相当密切的关系，下面章节对其将会有详细的说明与范例介绍。 out对象 JSP是一种动态的网页，其与HTML这一类静态文件的最大不同，在于同一份网页经过程序运算得以根据各种条件及情况进行呈现。out对象在这一方面提供相关的支持，服务器端利用out对象将所要输出的内容，在传送至网页的时候动态写入客户端。 session与application对象 application与session这两个对象，基本上被使用于记录和处理JSP网页之间的共享数据。 由于互联网本身是一种无联机状态的应用程序，当网页文件从网站服务器传送至客户端的浏览器之后，客户端和服务器端之间就没有任何联机状态存在，这个先天的缺陷，让网页无法存储应用程序运行期间所需的共享数据，application与session对象就是被设计用来解决这样的问题的。 config、pageContext以及page对象 这3个对象被用于存取JSP网页程序运行阶段的各种信息内容，其中config包含JSP网页文件被编译成为Servlet之后的相关信息、pageContext则是提供系统运行期间各种信息内容的存取操作功能，page代表目前正在运行的JSP网页对象。 JSP服务器端应用程序可以运用这3个对象，存取网页运行期间的各种环境信息，同时将当前网页当作对象进行操作，本章最后将对于这几个对象将会有详细的说明与探讨。 exception对象 exception为JSP提供用于处理程序运行错误的异常对象，此对象搭配功能强大的异常处理机制，运用于JSP网页的程序除错与异常处理上。 通过指定某一个页面为错误处理页面，把所有的错误都集中到那个页面进行处理，可以使整个系统的健壮性得到加强，也可以使程序的流程更加简单明晰。 request对象 request对象主要用于接收客户端通过HTTP协议连接传输到服务器端的数据。在客户端的请求中如果有参数，则该对象就有一个参数列表，它通常是HttpServletRequest的子类，其作用域就是一次request请求。 HTTP通信协议是客户与服务器之间一种提交（请求）信息与响应信息（request/respone）的通信协议。在JSP中，内置对象request封装了用户提交的信息，那么该对象调用相应的方法可以获取封装的信息，即使用该对象可以获取用户提交的信息。 request内置对象代表了客户端的请求信息，主要用于接受客户端通过HTTP协议传送给服务器端的数据。 Request对象封装请求信息的内容：请求的头信息（Header）、系统信息（比如：编码方式）、请求的方式（比如：GET或POST）、请求的参数名称和参数值等信息； 还提供了获取cookie和session等对象、数据的方法。 通过request对象可以获取用户的请求信息 request对象包括很多方法，最主要的有getParameter(String name)、getParameterValues(String name)、getParameterNames()等方法。 String getParameter(String name) 用表单和超链接、传递参数的时候，使用getParameter(String name)接收传递的参数。 返回给定参数的值，当传递给此方法的参数名没有实际参数与之对应时，返回null。 使用getParameter(String name)取得的值都是字符串类型，需要转换为需要的类型。 Enumeration getParameterNames() 返回值类型：枚举类型Enumeration。 得到客户端提交的所有参数的名称。 【例4-1】中的代码段通过循环可获取客户端提交的所有参数的名字 <% Enumeration enu = request.getParameterNames(); while (enu.hasMoreElements()) { String parameterName = (String) enu.nextElement(); String parameterValue = (String) request.getParameter(parameterName); out.print("参数名称：" + parameterName + "<BR>"); out.print("参数内容：" + parameterValue + "<BR>"); } %> void setCharacterEncoding(String chaen) 在form表单采用post方式提交请求时，需要设置request对象的编码方式，保证能够正确地取到数据。 <%request.setCharacterEncoding("gbk");%> String [] getParameterValues(String name) 使用getParameterValues()能够取出变量的多个值。返回值类型：字符串数组 String[]。 能够取出变量的多个值，主要用于获取复选框的值或是下拉列表带multiple属性的值。 response对象 response对象用于将服务器端数据发送到客户端以响应客户端的请求。 response对象实现HttpServletResponse接口，可对客户的请求做出动态的响应，向客户端发送数据，如Cookie、HTTP文件头信息等，一般是HttpServlet.Response类或其子类的一个对象。 1、动态响应contenType属性 public void setContentType(String type) 当一个用户访问一个JSP页面时，如果该页面用page指令设置页面的contentType属性是text/html，那么JSP引擎将按照这种属性值作出反映。如果要动态改变这个属性值来响应客户，就需要使用response对象的setContentType(String s)方法来改变contentType的属性值。 设置输出数据的类型: text/html: 网页 text/plain: 纯文本 application/x-msexcel: Excel文件 application/msword: Word文件 2、设置刷新 public void setHeader(Stringname, String value) setHeader可以设置HTTP应答报文的首部字段和值；利用setHeader方法可以设置页面的自动刷新 例如： // 5秒种后自动刷新本页面 response.setHeader("Refresh","5"); // 5秒种后自动跳转到新页面 response.setHeader("Refresh", "5;URL=http://www.163.com"); 3、将客户端重定向到指定的URL void sendRedirect(String redirectURL) 在某些情况下，当响应客户时，需要将客户重新引导至另一个页面，可以使用response的sendRedirect(URL)方法实现客户的重定向。 例如 : response.sendRedirect(xxx.jsp?param1=aaa&...); sendRedirect和的区别： response.sendredirect()会在客户端呈现跳转后的URL地址；这种跳转称为客户端跳转。使用response.sendredirect()将重定向的URL发送到客户端，浏览器再根据这个URL重新发起请求。所以用这个方法时，浏览器地址栏上会显示新的请求资源的地址。并且此时的request，response都和第一次不一样，是重新产生的request，response。 使用完全是在服务器上进行，浏览器地址栏中的地址保持不变；这种跳转称为服务器端跳转。所以使用这个方法时没有产生新的request，response。 因为request没有变，在同一个请求内，可以用request来传递参数。 response.sendRedirect()想带参数的话，自己在地址中写成 xxx.jsp?param1=aaa&... 这种形式传递参数。能够使用标签向目标文件传送参数和值，目标文件必须是一个动态的文件，能够处理参数。 后面的语句不会被执行也不会继续发送到客户端，`response.sendRedirect()`后面的语句会继续执行（但是在页面上看不到），除非语句前面有return。 是在服务器的内部进行转换，只发送给客户端最后转到的页面，速度比较快； response.sendRedirect()需要服务器与客户端之间的往返，可以转到任何页面，包括网络有效域名。但速度比较慢。 4、设定状态显示码的方法 void setStatus(int n) 当服务器对请求进行响应时，发送的首行称为状态行。 response状态行包括3位数字的状态代码。 对5类状态代码的大概描述。 1XX：1开头的3位数字：主要是实验性质的 2XX：表示请求成功。 3XX：表示在请求满足之前应该采取进一步的行动。 4XX：当浏览器做出无法满足的请求时，返回该状态码。 5XX：表示服务器出现的问题。 200：正常 400：请求类型不匹配 401：请求需要HTTP认证 403：取得请求但拒绝服务 404：资源找不到 500：Java 程序抛出异常 可以通过response对象的setStatus(int n)方法来增加状态行的内容。 5、void addCookie(Cookie cookie) 添加一个Cookie对象，用来保存客户端的用户信息。可以通过request对象的getCookie()方法获得这个Cookie。 Cookie可以保存用户的个性化信息，从而对下一次访问提供方便。 out对象 out对象是javax.servlet.jsp.JspWriter的一个对象，它能把信息发送给客户端的浏览器。 out对象常用的方法是print()和println()，两者都在浏览器上显示信息。out对象最主要的功能在于将特定的数据内容搭配JSP程序代码动态输出至客户端的浏览器网页，在本书稍早的章节范例当中，我们已经初步看到了如何使用这个对象进行文本输出，这一节的内容将进一步说明out对象的相关特性。 数据输出 输出数据 newLine在网页中输出一行空白，例如：out.newLine(); print和println这2个方法成员被引用的时候均接受一个特定型态的参数，並且将这个参数输出到网页上： out.print("Hello JSP") ;、out.println("Hello JSP") ; 第一行程序代码将Hello JSP直接输出到客户端的缓冲区上，第二行则在输出Hello JSP之后紧接着加上一个换行。但这换行符在浏览器中会被忽略，要想真正在页面中实现换行，就需要在输出内容的最后加上换行标签<br>。 JSP程序利用out对象将网页内容输出时，都要和客户端做一次连接，并且会为此消耗不少的资源； 因此可以将要输出的内容放在一个固定大小的缓冲区中，等到缓冲区满时再一次性将内容送往客户端，这就要将autoFlush设为true，否则缓冲区满时将产生IOException错误。<%@ page autoFlush="true"%> 缓冲区操作 缓冲区是数据输出到浏览器之前，用来暂存数据的一块区域。 缓冲区操作 clear()、clearBuffer()和flush()使用于清空缓冲区內容。 clear() 使用于清空缓冲区中暂存的数据內容，缓冲区必需存在储存的数据 ，否则系统会引发一个IOException的例外 。 clearBuffer() 只负责清除的操作而不在乎是否存在任何数据。 flush() 除了清空缓冲区，还会进一步将所清空的数据内容输出到网页 。 【例4-10】out对象对缓冲区的操作outbuffer.jsp。 <% out.println("JSP程序设计<br>"); out.clearBuffer(); out.println("清华出版社<br>"); out.flush(); out.println("康牧编著<br>"); out.println("==========<br>"); out.println("剩余缓冲区大小："+ out.getRemaining()+"bytes<br>"); out.println("预设缓冲区大小："+ out.getBufferSize()+"bytes<br>"); out.println("AutoFlush："+out.isAutoFlush()); out.close(); out.print("hello"); %> 获取缓冲区状态 获取缓冲区当前状态的方法，分別为getBufferSize、getRemaining和isAutoFlush 。 getBufferSize返回一个表示当前缓冲区大小的整数值。 getRemaining所返回的整数值，则是当前缓冲区中剩余的空间大小。 isAutoFlush用以设定当数据储存量大于缓冲区剩余空间的时候，是否清空其中的数据內容。是则返回一个true，否则返回值为flase。 session对象 session(会话)对象是类javax.servlet.Httpsession的一个对象。session是从客户端连接服务器开始，直到与服务器断开连接为止。session对象用于保存每个与服务器建立连接的客户端的信息，session的ID保存于客户端的Cookie中，这个sessionID标识唯一的用户，与其他用户的sessionID不同。接下来针对session的概念与其中数据的处理方式来进行讨论。 session的概念 什么是Session： Session对象是一个jsp内置对象，它在第一个jsp页面被装载时自动创建，完成会话期管理。 从一个客户打开浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束，被称为一个会话。当一个客户访问一个服务器时，可能会在这个服务器的几个页面之间反复连接，反复刷新一个页面，服务器应当通过某种办法知道这是同一个客户，这就需要session对象。 当客户端用户向服务器提出请求打开网页后，若该网页中包含了为用户建立session的程序代码，则便会产生session 对象。 session对象的id session对象的id：当一个客户首次访问服务器上的一个jsp页面时，jsp引擎产生一个session对象，同时分配一个String类型的id号，jsp引擎同时将这个id号发送到客户端，存放在Cookie（Cookie是Web服务器保存在用户硬盘上的一段文本）中，这样 session对象和客户之间就建立了一一对应的关系。当客户再访问连接该服务器的其他页面时，不再分配给客户新的session对象，直到客户关闭浏览器后，服务器端该客户的session对象才取消，并且和客户的会话对应关系消失。当客户重新打开浏览器再连接到该服务器时，服务器为该客户再创建一个新的session对象。 session的有效期限 session和application相同，有其存在的期限。当发生以下四种情形其中之一时，session对象中的数据便会清空 ： 用户关闭目前正在使用的浏览器程序 关闭网页服务器 用户未向服务器提出请求超过预设的时间，Tomcat服务器预设为30分钟 运行程序结束session 访问session中的数据 建立session变量 在JSP中不需要特别设置程序代码来建立用户session，当程序使用了session对象时，便会自动建立session，而下面这行语句便是在session中新增变量数据的方式： session.setAttribute("变量名称",变量内容) 变量内容可为字符串或者其他对象类型，接着让我们来看看如何使用这个方法在session中设置变量数据： <% // 设置字符串 session.setAttribute("id","编号"); // 设置日期 session.setAttribute("expire",new Date(86400*10)); // 设置整数 session.setAttribute("level",new Integer(3)); %> 返回session中的变量 在session中设置了变量数据后，在其他的各个网页中便可使用getValue读取其中的内容，此方法所返回的数据类型为对象(Object)类型，语法如下： session.getAttribute("变量名称") 返回所有session中的变量名称 getValueNames()方法可以取出session中所有变量的名称，其结果为一个枚举类的实例。语法为： session.getAttributeNames() 清除session中的变量 removeValue()方法可以清除session中的变量数据，使用语法如下： session. removeAttribute("变量名称") 结束session 对于已经建立的session，可使用invalidate()方法将其结束，使用语法为： session.invalidate() 其它session对象的常用方法 方 法 说 明 getCreationTime() 返回session建立的时间，返回值为从格林威治时间开始算起到session建立时的毫秒数 getLastAccessedTime() 返回客户端对服务器端提出请求至处理session中数据最后的时间，若为新建立的session则返回–1 getMaxInactiveInterval() 返回客户端未对session提出请求而session开始停滞到自动消失之间所间隔的时间，返回值以秒为单位 isNew() 返回布尔值表示是否为新建的session SetMaxInactiveInterval (int interval) 设置客户端未对session提出请求而session开始停滞到自动消失之间所间隔的时间为interval，以秒为单位 session.getValue()方法所返回的数据类型为对象(Object)类型， 可以根据程序的需要转换为其他数据类型。 application内置对象 Application对象和Session对象相比，含义更加广泛。 什么是application: Application对象保存了一个应用系统中公有的数据，一旦创建了application对象，除非服务器关闭，否则application对象将一直得保存，并为所有客户共享。 服务器启动后就会自动创建application对象，当客户在所访问的网站的各个页面之间浏览时，这个application对象都是同一个，直到服务器关闭。所有客户的application对象都是同一个，即所有客户共享这个内置的application对象。 在JSP服务器运行时，仅有一个application对象，它由服务器创建，也由服务器自动清除，不能被用户创建和清除。 Application是一个所有在线用户共享的数据存取区，application中的变量数据在程序设定其值时被初始化，而当关闭网页服务器，或者超过预设时间而未有任何用户联机时自动消失。 存取application中的数据 建立application变量 除了系统预设的application变量外，要在application中建立变量数据则必须使用setAttribute()方法，建立application变量的语法如下： application.setAttribute(“变量名称”,变量内容)； <% // 设置字符串 application.setAttribute("id","编号"); // 设置日期 application.setAttribute("expire",new Date(86400*10)); // 设置整数 application.setAttribute("level",new Integer(3)); %> 返回application中的变量 在设置了application中的变量数据之后，接着在各个网页中便可利用getAttribute()方法来取得所设置的application变量内容，使用语法如下： application.getAttribute("变量名称") 此方法返回的数据内容为对象(Object)类型，延续前面的例子，若在其他的网页中加入下面的程序代码，则会在浏览器上显示objApp变量存储的内容： <% Object objApp = application.getAttribute("id"); out.println(id); %> 删除application变量 要删除application中的变量数据，必须引用removeAttribute()，使用的语法为： application.removeAttribute("变量名称") 返回所有application变量 getAttributeNames()方法会返回application中所有变量名称的集合对象，数据类型为Enumeration。 getAttributeNames()使用语法如下：application.getAttributeNames() 使用 application 对象取得信息 方 法 说 明 getMajorVersion() 返回服务器解释引擎所支持的最新 Servlet API 版本 getMinorVersion() 返回服务器解释引擎所支持的最低 Servlet API 版本 getMimeType(String file) 返回文件 file 的文件格式与编码方式 getRealPath(String path) 返回虚拟路径 path 的真实路径 getServerInfo() 返回服务器解释引擎的信息 其他JSP内置对象 pageContext对象 pageContext对象衍生于javax.servlet.jsp.PageContext类，该对象可以得到当前页面中所有其他的JSP隐含对象，例如getRequest()、getResponse()、getOut()和getSession()等，并提供了处理JSP各个对象与属性的方法。 pageContext 对象用于访问页面有效属性的方法及对应的说明： 方 法 说 明 Object getAttribute(String name) 返回当前页面内的name变量 void setAttribute(String name, Object obj) 设定当前页面内name变量值为obj void removeAttribute(String name) 删除当前页面内的name变量 HttpSession getSession() 取得页面的session对象 ServletContext getServletContext() 返回ServletContext对象，这个对象对所有的页面都是共享的。 javax.servlet.ServletRequest getRequest() 该方法的返回对象是JSP内置对象request对象，主要用于获取客户端的信息。 pageContext对象访问所有范围的属性操作与上面的方法类似，只是多了一个输入参数，例如设置变量值可以用setAttribute(String name,Object obj,int scope)，其中，scope取值可以为PAGE_SCOPE、REQUEST_SCOPE、SESSION_SCOPE和APPLICATION_SCOPE，分别代表页内有效、请求有效、会话有效和应用有效。pageContext对象还可以实现页面重定向和包含页面等功能。 pageContext.setAttribute(“usename”,name)设置的属性在当前页面有效。 pageContext.getSession().setAttribute(“session Value”,name)设置的属性在session中有效。 pageContext.getServletContext().setAttribute(“sharevalue”,name)设置的属性是对所有页面共享的。 config对象 config对象是类javax.servlet.ServletConfig的一个对象，它标识Servlet的配置。config对象主要用来取得服务器的配置信息，在JSP页面通过JSP Container进行初始化时被传递。 使用config对象，在修改需要在Web服务器中处理的变量时，不需要逐一修改JSP文件，而只需修改相应属性文件的内容，这样就大大简化了网络维护工作，而且能够避免由于忘记修改一些文件而造成的错误。 config对象常用的方法及对应的说明如下： 方 法 说 明 String getInitParameter(String name) 返回name所指定的初始参数 java.util.Enumeration getInitParameterNames() 返回所有初始参数 ServletContext getServletContext() 返回Servlet相关的上下文对象 String getServletName() 返回Servlet名称 page对象 page对象代表了正在运行的由JSP文件产生的类对象，此对象在JSP中并不常用 page对象是指向当前JSP程序本身的对象，有点像类中的this，参考【例4-9】。page对象其实是java.lang.Object类的实例对象，它可以使用Object类的方法，例如hashCode()、toString()等方法。page对象在JSP程序中的应用不是很广，但是java.lang.Object类还是十分重要的 JSP内置对象很多方法的返回类型是Object，需要用到Object类的方法 exception对象 exception对象是类java.lang.Throwable的一个对象，是为JSP提供用于处理程序运行错误的异常对象，可以配合page指令一起使用。参考【例4-10】，通过指定某一个页面为错误处理页面，把所有的错误都集中到那个页面进行处理，可以使整个系统的健壮性得到加强，也可以使程序的流程更加简单明晰。 必须在isErrorPage=“true”的情况下才可以使用exception对象。 exception对象常用的方法及对应的说明如下： 方 法 说 明 String getMessage() 返回错误信息 String getLocalizedMessage() 取得本地语系的错误提示信息 void printStackTrace() 以标准错误的形式输出一个错误和错误的堆栈 String toString() 该方法以字符串的形式返回一个对异常的描述 Throwable fillInStackTrace() 重写错误的堆栈

JSP基本语法：文件结构、脚本元素、指令元素、动作元素 学习目标： 掌握JSP的脚本元素：“隐藏注释”、“声明”、“表达式” 掌握JSP的指令元素：page、include 了解JSP的指令：taglib 掌握JSP的动作元素：<jsp:include>、<jsp:forward>、<jsp:param> 掌握include指令和<jsp:include>的区别 掌握JSP的动作元素：<jsp:useBean>、<jsp:getProperty> 和 <jsp:setProperty> 了解JSP的动作元素：<jsp:plugin> 目录： JSP文件的结构 创建第一个JSP文件 分析JSP文件的组成元素 JSP的脚本元素 隐藏注释 HTML注释 声明 脚本代码 表达式 JSP指令元素 Page指令 include指令 taglib指令 JSP动作元素 <jsp:include> 动作 <jsp:forward>动作 <jsp:param>动作 <jsp:useBean>、<jsp:getProperty> 和 <jsp:setProperty> 动作 1、<jsp:useBean>动作 2、<jsp:setProperty> 动作 3.动作 <jsp:plugin> JSP语法分为三种不同的类型： 脚本元素(SCRIPTING) 指令元素(DIRECTIVE) 例如： <%@ page import=“java.io.*” %> 动作元素(ACTION) 例如：<jsp:include>，<jsp:forward>，<jsp:getProperty> 等 JSP文件的结构 在传统的网页HTML(.htm、.html)中加入Java程序片断，就构成了JSP网页(*.JSP) Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序片断，然后将执行结果以HTML格式返回给客户端 创建第一个JSP文件 <%@ page contentType="text/html; charset=GBK"%> <html> <head> <title>我的第一个JSP程序！</title> </head> <body> <%!int number = 1;%> <%--这是声明一个变量 --%> <%!public int count() { return number++; }/*这是声明一个方法*/%> <% //JSP程序代码 out.println("Hello JSP!"); out.println("欢迎使用JSP交互式动态网页!!"); %> <br> <%="您是第" + count() + "个客人!"%> <br> </body> </html> 分析JSP文件的组成元素 helloJSP.jsp网页例子的结构 page指令 <%@ page contentType="text/html; charset=GBK" %> 这行代码为page指令，page是JSP的指令元素 批注 <%--这是声明一个变量 --%> <%/*这是声明一个方法*/%> <%// JSP程序代码%> <%…%>区块里的程序代码，程序执行的过程中，这些标识的程序代码都将被忽略。批注在程序中可有可无，然而为了程序日后便于维护，为程序加上良好的批注，是一个优秀的程序员必须养成的习惯。 数据输出 out对象进行指定字符串的输出。out是JSP中的默认对象，主要用来输出数据到客户端网页上。println则是out对象提供将字符串等数据输出网页的方法，接受一个特定类型的参数，并且将参数的内容输出到网页上。且其中每一行完整的程序语句，均必须以分号;作为结束。 <% out.println("Hello JSP "); out.println("欢迎使用JSP交互式动态网页!!"); %> 表达式也是脚本元素的一部分，在表达式中调用count方法，计算访问该页面的人数，并在页面上输出结果。 <%= "您是第" + count() + "个客人!" %> JSP原始代码中包含了JSP元素和Template(模板) data两类 Template data指的是JSP引擎不处理的部分，即标记<%……%>以外的部分，例如代码中的HTML的内容等，这些数据会直接传送到客户端的浏览器。 JSP元素则是指将由JSP引擎直接处理的部分，这一部分必须符合JSP语法，否则会导致编译错误。 JSP的脚本元素 JSP语句中的JSP脚本元素(Scripting Elements)用来插入一些Java语言程序代码，这些Java语言的程序代码将出现在由当前JSP页面生成的Servlet中，用来实现一些功能。包括： 隐藏注释(Hidden Comment)：<%--这是客户端不可见的注释 --%> HTML注释(HTML Comment)： <!--这是HTML注释--> 声明(Declaration)： <%! 这是声明%> 脚本代码(ScriptLets)： <%这是脚本段 %> 表达式(Expression)： <%=这是表达式 %> 在JSP中，主要的程序部分就是脚本元素，其中包括三个部分：声明（Declaration）、表达式（Expression）和脚本代码（Scriptlet）。从功能上讲，声明用于声明一个或多个变量，表达式将是一个完整的语言表达式，而脚本代码部分将是一些程序片断。 三个脚本元素的基本语法都是以一个“<%”开头，以一个“% >”结尾的。 声明：<%! this is a declaration %> 脚本代码：<% this is a scriptlet %> 表达式：<%= this is an expression %> 隐藏注释 JSP 语法格式如下：<%--comment for server side only--%> 隐藏注释标记的字符在JSP编译时会被忽略，它在希望隐藏或者注释JSP程序时是非常有用的。JSP编译器不会对<%--和--%>之间的语句进行编译，且该语句也不会显示在客户端的浏览器中。 隐藏注释内容可以写任意字符串除了“--%>”，如果必须要使用“--%>”，必须写成“--%\>”。 JSP语句中的隐藏注释镶嵌在JSP程序的源代码中，使用隐藏注释的目的并不是提醒用户，而是为了： 使程序设计人员和开发人员阅读程序方便，增强程序的可读性。 在增强程序可读性的同时，又顾及程序系统的安全性。如果用户通过Web浏览器查看该JSP页面，是看不到隐藏注释的内容的。 “隐藏注释”写在JSP程序代码中，但不发送到客户端。 HTML注释 HTML注释又称为显示注释，用户能够在客户端看到注释内容。 HTML注释语法格式如下：<!--注释[<%= 表达式 %>]--> 这种注释发送到客户端，但不直接显示在页面中，可以通过在某一JSP页面中右击，在弹出的快捷菜单中选择“查看源文件”命令查看其代码。 Scriptlets中的注释 由于Scriptlets包含Java代码，所以Java中的注释规则在Scriptlets中也适用。常用的Java注释使用//表示单行注释，使用/*……*/表示多行注释。 例如： <% …… //color表示颜色，通过它来动态控制颜色。 String color1="99ccff"; /* color表示颜色，通过它来动态控制颜色。 */ …… %> 声明 JSP中的声明(Declaration)用来定义一个或多个合法的变量（包括普通变量和类变量）和方法，并不输出任何的文本到输出流，声明的变量和方法将在JSP页面初始化时被初始化。 语法：<%! declaration;[declaration;] ... %> 注意：声明并不在JSP页内产生任何输出。它们仅仅用于定义，而不生成输出结果。要生成输出结果，应该用JSP表达式或脚本段。 JSP的声明语句用来声明将要在JSP中使用的变量和方法。变量和方法必须要声明，否则会出错。可以一次声明多个变量和方法，只要以;结尾即可，而且必须保证这些声明在Java中合法。 可以在JSP页面中定义方法或变量，这些方法和变量可被同一页面的其他代码访问。通常应该在JavaBean中定义方法，然而当代码只用于一页时，在网页内定义方法会更方便。 在JSP里，声明是一段Java代码，它用来定义在产生的类文件中类的属性和方法。声明后的变量和方法可以在JSP的任意地方使用，既可以声明方法，也可以声明变量。 在声明方法或变量时，应该注意以下方面： 声明必须以;结尾，在这一点上JSP语法中的Scriptlet语句有同样的规则，但是JSP语法中的表达式就不能以;结尾。 可以直接使用在<%@ page %>中包含进来的已经声明的变量和方法，不需要对它们重新进行声明。 一个声明仅在一个页面中有效，对于一些在每个页面都用得到的声明，最好把它们写成一个单独的文件，然后用<%@ include %>或语句把该文件及文件中的各个元素包含进来。 由于声明不会有任何输出，因此它们往往和JSP表达式或Scriptlet结合在一起使用。 JSP的变量可以分为局部变量和全局变量，在JSP中声明变量时，要注意变量的定义域。 在<% %>中声明的变量是局部变量，对外部函数不可见。 在<%！ %>中声明的变量是全局变量，这种变量在整个JSP页面内都有效。因为JSP引擎将JSP页面编译成Java文件时，将这些变量做为类的成员变量，这些变量的内存空间直到服务器关闭后才释放。 在<%！ %>中声明的方法，该方法在整个JSP页面内有效，但是在该方法内定义的变量只在该方法内有效。 脚本代码 JSP中的脚本代码是一段Java程序代码，这些代码在请求处理时在服务器端按顺序执行，脚本代码中如果使用了out对象，则会在客户端显示输出内容。 语法： <% code %> 注意： 1. 脚本段内不能定义方法 2. 脚本代码内只能定义局部变量 一个Scriptlet能够包含多个JSP语句、变量、表达式。有了Scriptlet，用户可以进行以下操作： 声明将要用到的变量 编写JSP表达式 使用任何隐含的对象和任何用声明过的对象 编写JSP语句 (如果使用Java语言，这些语句必须遵从Java Language Specification，即Java语言规范) 填写任何文本和HTML标记，注意JSP元素必须在Scriptlet之外 当JSP收到客户的请求时，Scriptlet就会被执行，如果Scriptlet有显示的内容，这些显示的内容就可以存放在out对象中。 <% String t=“test”; out.println(t); %> 注意： 1、在Scriptlet内部使用字符“%> ”，必须写成“%\>”。 2、脚本段内不能定义方法，这与声明不同，这是因为JSP引擎会把脚本段内的代码放到Servlet内的方法内，而方法是不能被嵌套定义的。 表达式 JSP能够计算表达式(Expression)，并向JSP页面输出表达式的运算结果 语法格式如下：<%= Java Expression %> 表达式元素表示的是一个在Java脚本语言中被定义的Java表达式，在运行后被自动转换成字符串，然后插入到表达式所在JSP文件的位置显示。表达式在运行时进行计算（页面被请求时），因此可以访问和请求有关的全部信息。 例如： <%= new java.util.Date() %> // 输出系统当前时间 <%= "Hello" %> // 输出Hello <%= 1＋3＋5 %> // 输出9 表达式的值在执行后会被自动转化为字符串类型进行输出，因此特定情况下需要进行数据类型的转换。 在JSP页面中使用表达式时请注意以下两点： 不能用分号;作为表达式的结束符，这一点与Scriptlet不同，同样的表达式用在Scriptlet中时，就需要以分号来作为一句Scriptlet语句的结尾 有时候表达式也能作为其他JSP元素的属性值，一个表达式能够变得很复杂，它可能由一个或者多个表达式组成，这些表达式的顺序是从左到右 注意： JSP的表达式中没有分号，除非在加引号的字符串部分才使用分号。 如Current time:<%=new java.util.Date()；%> 表达式实际上是被转换成out.println()方法中的内容。 如：<%= “hello world”%>相当于JSP页面中的：<%out.println(“hello world”); %> JSP指令元素 JSP的指令元素描述了JSP页面转换成JSP容器所能执行的Java代码的控制信息，如JSP页面所使用的语言、导入的Java类、网页的编码方式和指定错误处理页面等。JSP的指令元素独立于JSP页面接受的任何请求，且不产生任何页面输出信息。 JSP有三个指令元素，page、include和taglib。这些指令元素是针对JSP引擎的，并不会直接产生任何看得见的输出。它们包含在<%@ %>里。 两个主要的指令是page与include，taglib指令只有在使用标签库编程时才使用。 Page指令 Page指令用于定义JSP页面中的全局属性，它描述与页面相关的一些信息 JSP 语法格式如下： <%@ page [language="java" ] [extends="package.class" ] [import="{package.class | package.*},..." ] [session="true | false" ] [buffer="none | 8kb | sizekb" ] [autoFlush="true | false" ] [isThreadSafe="true | false" ] [info="text" ] [errorPage="relativeURL" ] [contentType="mimeType;charset=characterSet"|"text/html; charset=ISO-8859-1" ] [isErrorPage="true | false" ] %> Page指令的位置一般在JSP页面的开头，放在其他位置也是可行的，在一个JSP页面中可以有多个page指令。 language="java" language属性用来设定编写JSP网页使用的程序语法，目前处理JSP网页服务器中的JSP引擎都只支持Java，因此这个属性的默认值为Java。 extends="package.class" extends属性定义了由JSP页面产生的servlet的父类，标明JSP编译时需要加入的Java Class的全名。一般来说，这个属性不会用到，只是当需要实现一些特殊功能时比较方便。但是必须谨慎使用，除非用户对Java非常熟悉，因为它会限制JSP的编译能力。 import="{package.class|package.*},…" import属性用来指定所要加载的非预设Java包或类。默认加载的包类有java.lang.*、javax.servlet.*、javax.servlet.jsp.*和javax.servlet.http.* 载入非预设包，如 <%@page import="java.util.*, java.io.*"%> 一个import属性导入一个或多个Java类的定义，中间用逗号分隔。 session="true|false" 用来设定JSP网页的用户是否需要使用内建的HTTPsession对象与功能，属性值可为true或false，默认值为true。如果他为true，那么session是有用的；如果它为false，那么用户就不能使用session对象，以及定义scope=session的元素。 例如： <%@page session="false" %>、 <%=session.getId() %>，由于session被设置为false，无法使用session对象，因此该实例代码运行时将产生异常。 Session对象的类型是javax.servlet.http.HttpSession。 autoFlush="true|false" 设置如果buffer溢出，是否需要强制自动刷新输出缓冲。 默认值为true，表示输出正常，即当输出缓冲区满的时候，刷新缓冲区而不是抛出一个异常。 如果设置为false，这个buffer溢出就会导致一个意外错误的发生。 如果用户把buffer设置为none，那么就不能设置为false。 isThreadSafe="true|false" isThreadSafe属性的属性值可为true或false，缺省值是true，用来设置JSP文件是否能多线程使用。如果被设置为true，JSP能够同时处理多个用户的请求。JSP程序员要处理同步时共享的状态，以保证同步时确实是安全的。如果设置成false，则采用单线程模式控制客户端访问该页，一个JSP一次只能处理一个请求。 info="text" 设定一个代表当前这个JSP网页的信息，在执行JSP时将会被逐字加入JSP中 设定內容可在程序中使用getServletInfo()方法取回 设定info属性：<%@page info = "网页信息说明 … "%> errorPage="relativeURL" 设置处理异常事件的JSP文件 当前网页产生例外错误时，可取得与显示这个例外错误信息的另一个网页地址： <%@page errorPage="error.jsp"%> 当目前的网页发生例外错误时，网页被重定向到error.jsp，error.jsp中可直接使用exception对象来获取相关的错误信息。 isErrorPage="true|false" 设置此网页是否为错误处理页面可显示其它网页所产生的例外信息，默认值为false 如果设为true，则表明在该页面中可以获取异常对象exception，并通过该对象取得从发生错误的页面传出的错误信息，获取错误信息的常用方法如下： <%=exception.getMessage()%> contentType="mimeType[;charset=charcterSet]"|"text/html" contentType属性指定返回浏览器的内容类型，可用的属性值有text/plain(纯文本页面)、text/html(纯文本的HTML页面)、text/xml(XML页面)、applcation/x-msexcel(Excel文件)和applcation/msword(Word文件)等。 contentType中可以同时指定返回页面中所使用的字符编码，如charset=gbk等。常用格式如下： <%@page contentType ="text/html;charset=gbk"%> 无论把 <%@page%> 放在JSP文件的哪个地方，它的作用范围都是整个JSP页面。不过，为了JSP程序的可读性，以及养成良好的编程习惯，最好还是把它放在JSP文件的顶部。 注意： <%@ page %>指令作用于整个JSP页面，同样包括静态的包含文件。但是<%@ page %>指令不能作用于动态的包含文件，比如 可以在一个页面中使用多个<%@ page %>指令，但其中的属性只能用一次，除了import属性。因为import属性和Java中的import语句类似(参照Java Language，import语句引入得是Java语言中的类)，所以能多用几次 include指令 JSP中的include指令用来包含一个静态的文件，在解析当前页面时，这个文件中的代码会被复制到当前页面中。其语法格式如下： <%@ include file="relativeURL"|"相对位置" %> 其中，file="filename"这个被包含文件的路径名一般来说是指相对路径，不需要什么端口、协议和域名，例如conn.jsp、/beans/calendar.jsp等。如果路径是以文件名或目录名开头，那么这个路径就是正在使用的JSP文件的当前路径；如果这个路径以/开头，那么这个路径主要是参照JSP应用的上下关系路径。 <%@include%>指令将会在JSP程序代码被编译时，插入一个包含文本或者源代码的文件一起进行编译。 使用<%@include%>指令语句去包含某个文本或程序代码文件的过程是静态的，静态包含的具体含义是指这个被包含的文件将会被完整地插入到原来的主JSP文件中去，这个由主JSP文件包含的文件可以是JSP文件、HTML文件、文本文件或者是一段Java代码等。如果<%@include%>指令包含的文件时JSP文件，则该JSP文件将会被主JSP文件一起编译执行。 include指令将会在JSP编译时插入一个文件，而这个包含过程是静态的。所谓静态的是指file属性值不能是一个变量。例如，下面为file属性赋值方式是不合法的。 <%String url="header.htmlf";%>、 <%@ include file="<%=url%>"%> 也不可以在file所指定的文件后添加任何参数，下面的这行代码是不合法的。 <%@ include file="query.jsp?name=browser"%> include指令只能加载指定的外部文件，而且不能进行传递参数操作，如果外部文件只包含单纯的静态内容，使用include指令是理所当然的选择。 如果只是用include指令来包含一个静态文件，那么这个包含的文件所执行的结果将会插入到JSP文件中放<%@ include %>的地方。一旦包含文件被执行，那么主JSP文件的过程将会被恢复，继续执行下一行 在这个包含文件中不能使用<html>、</html>、<body>、</body>标记，因为这将会影响在原JSP文件中同样的标记，有时会导致错误 一旦引用了include指令，加载的外部文件内容将成为当前网页的一部分 当文件的内容包含中文时，Tomcat会显示为乱码；在外部文件中加入page指令，即可将中文正确显示出来 被包含文件可以是JSP文件、HTML文件、文本文件、inc文件等。如果包含的文件包含可执行代码，那么这个包含的文件的代码将会被执行 被包含的文件内容常常是代码段，因此代码片断的后缀名最好是以"f"(fragment的第一个字母)结尾，例如，".htmlf"、".jspf"等，从而避免JSP编译器对该文件内容进行语法检查。如果要改变filename的内容，不需重新编译JSP文件，所以此方式执行效率较高 由于使用include指令，可以把一个复杂的JSP页面分成若干简单的部分，这样大大增加了JSP页面的管理性。当要对页面进行更改时，只需要更改对应的部分就可以了。 taglib指令 taglib指令用来定义一个标签库及其自定义标签的前缀，其语法格式如下： <%@ taglib uri="tagLibraryURI" prefix="tagPrefix" %> 其中，属性uri(Uniform Resource Identifier，统一资源标识符)用来唯一地确定标签库地路径，并告诉JSP引擎在编译JSP程序时如何处理指定标签库中的标签；属性prefix定义了一个指示使用此标签库的前缀。例如： <%@ taglib uri="http://jspcentral.com/tags" prefix="public" %> <public:loop>…</public:loop>（使用public标签库中的loop标签） 以上指令，声明此JSP文件使用了自定义标签库，同时引用标签库，并且指定了它们的标签前缀。 例如，使用JSTL中数据库标签库的例子： <%@ taglib uri="http://www.sun.com.jsp/jstl/sql" prefix="sql" %> <sql:query var="books"> select * from books </sql:query> uri="tagLibraryURI" URI根据标签的前缀对自定义的标签进行唯一的命名，URI可以是以下的内容： 一个相对或绝对的路径 可以是标签库描述文件 prefix="tagPrefix" 表示标签在JSP中的名称。比如，在<>中的public，如果这里不写public，就是不合法的。 注意: (1) 必须在使用自定义标签之前使用<<%@tag%>>指令。 (2) 一个页面中可以多次使用taglib指令，但是前缀只能使用一次。 (3) 请不要用jsp, jspx, java, javax, servlet, sun和sunw做为前缀，这些已被Sun公司声明保留。 JSP动作元素 JSP动作元素和JSP指令元素不同，它是在客户端请求时动态执行的，是通过XML语法格式的标记来实现控制Servlet引擎行为的。JSP动作元素是一种特殊标签，并且以前缀jsp和其他的HTML标签相区别，利用JSP动作元素可以实现很多功能，包括动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码等。 <jsp:include> 动作 <jsp:include> 动作元素可以用来包含其他静态或动态页面，JSP有两种不同的包含方式：编译时包含和运行时包含。编译时包含只是将静态文件内容加到JSP页面中，其优点是速度快，如前面提到的<%@ include %> 指令。运行时包含指被包含的文件在运行时被JSP容器编译执行， <jsp:include> 的包含就是运行时包含，同时支持编译时包含。 <jsp:include> 有带参数和不带参数两种语法格式，分别如下所示： <jsp:include page="relativeURL" flush="true|flase"/> 和 <jsp:include page="relativeURL" flush="true|flase"> <jsp:param name="attributeName" value="attributeValue"/> <jsp:param … /> </jsp:include> 其中，relativeURL指代被包含文件的相对路径；属性flush为true时，表示实时输出缓冲区。<jsp:param> 用于在包含文件时传递一些参数，一个 <jsp:include> 中可以包含一个或多个<jsp:param> 动作元素。 JSP中include指令与include动作的区别： include指令是指把其它页面的JAVA代码（源码）加进来，跟本页面的代码合并在一起，相当于把源码从那个页面复制到本页面中来，然后再编译。并且由于本页面编译时已经包含了别的文件的源码，所以以后其它页面更改时，本页面并不理会，因为已经编译过了。 <jsp:include> 动作是指两个页面的代码运行完以后，再把被包含页面运行后的HTML结果加到本页面运行后的HTML结果中来。所以是运行时包含，并且还可以传递参数给被包含的页面。 和 <%@include%> 指令不同的是，<jsp:include> 动作包含的内容可以是动态改变的，它在执行时才确定，而前者包含的内容是固定不变的，一经编译，就不再改变。 语法 状态 对象 描述 <%@include file="...."%> 编译时包含 静态 JSP引擎将对所包含的文件进行语法分析 运行时包含 静态和动态 JSP引擎将不对所包含的文件进行语法分析 <jsp:forward>动作 <jsp:forward> 用于在服务器端结束当前页面的执行，并从当前页面跳转到其他指定页面。转向的目标页面可以是静态的HTML页面、JSP文件或Servlet类。这个元素的使用语法和 <jsp:include> 类似。 <jsp:forward> 既可以带参数也可以不带参数，语法格式分别如下： <jsp:forward page="relativeURL"/> ​ 和 <jsp:forward page="relativeURL"> <jsp:param name="attributeName" value="attributeValue"/> <jsp:param … /> </jsp:forward> <jsp:param … /> 指可以有多个 <jsp:param/> 标记。 1、page="relativeURL" 这里是一个表达式或是一个字符串用于说明你将要定向的文件或URL。这个文件可以是JSP程序段，或者其它能够处理request对象的文件(如asp，cgi，php)。 2、<jsp:param name="attributeName" value="attributeValue" /> 向一个动态文件发送一个或多个参数，这个文件必须是动态文件。如果想传递多个参数，可以在一个JSP文件中使用多个<jsp:param>；name属性指定参数名，value属性指定参数值。 <jsp:forward> 标签从一个JSP文件向另一个文件传递一个包含用户请求的request对象。 <jsp:forward> 标签以后的代码，将不能执行。 执行时查看浏览器地址栏，跳转后地址并没有发生变化。 <jsp:forward> 操作典型的使用就是登录。如进行权限验证的页面。当验证通过后，就把页面forword到登录成功的页面；当验证不通过时，就把页面forword到登录页面。 <jsp:param>动作 <jsp:param>元素用来传递参数给JSP程序，而由程序取得参数值，在程序中便是一个变量值。语法如下： <jsp:param name="attributeName" value="attributeValue"/> <jsp:param>元素使用时必须要设置其name属性，表示传递参数的名称，并通过value属性来设置该参数的值。JSP中设置元素的属性时必须加上双引号""。 在JSP程序中以如下的程序代码来获取该参数的值：request.getParameter("attributeName"); <jsp:param> 操作元素的使用必须配合 <jsp:include>、<jsp:forward> 以及 <jsp:plugin> 等元素。 <jsp:useBean>、<jsp:getProperty> 和 <jsp:setProperty> 动作 所谓JavaBean，其实是一个Java类，封装了一些常用的复杂的操作，一般可以使用JavaBean进行数据库连接、实现业务逻辑等，可以使得前台显示和后台业务逻辑更好地分离。使用JavaBean有利于代码重用，提高程序结构清晰性，这些Java类放在“WEB-INF/classes”目录内，可以使用进行实例化，并指定一个名字和作用域。 1、<jsp:useBean>动作 <jsp:useBean> 用来加载JSP页面中使用的JavaBean，其语法格式如下： <jsp:useBean id="beanInstanceName" scope="page|request|session|application" class="package.class" type="class_or_interface_name" beanName="ser_filename" > optional properties tags </jsp:useBean > id="beanInstanceName" 其中，id制定该JavaBean的实例变量的名称。 在所定义的范围中确认Bean的变量，使之能在后面的程序中使用此变量名来分辨不同的Bean，这个变量名对大小写敏感，必须符合所使用的脚本语言的规定，这个规定在Java Language规范已经写明。如果Bean已经在别的标记中创建，则当使用这个已经创建过Bean时，id的值必须与原来的那个id值一致；否则意味着创建了同一个类的两个不同对象。 scope="page|request|session|application" scope指定该Bean存在的范围以及id变量名的有效范围。缺省值是page，以下是详细说明： page-能在包含元素的JSP文件以及此文件中的所有静态包含文件中使用这个Bean，直到页面执行完毕向客户端发回响应或转到另一个文件为止 request-在任何执行相同请求的JSP文件中使用这个Bean，直到页面执行完毕向客户端发回响应或转到另一个文件为止。能够使用Request对象访问这个Bean，比如request.getAttribute(beanInstanceName)。其中beanInstanceName是Bean实例化的名字。 session从创建Bean开始，在任何使用相同session的JSP文件中使用这个Bean。这个Bean存在于整个session生存周期内，任何在分享此session的JSP文件都能使用同一Bean。注意在创建这个Bean的JSP文件中<%@ page %>指令中必须指定session="true"，否则可能会导致致命错误发生。可以使用session对象访问Bean，比如 session.getValue(beanInstanceName)。 application从创建Bean开始，在任何使用相同application的JSP文件中使用Bean。这个Bean存在于整个application生存周期内，任何在分享此application的JSP文件都能使用同一Bean。能够使用application对象访问这个Bean，比如application.getAttribute(beanInstanceName)。 class="package.class" class属性指定Bean的类路径和类名，不可接受动态值，不能是抽象的。 使用new关键字以及class构造器从一个class中实例化一个bean。这个class不能是抽象的，必须有一个公用的，没有参数的构造器。这个package的名字区别大小写。 如果该Bean不在作用域内，则将它实例化。也可以使用type属性并结合class属性来指定要将何种类型的Bean实例化。 如果使用类属性，不要同时指定beanName属性。 <jsp:useBean id="customer" class="com.myco.Customer"/> <%/* * 实例化bean: com.myco.Customer，并把对象存放在页面上下文(PageContext)中 * 该实例对象只能在当前页面通过customer访问 */%> … <%=customer.getName()%> beanName .class文件的名称、Bean包名或者包含该Bean的串行化文件（.ser文件）。仅当Bean不存在于指定的作用域时，才使用此属性。还必须使用类型属性来指定要将何种类型的Bean实例化。 BeanName属性不能与class属性一起使用。 此值区分大小写。 type 如果此属性与class或者beanName属性一起使用，它指定要实例化的Bean的类或接口。如果type属性未能与class或者beanName属性一起使用，则不将新的Bean实例化，而且type属性指的是已在作用域内的Bean。 此值区分大小写。 Properties tags <jsp:setProperty> 标记列表，它设置实例化的Bean的初始特性值。 <jsp:useBean id="connection" class="com.myco.myapp.Connection" scope="session"> <jsp:setProperty name="connection" property="timeout" value="33"> <jsp:setProperty name="connection" property="maxUsers" value="100"> </jsp:useBean> 2、<jsp:setProperty> 动作 <jsp:setProperty> 用于设置Bean的属性值，语法格式如下： <jsp:setProperty name="beanInstanceName" { property="*"| property="propertyName"[param="parameterName"]| property="propertyName" value="{string|<%=expression%>}" } /> <jsp:setProperty> 用于设置Bean的属性值，有以下两种用法。 可以在 <jsp:useBean> 元素的外面(后面)使用 <jsp:setProperty>。 <jsp:useBean id="myName" … /> … <jsp:setProperty name="myName" property="someProperty" …/> 此时，不管 <jsp:useBean> 是找到了一个现有的Bean，还是新创建了一个Bean实例， <jsp:setProperty> 都会执行。 把<jsp:setProperty> 放入 <jsp:useBean> 元素的内部。<jsp:useBean id="myName" … > … <jsp:setProperty name="myName" property="someProperty" …/> </jsp:useBean> 此时，<jsp:setProperty> 只有在新建Bean实例时才会执行，如果使用现有实例，则不执行 <jsp:setProperty>。 属性： 1．name="beanInstanceName" 该属性对应 <jsp:useBean> 中的id,因此name要和 <jsp:useBean> 的id一样 。 2．property="*" 这是一种设置Bean属性的快捷方式。储存用户在JSP输入的所有值，用于匹配Bean中的属性。JSP解释器将把系统Request对象中的参数一个一个的列举出来，检查这个JavaBean的属性是否和Request对象中的参数有相同的名称。如果有，就自动将Request对象中参数值传递给相应的JavaBean属性。 在Bean中，属性的名字、类型必须和request对象中的参数名称相匹配。由于表单中传过来的数据类型都是String类型的，JSP内在机制会把这些参数转化成Bean属性对应类型。 property="propertyName" [ param="parameterName" ] 用一个参数值来指定Bean中的一个属性值，一般情况下是从request对象中获得的。其中property指定Bean的属性名，param指定request中的参数名。 在Bean属性的名字和request中参数名字不同时使用这个方法。 Param指定request中的参数名。 property="propertyName" value="{string | <%= expression %>}" 使用指定的值来设定Bean属性。这个值可以是字符串，也可以是表达式。如果是字符串，那么它就会被转换成Bean属性的类型。如果是一个表达式，那么它的类型就必须和将要设定的属性值的类型一致。 如果参数值为空值，那么对应的属性值也不会被设定。此外，不能在同一个中同时使用param和value参数 。 下面两行使用请求参数值来匹配Bean中的属性值。 <jsp:setProperty name="user" property="*" /> <jsp:setProperty name="user" property="user" param="username"/> 假设上面两行所在的JSP文件是action-setproperty.jsp。访问该页面的URL是http://localhost:8080/action-setproperty.jsp?username=liuyongpo。则该URL中的参数username的值liuyongpo就会自动赋予给user中的属性user. 3.动作 主要用于获得JavaBean中的属性值 使用<jsp:getProperty> 之前，必须用 <jsp:useBean> 创建它。 JSP 语法格式如下：<jsp:getProperty name="beanInstanceName" property="propertyName" /> 属性： name="beanInstanceName" 该属性对应中的id，因此name要和的id一样 。 property="propertyName" propertyName是想要取得的属性值。 <jsp:plugin> <jsp:plugin> JSP 语法格式如下： <jsp:plugin type="bean|applet" code="classFileName" codebase="classFileDirectoryName" name="instanceName" align="left|right|top|middle|bottom" width="width" height="height" hspace="horizontalSpace" vspace="verticalSpace" archive="archiveURL,…"> <jsp:params> <jsp:param name="propertyName" value="propertyValue"/> … </jsp:params> <jsp:fallback>text message</jsp:fallback> </jsp:plugin>

JSP与Web技术概论 目录： Web应用程序开发基础知识 1. 客户端与浏览器 2. 服务器端与服务器 3. 通信协议 4. 全球资源定位器—— URL 静态网页与HTML 交互式动态网页技术 客户端动态网页技术 服务器端动态网页技术 主流动态页面技术 网站数据库技术 JSP与相关技术 Servlet概念 JSP的优势 JSP的弱势 软件编程体系简介 C/S结构编程体系 —— 客户机/服务器(Client/Server,C/S)模式 B/S结构编程体系 —— 浏览器/服务器(Browser/Server,B/S)模式 企业应用开发架构 两层架构 三层架构 N层架构 开发架构比较 Web应用程序开发基础知识 Web结构 Web主要由两个部分组成，提供信息的Web服务的服务器端网站及向网站提出信息内容浏览要求的客户端浏览器。 服务器端网站存放包含各种形态的多媒体信息网页 客户端主要包含了各种可以浏览网页内容的浏览器软件 目前比较通用的浏览软件为Windows操作系统的Internet Explorer(简称IE)浏览器。 1. 客户端与浏览器 要打开和浏览网络上的网页文件，必须通过浏览器程序，而使用浏览器打开网页的这一端，称为客户端，因为网站为上线用户提供打开网页的服务，因此用户也可称为客户。 浏览器的功能主要是解释HTML文件中的内容，若HTML中同时含有客户端执行的描述语言，例如VBScript或JavaScript，则浏览器同样会对其进行解释的操作，最后将整份网页的执行结果呈现在用户的浏览器窗口中。 2. 服务器端与服务器 与客户端相比，提供浏览网页服务的一方称作“服务器端”，而用来放置这些网页信息的计算机，则称为服务器。 服务器的功能并不只是单纯地存放网页信息，任何可提供网络服务的计算机都是服务器，例如提供网页信息的称为网页服务器，而提供文件上传与下载功能的则称为文件服务器。 3. 通信协议 在网络上要能彼此互通信息就必须遵循一定的沟通方式，这些沟通方式即所谓的通信协议，只有双方都使用相同的通信协议，才能建立起连接通道。 HTTP通信协议 客户端与Web(网络)服务器通信的整个流程，从图中可以看它，HTTP协议用来规范在客户端和服务器之间的数据传输格式，更重要的是，HTTP协议定义了从客户端发送HTTP请求到服务器端返回HTTP响应的整个流程。 ① HTTP请求； ②Web服务器解析处理HTTP请求； ③产生HTTP相应； ④HTTP相应。 4. 全球资源定位器—— URL URL的英文全称为Uniform Resource Locator(全球资源定位器)，当用户想要打开位于远程网站主机上的网页时，必须指定其URL位置，也就是通常所讲的网址，如下所示为一个URL地址：http://mfdycs.cn (欢迎访问我的个人博客) 静态网页与HTML 静态网页：是指一旦网页制作成功就不能随意更改或需要专业的技术人员进行修改。不能实现用户与服务器之间的交互，制作周期较长，更改困难，适应于一些不需要经常修改内容的网页。 静态网页及其执行过程： 任何Web服务器都支持静态网页： 首先用户在浏览器的地址栏中键入要访问的地址，并回车出发请求； 浏览器将请求发送到指定的Web服务器上； Web服务器接收请求并根据htm或html后缀判断所请求的静态网页； Web服务器从硬盘或者内存中读取正确的htm页面，然后将其送回用户浏览器。 交互式动态网页技术 动态网页：是指能够根据用户的请求而动态生成显示的结果。 不需要维护人员经常手动更新，它能够根据不同的时间，不同的人产生不同的页面。 目前绝大多数的网站采用的都是动态网页技术如JSP、ASP、PHP以及CGI技术等。 动态网页技术根据实现的不同还可以分为： 客户端动态网页技术 服务器端动态网页技术 客户端动态网页技术 与静态网页非常类似：只是客户端的浏览器在接收到服务器端传送而来的资源时，还需要负责对其中的脚本进行解释执行，并产生动态效果。 实现的语言有：JavaScript和VBScript脚本语言。 在客户端执行的网页语言 (1) 用户通过浏览器指定URL，向网页服务器请求特定的网页内容。 (2) 服务器加载指定的HTML网页，返回至客户端的网页浏览器进行解释。 (3) 浏览器取得HTML文件，解释其中的HTML及Script网页程序代码。 (4) 显示HTML网页。 服务器端动态网页技术 服务器端动态网页技术和我们前面讨论的两种运行原理不同： 服务器端网页的运行过程如下： 用户通过浏览器指定URL，向网页服务器请求特定的网页内容。 服务器加载指定的JSP网页，通过解释器解读其中的JSP程序代码，创建HTML网页，然后返回至客户端的网页浏览器进行解释。 浏览器取得JSP文件，解释其中的HTML及Script网页程序代码。 显示网页。 ​ 在上述过程中，用户可以发现服务器端的网页语言与HTML静态网页最大的差异在于第2个步骤，这个部分通过执行JSP程序代码创建HTML网页，因此在不同条件的情况下，网站得以利用同一份JSP网页文件，输出完全不同的网页内容，甚至动态产生Script程序代码。 主流动态页面技术 目前主要是3P技术： ASP（Active Server Pages） JSP（Java Server Pages） PHP（Hypertext Preprocessor） 网站数据库技术 ​ JSP网站开发离不开数据库编程，与数据库交互几乎是每个大型动态网站必备的功能。通过访问数据库，可以使一个动态网站所能呈现的内容范围比静态网站广泛得多。所以掌握数据库编程技术是网站开发的基础。 ​ JSP网页主要提供用户与服务器端数据库的操作存取功能，同时也是数据库内容的展示界面，客户端浏览器、服务器JSP网页与数据库三者形成一个交互式的数据库网站，其流程说明如下： ​ (1) 用户通过浏览器指定URL，向网页服务器请求特定的网页内容。 ​ (2) 服务器加载指定的JSP网页，通过解释器解读其中的JSP程序代码。 ​ (3) JSP根据其运算逻辑，存取数据库内容，建立所需的内容信息。 ​ (4) 处理好的数据用以创建HTML网页，返回至客户端的网页浏览器进行解释。 ​ (5) 浏览器取得JSP文件，解释其中的HTML及Script网页程序代码。 ​ (6) 显示网页。 JSP与相关技术 JSP(JavaServer Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准 用JSP开发的Web应用是跨平台的 JSP的1.0规范的最后版本是1999年9月推出的，常用版本是2003年发布的JSP2.0 JSP技术使用Java编程语言编写类XML的tags和scriptlets: 来封装产生动态网页的处理逻辑。 网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。 JSP将网页逻辑与网页设计和显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。 Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。 JSP与Java Servlet一样，是在服务器端执行的，通常返回该客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。 本质上，JSP是Servlet API的一个扩展。 JSP在处理请求之前都要编译成Servlet,所以它具有Servlet的所有优势，包括访问Java API。 简单的说，一个JSP页面就是包含了能够生成动态内容的可执行应用代码的HTML网页。 当服务器第一次接收到对某个页面的请求时，JSP引擎就开始进行上述的处理过程，将被请求的JSP文件编译成Class文件。 在后续对该页面再次进行请求时，若页面没有进行任何改动，服务器只需直接调用Class文件执行即可。 所以当某个JSP页面第一次被请求时，会有一些延迟，而再次访问时会感觉快了很多。如果被请求的页面经过修改，服务器将会重新编译这个文件，然后执行。 Servlet概念 ​ Servlet是运行在服务器上的Java程序，是一个中间层，主要用来处理客户端请求，并对客户端请求进行响应，还可以连接应用服务。Servlet是在服务器端实现动态网页的一种技术。 Servlet的生命周期： 客户端向服务器发出请求，服务器根据客户端的请求，找到相应的Servlet类 判断该Servlet是否在内存中加载？若未加载，创建该Servlet实例，调用init()方法完成初始化操作。若已经加载，转3。 调用service()方法对客户端进行响应。等待下一次请求。在Servlet生命周期中，service()方法是其中的核心。每当客户端向Servlet发出一个请求时，该方法就会被调用,对用户的请求进行处理，并返回响应。 结束，调用destroy()方法。当服务器端不再需要该Servlet的时候，服务器调用destroy()方法卸载该Servlet，释放Servlet运行时占用的资源。 Servlet是一种独立于平台和协议的服务器端的Java应用程序，可以生成动态的Web页面。 它担当Web浏览器或其他HTTP客户程序发出请求，与HTTP服务器上的数据库或应用程序之间的中间层。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。 JSP的优势 程序可以跨台平执行 JSP可以让开发人员在任意环境中进行开发，在任意环境中进行系统部署，在任意环境中扩展应用程序。 多样化和功能强大的开发工具支持。 Java有许多非常优秀的开发工具，而且有许多可以免费得到，并且其中的许多已经可以顺利地运行于多种平台之下。 强大的可伸缩性。 从只有一个小的jar文件就可以运行servlet/jsp到由多台服务器进行集群和负载均衡，到多台Application进行事务处理，一台服务器到无数台服务器，Java显示了巨大的生命力。 JSP的弱势 跨平台的功能和极度的伸缩能力极大地增加了产品的复杂性。 它在扩展时需要分成多少块，那么java系统中就有多少种产品，所以用户可能会看到jre，jdk，jsdk，jswdk等，而实际上它们是密不可分的。只要将它们有效地搭配在一起，就可以产生强大的效能。当然，这同时也使应用程序变得非常复杂。 JSP运行是用class常驻内存来完成的，虽然提高了响应速度，但要占用相当内存。 Java的运行速度是用class常驻内存来完成的，所以它在一些情况下所使用的内存比起用户数量来说确实是“最低性能价格比”了。从另一方面，它还需要硬盘空间来储存一系列的.java文件和.class文件，以及对应的版本文件。 JSP程序调试不方便。 JSP页面首先被转化为一个.java文件(Servlet)，然后再被编译。这样，出错信息实际上指向的是经过转化的那个.java文件而不是jsp本身。 软件编程体系简介 C/S结构编程体系 —— 客户机/服务器(Client/Server,C/S)模式 最大特点是在每个用户端需要安装程序，所有用户端程序和中心服务器进行信息交互 优点是用户端程序一致，比较方便控制，服务器端和用户本地的数据很容易进行交互，通信速度比较快 缺点是每个用户都需要安装客户端，比较繁琐，而且不能很好的跨操作系统平台 服务器只集中管理数据，计算任务分散在客户机上，客户机和服务器之间通过网络协议来进行通讯 客户端先进行简单的预处理，将处理后的结果再提交给服务器进行进一步的处理 这种模式我们也通常成为胖客户端模式 C/S结构通常适用于具有固定的用户端或者少量的用户端，并且是对安全性要求比较高的应用 典型的系统：QQ、MSN、邮局信息管理系统、飞机票火车票售票系统。 B/S结构编程体系 —— 浏览器/服务器(Browser/Server,B/S)模式 客户端使用通用的浏览器(如:NetScape、Explorer) 代替各种应用软件，服务器则为Web服务器。浏览器和服务器之间通过TCP/IP通信协议进行连接，浏览器发出请求，由Web服务器向后台取出数据进行处理，并将结果返回给浏览器。 这种模式，我们通常将其称为瘦客户端模式 典型的系统：网上银行、网上购物、Blog等等 企业应用开发架构 在构建企业级应用的时候，通常需要大量的代码，而且这些代码一般分布在不同的计算机上，划分代码运行在不同计算机上的理论就是多层设计理论。 企业级应用系统通常分成：两层、三层、N层架构。 两层架构 ​ 传统的两层应用包括用户接口和后台程序，后台程序通常是一个数据库，用户接口直接同数据库进行对话。实现上，通常使用JSP、ASP或者VB等技术编写这类软件，结构如图 两层应用架构显示逻辑层一般由HTML、JSP、ASP实现，通过JSP和ASP直接和数据库相连 三层架构 ​ 在两层应用中，应用程序直接同数据库进行对话。三层结构在用户接口代码和数据库中间加入了一个附加的逻辑层，通常这个层叫做“商务逻辑层”，如图 N层架构 如果某个应用超过三个独立的代码层，那么这个应用叫做N应用，就不再叫四层或者五层等名称，而是统称为N层 开发架构比较 两层架构的优点是开发过程比较简单，利用服务器端的程序直接访问数据库，部署起来比较方便。缺点是程序代码维护起来比较困难，程序执行的效率比较低，用户容量比较少。 三层架构基本解决了两层架构的缺点，将显示部分和逻辑流程控制分开，利用服务器应用程序实现显示部分，利用商务逻辑层实现程序的流程控制，分层使维护变的方便一些，而且执行效率也会有所提高，但是相对部署起来就比较困难一些。 根据实际的需要，会进一步细化每一层，或者添加一些层，就形成了N层架构，和三层架构一样，组件化的设计使维护相对容易，但是部署相对困难。