Jsp1

　　

jsp代码中包含两类：jsp元素和template data。　　template模板 data：jsp引擎不处理的部分，就是<%....%>之外的部分，直接给浏览器显示。

 

 

　　　　<%! %>

　　　　<%  %>

　　　　<%=   %>

 

 

　　　　<%-- --%>

　　　　<!-- -->

　　jsp指令元素： 1.page：11个属性

language，

extends,

import，

session，

buffer，

autoFlush，

buffer,

autoFlush,

isThreadSafe,

info,

errorPage,

contentType,

isErrorPage

　　　　　　　2.include

file:

　　　　　　　3.taglib:

uri:

prefix:

　　　　Jsp动作指令：

<jsp:forward>

 

jsp: param用于在转发时增加额外的请求参数。请求参数的值可以通过HttpServletRequest类的getParameter()方法获得。

下面是代码实例：

 

forward指令用于将页面响应转发到另外的页面。既可以转发到静态的HTML页面，也可以转发到动态的JSP页面，或者转发到容器中的Servlet。

 

forward指令格式如下:

　　<jsp:forward page="{relativeURL|<%=expression%>}">

    {jsp:param..../>}

　　</jsp:forward>

 

在Jsp1中：

<jsp:forward page="Jsp1.jsp">
<jsp:param value="<%=user %>" name="name"/>
<jsp:param value="<%=password %>" name="password"  />

</jsp:forward>

 

 在Jsp2中

<% String name =request.getParameter("name");
String password=request.getParameter("password");

%>
<%=name %>
<%=password %>

结果图： 

从图中可以看出，执行forward指令时，用户请求的地址依然没有发生变化，但页面内容却完全被forward目标页的内容。

另外，在执行forward指令转发请求时，客户端的请求参数不会丢失。来看下面例子，该页没有任何动态内容，只是一个静态的表单页，作用是将请求参数提交到jsp-forward.jsp页。

<jsp:include>:

<jsp:useBean>:

　　　　　　　　　　　　

javaBean是特殊的Java类，使用J ava语言书写，并且遵守JavaBean API规范。

接下来给出的是JavaBean与其它Java类相比而言独一无二的特征：

• 提供一个默认的无参构造函数。
• 需要被序列化并且实现了Serializable接口。
• 可能有一系列可读写属性。
• 可能有一系列的"getter"或"setter"方法。

---

JavaBean属性

一个JavaBean对象的属性应该是可访问的。这个属性可以是任意合法的Java数据类型，包括自定义Java类。

一个JavaBean对象的属性可以是可读写，或只读，或只写。JavaBean对象的属性通过JavaBean实现类中提供的两个方法来访问：

访问JavaBean

<jsp:useBean> 标签可以在JSP中声明一个JavaBean，然后使用。声明后，JavaBean对象就成了脚本变量，可以通过脚本元素或其他自定义标签来访问。<jsp:useBean>标签的语法格式如下：

<jsp:useBean id="bean 的名字" class="javabean名" scope="bean 的作用域" />

这种情况下，body部分的内容只在此标签创建JavaBean的实例对象时才执行，创建JavaBean之后则表示JavaBean已存在，则body内容不会显示了。

其中，根据具体情况，scope的值可以是page，request，session或application。

【id】

　　 一个用来标识你指定作用域的变量，假如该Bean对象已由
        其它<jsp:useBean>元素创建，则该值必须和实例化该Bean对象
        的<jsp:useBean>元素id属性值一致，才能实现定位到该Bean对象。

　　id值可任意只要不和同一JSP文件中其它<jsp:useBean>中id值一样就行了。

　　　　注：先要有个javabean.java文件，id值才不会报错，在eclipse中。

　　　　

【scope:范围】【skōp】

Scope属性具有四个可能的值分别是application 、session 、request、page;四种不同的生命周期和使用范围。

　　page：默认，缺省值；在本页面（<jsp:useBean>所在的jsp）；或其包含页面使用。直到forward或回应回客户端。

　　session:你可以在同一次会话的任意一个页面中使用该javaBean，该Bean在整个会话期间一直存在。但是该<%@page session=true%> session必须设为true；

　　request：可以在处理同一个请求的任意一个页面使用该JavaBean对
        象，直到该页面发送响应回客户端或产生新的请求。

　　application：待定----

【class】： 从一个class实例化Bean对象，使用new关键字调用class的构造方法完

 成。class="d.bean"

【type】用来指定该Bean对象的数据类型，假如既没有指定 class　或 beanBean, 没
有Bean对象能被实例化。包和类名称大小写敏感。

 【beanName】：beanName="{package.class | <%= expression %>}" type="package.class　　使用java.beans.Beans.instantiate方法实例化beanName属性指定的类或序列化模板对应的Bean对象，赋予JavaBean对象type属性指定的数据类型。Beans.instantiate方法会检查beanName属性指定的名称是类名称还是序列化模板的名称。假如该JavaBean对象已被序列化，则Beans.instantiate使用类加载器读取序列化的内容，更多信息可参考JavaBeans.beanName属性值要么是一个完整类名，要么是一个可以转化为完整类名的表达式。用来传给Beans.instantiate方法。type属性值可和beanName属性值同，或为其超类、接口。

　　　　【注意】：

1.class或beanName不能同时存在；它们用来指定实例化的类名称或序列化模板；
如果确信JavaBean对象已存在，class和beanName属性均可无须指定, 可只须指定
type属性。

2. class可以省去type独自存在，beanName必须和type一起使用；

3.class指定的是类名，beanName指定的是类名或序列化模板的名称；

<jsp:setProperty>:

　　　　

<jsp:setProperty property="proertyname" name="bean name" value="value"/>

　　name：use bean中的id值，

　　property：javabean类中的属性名，

　　value：你要设给property的值。

　　

1 <jsp:setProperty name="beanName"
2 {
3     property="propertyName" value="{String|<%=expression%>}"或
4     property="propertyName"[param="parameterName"]或
5     property="*"
6 }/>

value的值可以是字符串，也可以是表达式。如果value的值是一个表达式，那么该表达式的计算结果必须与所有要设置的JavaBean属性的类型一致。
param属性用于将JavaBean实例对象的某个属性值设置为一个请求参数值，该属性值同样会自动转换成要设置的JavaBean属性的类型。
注意：可以将八种基本数据类型和字符串相互转换，但是对与复杂类型不能转换。

<jsp:getProperty>:

　　　　<jsp:getproperty name=“id” property=“property”/>

　　　　<jsp:getProperty>标签：用于在jsp页面中获取一个JavaBean组件的属性。

<jsp:plugin>:

　　　　　　JSP内置对象

request:

response:

session:

application:

out:

config:

page:

pageContext:

exception:

Cookie:

 

 cookie与session

---------------------------------------------------------------------------------------------------------

JSP（全称JavaServer Pages）是由Sun Microsystems公司倡导和许多公司参与共同创建的一种使软件开发者可以响应客户端请求，而动态生成HTML、XML或其他格式文档的Web网页的技术标准。JSP技术是以Java语言作为脚本语言的，JSP网页为整个服务器端的Java库单元提供了一个接口来服务于HTTP的应用程序。

JSP使Java代码和特定的预定义动作可以嵌入到静态页面中。JSP句法增加了被称为JSP动作的XML标签，它们用来调用内建功能。另外，可以创建JSP标签库，然后像使用标准HTML或XML标签一样使用它们。标签库提供了一种和平台无关的扩展服务器性能的方法。

JSP被JSP编译器编译成Java Servlets。一个JSP编译器可以把JSP编译成JAVA代码写的servlet然后再由JAVA编译器来编译成机器码，也可以直接编译成二进制码。

 

目录

  [隐藏] 

• 1JSP和Servlets2本地化
  • 1.1JSP指令
  • 1.2JSP脚本元素和变量
    • 1.2.1标准脚本变量
    • 1.2.2脚本元素
  • 1.3JSP动作
    • 1.3.1标签样例
      • 1.3.1.1jsp:include
      • 1.3.1.2jsp:forward
      • 1.3.1.3jsp:plugin
      • 1.3.1.4jsp:useBean
  • 1.4JSP标签库
• 3JSP 2.0
• 4模型-视图-控制器 模式
• 5样例
• 6出版物
• 7参见
• 8外部链接

 

JSP和Servlets[编辑]

从架构上说，JSP可以被看作是从Servlets高级提炼而作为JAVA Servlet 2.1 API的扩展而应用。Servlets和JSP最早都是由Sun Microsystems（太阳公司）开发的。从JSP1.2版本以来，JSP处于Java Community Process（有人译为：JAVA社区组织）开发模式下。JSR-53规定了JSP 1.2和Servlet 2.4的规范，JSR-152规定了JSP 2.0的规范。2006年5月，JSP 2.1的规范作为Java EE 5的一部分，在JSR-245中发布。

 

静态数据在输入文件中的内容和输出给HTTP响应的内容完全一致。此时，该JSP输入文件会是一个没有内嵌JAVA或动作的HTML页面。而且，客户端每次请求都会得到相同的响应内容。

JSP指令[编辑]

JSP指令控制JSP编译器如何去生成servlet，以下是可用的指令：

• 包含指令include –包含指令通知JSP编译器把另外一个文件完全包含入当前文件中。效果就好像被包含文件的内容直接被粘贴到当前文件中一样。这个功能和C预处理器所提供的很类似。被包含文件的扩展名一般都是"jspf"（即JSP Fragment，JSP片段）:

<%@ include file="somefile.jsp" %>

• 页面指令page –页面指令有以下几个选项：

import	使一个JAVA导入声明被插入到最终页面文件。
contentType	规定了生成内容的类型。当生成非HTML内容或者当前字符集character set并非默认字符集时使用。
errorPage	处理HTTP请求时，如果出现异常则显示该错误提示信息页面。
isErrorPage	如果设置为TRUE，则表示当前文件是一个错误提示页面。
isThreadSafe	表示最终生成的servlet是否线程安全（thread safe）。

<%@ page import="java.util.*" %> //example import导入样例
<%@ page contentType="text/html" %> //example contentType页面类型样例
<%@ page isErrorPage=false %> //example for non error page无错页面样例
<%@ page isThreadSafe=true %> //example for a thread safe JSP线程安全JSP样例

注意：在同一个JSP文件中只有"import"导入页面指令可以被多次使用。

• 标签库指令taglib –标签库指令描述了要使用的JSP标签库。该指令需要指定一个前缀prefix（和C++的命名空间很类似）和标签库的描述URI:

<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>

JSP脚本元素和变量[编辑]

标准脚本变量[编辑]

以下是永远可用的脚本变量：

• out：JSPWriter，用来写入响应流的数据
• page：servlet自身
• pageContext：一个PageContext实例包括和整个页面相联系的数据，一个给定的HTML页面可以在多个JSP之间传递。
• request：HTTP request（请求）对象
• response：HTTP response（响应）对象
• session：HTTP session（服务端会话）对象

脚本元素[编辑]

有三个基本的脚本元素，作用是使JAVA代码可以直接插入servlet.

• 一种是声明标签，在JAVA SERVLET的类体中放入一个变量的定义。静态的数据成员也可以如此定义。

  <%! int serverInstanceVariable = 1; %>
  

• 一种是脚本标签，在JAVA SERVLET的类的_jspService()方法中放入所包含的语句。

  <% int localStackBasedVariable = 1;  out.println(localStackBasedVariable); %>
  

• 一种是表达式标签，在JAVA SERVLET的类中放入待赋值的表达式，表达式注意不能以分号结尾。

  <%= "expanded inline data " + 1 %>
  

JSP动作[编辑]

JSP动作是一系列可以调用内建于网络服务器中的功能的XML标签。JSP提供了以下动作：

jsp:include	和子过程类似，JAVA SERVLET暂时接管对其它指定的JSP页的请求和响应。当处理完该JSP页后就马上把控制权交还当前JSP页。这样JSP代码就可以在多个JSP页中共享而不用复制。
jsp:param	可以在jsp:include, jsp:forward或jsp:params块之间使用。指定一个将加入请求的当前参数组中的参数。
jsp:forward	用于处理对另一个JSP或SERVLET的请求和响应。控制权永远不会交还给当前JSP页。
jsp:plugin	Netscape Navigator的老版本和Internet Explorer使用不同的标签以嵌入一个applet。这个动作产生为嵌入一个APPLET所需要的指定浏览器标签。
jsp:fallback	如果浏览器不支持APPLETS则会显示的内容。
jsp:getProperty	从指定的JavaBean中获取一个属性值。
jsp:setProperty	在指定的JavaBean中设置一个属性值。
jsp:useBean	创建或者复用一个JavaBean变量到JSP页。

标签样例[编辑]

jsp:include[编辑]

<html>
<head></head>
<body>
<jsp:include page="mycommon.jsp" >
    <jsp:param name="extraparam" value="myvalue" />
</jsp:include>
name:<%=request.getParameter("extraparam")%>
</body>
</html>

jsp:forward[编辑]

<jsp:forward page="subpage.jsp" >
     <jsp:param name="forwardedFrom" value="this.jsp" />
</jsp:forward>

在本例中，请求被传递到"subpage.jsp"，而且请求的处理权不会再返回前者。

jsp:plugin[编辑]

<jsp:plugin type=applet height="100%" width="100%"
            archive="myjarfile.jar,myotherjar.jar"
            codebase="/applets"
            code="com.foo.MyApplet" >
    <jsp:params>
        <jsp:param name="enableDebug" value="true" />
    </jsp:params>
    <jsp:fallback>
        Your browser does not support applets.
    </jsp:fallback>
</jsp:plugin>

上述plugin例子说明了一种在网页中嵌入applet的统一方法。在<OBJECT>标签出现之前，并没有一种嵌入applets的通用方法。这个标签设计得并不好，但有希望在以后加入动态属性（height="${param.height}", code="${chart}"等）和动态参数的新功能。目前jsp:plugin标签不允许动态调用applets。例如，你如果有一个图表applet需要数据点以参数形式被传入，除非数据点的数量是一个常量，否则你就不能使用ResultSet循环来创建jsp:param标签，你不得不手写每个jsp:param标签的代码。而每个上述jsp:param标签可以有一个动态命名和动态值。

jsp:useBean[编辑]

<jsp:useBean id="myBean" class="com.foo.MyBean" scope="request" />
<jsp:getProperty name="myBean" property="lastChanged" />
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />

scope属性可以是request, page, session or application，它有以下用意：

• request— 该属性在请求的生命周期内有效，一旦请求被所有的JSP页处理完后，那么该属性就不可引用。
• page— 该属性只是当前页中有效。
• session— 该属性在用户会话的生命周期内有效。
• application— 该属性在各种情况下都有效，并且永远不会被变为不可引用，和全局变量global variable相同。

上述例子将会用一个创建一个类的实例，并且把该实例存储在属性中，该属性将在该请求的生命周期内有效。它可以在所有被包含或者从主页面（最先接收请求的页面）转向到的JSP页之间共享。

JSP标签库[编辑]

除了JSP预定义动作之外，开发者还可以使用JSP标签扩展API添加他们自定义的动作。开发者写一种实现一个标签的界面和一个标签库的XML描述文件的JAVA类，这就能指定标签和实现标签的JAVA类 请看如下JSP：

<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>
...
<myprefix:myaction> <%-- the start tag %>
...
</myprefix:myaction> <%-- the end tag %>
...

JSP编译器将会载入mytaglib.tld这个XML文件，然后可以看到标签myaction由JAVA类MyActionTag实现。当该标签首次在文件中使用时，将会创建一个MyActionTag的实例。然后（而且当每次该标签被使用时），当出现开始标签时，将会调用doStartTag()方法，根据开始标签的结果，来决定如何处理标签的主体。主体是指开始标签和结束标签之间的文本。这个doStartTag()方法将会返回如下之一：

• SKIP_BODY - 标签之间不做处理。
• EVAL_BODY_INCLUDE - 对标签之内主体进行赋值。
• EVAL_BODY_TAG - 对标签之内主体进行赋值并把结果输出到流（保存在标签的主体内容属性中）。

注意：如果标签扩展了BodyTagSupport类，当主体被执行时会在调用doEndTag()之前调用doAfterBody()方法。该方法用于实现循环结构。

当结束标签出现时，它会调用doEndTag()方法，该方法会返回如下两做之一：

• EVAL_PAGE - 表示JSP文件的剩余部分将会被执行。this indicates that the rest of the JSP file should be processed.
• SKIP_PAGE - 表示将不会再有更多执行操作。当前JSP页交出控制权。就象在转发动作中的作用一样。

上述myaction标签tag会有一个类似下面例子的用于实现的类：

public class MyActionTag extends  TagSupport {
    //Releases all instance variables.
    public void release() {...}

    public MyActionTag() { ... }

    //called for the start tag
    public int doStartTag() { ... }

    //called at the end tag
}

本地化[编辑]

JSP的本地化是通过和JAVA应用程序相同的方式完成的，即使用资源包。

JSP 2.0[编辑]

新的JSP规范版本包括新的用于提升程序员工作效率功能，主要有：

• An Expression Language（EL）允许开发者创建Velocity-样式 templates（among other things）.
• 更快更简单的创建新标签的方法。

Hello, ${param.visitor}  <%-- same as: Hello, <%=request.getParameter("visitor")%> --%>

模型-视图-控制器 模式[编辑]

为了把表现层presentation从请求处理request processing和数据存储data storage中分离开来，太阳公司推荐在JSP文件中使用一种模型-视图-控制器Model-view-controller模式。规范的SERVLET或者分离的JSP文件用于处理请求。当请求处理完后，控制权交给一个只作为创建输出作用的JSP页。有几种平台都基于服务于网络层的模-视图-控件 模式（比如Struts和Spring framework）。

样例[编辑]

不管JSP编译器是生成SERVLET的JAVA源码，或者是直接发布二进制码，了解一下JSP编译器是如何把文件转换成一个JAVA SERVLET，都是很有帮助的。例如，看一下如下输入JSP和它最后生成的JAVA SERVLET：

Input JSP

<%@ page errorPage="myerror.jsp" %>
<%@ page import="com.foo.bar" %>

<html>
<head>
<%! int serverInstanceVariable = 1;%>
...
<% int localStackBasedVariable = 1; %>
<table>
    <tr><td><%= "expanded inline data " + 1 %></td></tr>
    ...

Resulting servlet

package jsp_servlet;
import java.util.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;

import com.foo.bar; //imported as a result of <%@ page import="com.foo.bar" %>
import ...

class _myserlvet implements javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
    //inserted as a
    //result of <%! int serverInstanceVariable = 1;%>
    int serverInstanceVariable = 1;
    ...

    public void _jspService( javax.servlet.http.HttpServletRequest request,
                            javax.servlet.http.HttpServletResponse response )
        throws javax.servlet.ServletException,
               java.io.IOException
    {
        javax.servlet.ServletConfig config = ...;//get the servlet config
        Object page = this;
        PageContext pageContext = ...;//get the page context for this request
        javax.servlet.jsp.JspWriter out = pageContext.getOut();
        HttpSession session = request.getSession( true );
        try {
             out.print( "<html>
" );
             out.print( "<head>
" );
             ...
             //from <% int localStackBasedVariable = 1; %>
             int localStackBasedVariable = 1;
             ...
             out.print( "<table>
" );
             out.print( "   <tr><td>" );
             //note, toStringOrBlank() converts the expression into a string or if
             // the expression is null, it uses the empty string.
             //from <%= "expanded inline data " + 1 %>
             out.print( toStringOrBlank( "expanded inline data " + 1 ) );
             out.print( "   </td></tr>
" );
             ...
        } catch ( Exception _exception ) {
           //clean up and redirect to error page in <%@ page errorPage="myerror.jsp" %>
        }
    }
}

出版物[编辑]

• JavaServer Pages, Third Edition, Hans Bergsten，O'Reilly & Associates, Inc.，Sebastopol, California, 2003. ISBN 0-596-00563-6

参见[编辑]

• JSTL
• Java EE
• JavaServer Faces
• Java Servlet
• SSJS
• WAR (file format)
• EAR (file format)
• JAR (file format)
• Apache Tomcat

外部链接[编辑]

• Sun's JSP product description
• JSR 245 (JSP 2.1)
• JSR 152 (JSP 2.0)
• JSR 53 (JSP 1.2)

JSP（全称JavaServer Pages）是由Sun Microsystems公司倡导和许多公司参与共同创建的一种使软件开发者可以响应客户端请求，而动态生成HTML、XML或其他格式文档的Web网页的技术标准。JSP技术是以Java语言作为脚本语言的，JSP网页为整个服务器端的Java库单元提供了一个接口来服务于HTTP的应用程序。

JSP使Java代码和特定的预定义动作可以嵌入到静态页面中。JSP句法增加了被称为JSP动作的XML标签，它们用来调用内建功能。另外，可以创建JSP标签库，然后像使用标准HTML或XML标签一样使用它们。标签库提供了一种和平台无关的扩展服务器性能的方法。

JSP被JSP编译器编译成Java Servlets。一个JSP编译器可以把JSP编译成JAVA代码写的servlet然后再由JAVA编译器来编译成机器码，也可以直接编译成二进制码。

 

目录

  [隐藏] 

• 1JSP和Servlets2本地化
  • 1.1JSP指令
  • 1.2JSP脚本元素和变量
    • 1.2.1标准脚本变量
    • 1.2.2脚本元素
  • 1.3JSP动作
    • 1.3.1标签样例
      • 1.3.1.1jsp:include
      • 1.3.1.2jsp:forward
      • 1.3.1.3jsp:plugin
      • 1.3.1.4jsp:useBean
  • 1.4JSP标签库
• 3JSP 2.0
• 4模型-视图-控制器 模式
• 5样例
• 6出版物
• 7参见
• 8外部链接

 

JSP和Servlets[编辑]

从架构上说，JSP可以被看作是从Servlets高级提炼而作为JAVA Servlet 2.1 API的扩展而应用。Servlets和JSP最早都是由Sun Microsystems（太阳公司）开发的。从JSP1.2版本以来，JSP处于Java Community Process（有人译为：JAVA社区组织）开发模式下。JSR-53规定了JSP 1.2和Servlet 2.4的规范，JSR-152规定了JSP 2.0的规范。2006年5月，JSP 2.1的规范作为Java EE 5的一部分，在JSR-245中发布。

 

静态数据在输入文件中的内容和输出给HTTP响应的内容完全一致。此时，该JSP输入文件会是一个没有内嵌JAVA或动作的HTML页面。而且，客户端每次请求都会得到相同的响应内容。

JSP指令[编辑]

JSP指令控制JSP编译器如何去生成servlet，以下是可用的指令：

• 包含指令include –包含指令通知JSP编译器把另外一个文件完全包含入当前文件中。效果就好像被包含文件的内容直接被粘贴到当前文件中一样。这个功能和C预处理器所提供的很类似。被包含文件的扩展名一般都是"jspf"（即JSP Fragment，JSP片段）:

<%@ include file="somefile.jsp" %>

• 页面指令page –页面指令有以下几个选项：

import	使一个JAVA导入声明被插入到最终页面文件。
contentType	规定了生成内容的类型。当生成非HTML内容或者当前字符集character set并非默认字符集时使用。
errorPage	处理HTTP请求时，如果出现异常则显示该错误提示信息页面。
isErrorPage	如果设置为TRUE，则表示当前文件是一个错误提示页面。
isThreadSafe	表示最终生成的servlet是否线程安全（thread safe）。

<%@ page import="java.util.*" %> //example import导入样例
<%@ page contentType="text/html" %> //example contentType页面类型样例
<%@ page isErrorPage=false %> //example for non error page无错页面样例
<%@ page isThreadSafe=true %> //example for a thread safe JSP线程安全JSP样例

注意：在同一个JSP文件中只有"import"导入页面指令可以被多次使用。

• 标签库指令taglib –标签库指令描述了要使用的JSP标签库。该指令需要指定一个前缀prefix（和C++的命名空间很类似）和标签库的描述URI:

<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>

JSP脚本元素和变量[编辑]

标准脚本变量[编辑]

以下是永远可用的脚本变量：

• out：JSPWriter，用来写入响应流的数据
• page：servlet自身
• pageContext：一个PageContext实例包括和整个页面相联系的数据，一个给定的HTML页面可以在多个JSP之间传递。
• request：HTTP request（请求）对象
• response：HTTP response（响应）对象
• session：HTTP session（服务端会话）对象

脚本元素[编辑]

有三个基本的脚本元素，作用是使JAVA代码可以直接插入servlet.

• 一种是声明标签，在JAVA SERVLET的类体中放入一个变量的定义。静态的数据成员也可以如此定义。

  <%! int serverInstanceVariable = 1; %>
  

• 一种是脚本标签，在JAVA SERVLET的类的_jspService()方法中放入所包含的语句。

  <% int localStackBasedVariable = 1;  out.println(localStackBasedVariable); %>
  

• 一种是表达式标签，在JAVA SERVLET的类中放入待赋值的表达式，表达式注意不能以分号结尾。

  <%= "expanded inline data " + 1 %>
  

JSP动作[编辑]

JSP动作是一系列可以调用内建于网络服务器中的功能的XML标签。JSP提供了以下动作：

jsp:include	和子过程类似，JAVA SERVLET暂时接管对其它指定的JSP页的请求和响应。当处理完该JSP页后就马上把控制权交还当前JSP页。这样JSP代码就可以在多个JSP页中共享而不用复制。
jsp:param	可以在jsp:include, jsp:forward或jsp:params块之间使用。指定一个将加入请求的当前参数组中的参数。
jsp:forward	用于处理对另一个JSP或SERVLET的请求和响应。控制权永远不会交还给当前JSP页。
jsp:plugin	Netscape Navigator的老版本和Internet Explorer使用不同的标签以嵌入一个applet。这个动作产生为嵌入一个APPLET所需要的指定浏览器标签。
jsp:fallback	如果浏览器不支持APPLETS则会显示的内容。
jsp:getProperty	从指定的JavaBean中获取一个属性值。
jsp:setProperty	在指定的JavaBean中设置一个属性值。
jsp:useBean	创建或者复用一个JavaBean变量到JSP页。

标签样例[编辑]

jsp:include[编辑]

<html>
<head></head>
<body>
<jsp:include page="mycommon.jsp" >
    <jsp:param name="extraparam" value="myvalue" />
</jsp:include>
name:<%=request.getParameter("extraparam")%>
</body>
</html>

jsp:forward[编辑]

<jsp:forward page="subpage.jsp" >
     <jsp:param name="forwardedFrom" value="this.jsp" />
</jsp:forward>

在本例中，请求被传递到"subpage.jsp"，而且请求的处理权不会再返回前者。

jsp:plugin[编辑]

<jsp:plugin type=applet height="100%" width="100%"
            archive="myjarfile.jar,myotherjar.jar"
            codebase="/applets"
            code="com.foo.MyApplet" >
    <jsp:params>
        <jsp:param name="enableDebug" value="true" />
    </jsp:params>
    <jsp:fallback>
        Your browser does not support applets.
    </jsp:fallback>
</jsp:plugin>

上述plugin例子说明了一种在网页中嵌入applet的统一方法。在<OBJECT>标签出现之前，并没有一种嵌入applets的通用方法。这个标签设计得并不好，但有希望在以后加入动态属性（height="${param.height}", code="${chart}"等）和动态参数的新功能。目前jsp:plugin标签不允许动态调用applets。例如，你如果有一个图表applet需要数据点以参数形式被传入，除非数据点的数量是一个常量，否则你就不能使用ResultSet循环来创建jsp:param标签，你不得不手写每个jsp:param标签的代码。而每个上述jsp:param标签可以有一个动态命名和动态值。

jsp:useBean[编辑]

<jsp:useBean id="myBean" class="com.foo.MyBean" scope="request" />
<jsp:getProperty name="myBean" property="lastChanged" />
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />

scope属性可以是request, page, session or application，它有以下用意：

• request— 该属性在请求的生命周期内有效，一旦请求被所有的JSP页处理完后，那么该属性就不可引用。
• page— 该属性只是当前页中有效。
• session— 该属性在用户会话的生命周期内有效。
• application— 该属性在各种情况下都有效，并且永远不会被变为不可引用，和全局变量global variable相同。

上述例子将会用一个创建一个类的实例，并且把该实例存储在属性中，该属性将在该请求的生命周期内有效。它可以在所有被包含或者从主页面（最先接收请求的页面）转向到的JSP页之间共享。

JSP标签库[编辑]

除了JSP预定义动作之外，开发者还可以使用JSP标签扩展API添加他们自定义的动作。开发者写一种实现一个标签的界面和一个标签库的XML描述文件的JAVA类，这就能指定标签和实现标签的JAVA类 请看如下JSP：

<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>
...
<myprefix:myaction> <%-- the start tag %>
...
</myprefix:myaction> <%-- the end tag %>
...

JSP编译器将会载入mytaglib.tld这个XML文件，然后可以看到标签myaction由JAVA类MyActionTag实现。当该标签首次在文件中使用时，将会创建一个MyActionTag的实例。然后（而且当每次该标签被使用时），当出现开始标签时，将会调用doStartTag()方法，根据开始标签的结果，来决定如何处理标签的主体。主体是指开始标签和结束标签之间的文本。这个doStartTag()方法将会返回如下之一：

• SKIP_BODY - 标签之间不做处理。
• EVAL_BODY_INCLUDE - 对标签之内主体进行赋值。
• EVAL_BODY_TAG - 对标签之内主体进行赋值并把结果输出到流（保存在标签的主体内容属性中）。

注意：如果标签扩展了BodyTagSupport类，当主体被执行时会在调用doEndTag()之前调用doAfterBody()方法。该方法用于实现循环结构。

当结束标签出现时，它会调用doEndTag()方法，该方法会返回如下两做之一：

• EVAL_PAGE - 表示JSP文件的剩余部分将会被执行。this indicates that the rest of the JSP file should be processed.
• SKIP_PAGE - 表示将不会再有更多执行操作。当前JSP页交出控制权。就象在转发动作中的作用一样。

上述myaction标签tag会有一个类似下面例子的用于实现的类：

public class MyActionTag extends  TagSupport {
    //Releases all instance variables.
    public void release() {...}

    public MyActionTag() { ... }

    //called for the start tag
    public int doStartTag() { ... }

    //called at the end tag
}

本地化[编辑]

JSP的本地化是通过和JAVA应用程序相同的方式完成的，即使用资源包。

JSP 2.0[编辑]

新的JSP规范版本包括新的用于提升程序员工作效率功能，主要有：

• An Expression Language（EL）允许开发者创建Velocity-样式 templates（among other things）.
• 更快更简单的创建新标签的方法。

Hello, ${param.visitor}  <%-- same as: Hello, <%=request.getParameter("visitor")%> --%>

模型-视图-控制器 模式[编辑]

为了把表现层presentation从请求处理request processing和数据存储data storage中分离开来，太阳公司推荐在JSP文件中使用一种模型-视图-控制器Model-view-controller模式。规范的SERVLET或者分离的JSP文件用于处理请求。当请求处理完后，控制权交给一个只作为创建输出作用的JSP页。有几种平台都基于服务于网络层的模-视图-控件 模式（比如Struts和Spring framework）。

样例[编辑]

不管JSP编译器是生成SERVLET的JAVA源码，或者是直接发布二进制码，了解一下JSP编译器是如何把文件转换成一个JAVA SERVLET，都是很有帮助的。例如，看一下如下输入JSP和它最后生成的JAVA SERVLET：

Input JSP

<%@ page errorPage="myerror.jsp" %>
<%@ page import="com.foo.bar" %>

<html>
<head>
<%! int serverInstanceVariable = 1;%>
...
<% int localStackBasedVariable = 1; %>
<table>
    <tr><td><%= "expanded inline data " + 1 %></td></tr>
    ...

Resulting servlet

package jsp_servlet;
import java.util.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;

import com.foo.bar; //imported as a result of <%@ page import="com.foo.bar" %>
import ...

class _myserlvet implements javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
    //inserted as a
    //result of <%! int serverInstanceVariable = 1;%>
    int serverInstanceVariable = 1;
    ...

    public void _jspService( javax.servlet.http.HttpServletRequest request,
                            javax.servlet.http.HttpServletResponse response )
        throws javax.servlet.ServletException,
               java.io.IOException
    {
        javax.servlet.ServletConfig config = ...;//get the servlet config
        Object page = this;
        PageContext pageContext = ...;//get the page context for this request
        javax.servlet.jsp.JspWriter out = pageContext.getOut();
        HttpSession session = request.getSession( true );
        try {
             out.print( "<html>
" );
             out.print( "<head>
" );
             ...
             //from <% int localStackBasedVariable = 1; %>
             int localStackBasedVariable = 1;
             ...
             out.print( "<table>
" );
             out.print( "   <tr><td>" );
             //note, toStringOrBlank() converts the expression into a string or if
             // the expression is null, it uses the empty string.
             //from <%= "expanded inline data " + 1 %>
             out.print( toStringOrBlank( "expanded inline data " + 1 ) );
             out.print( "   </td></tr>
" );
             ...
        } catch ( Exception _exception ) {
           //clean up and redirect to error page in <%@ page errorPage="myerror.jsp" %>
        }
    }
}

出版物[编辑]

• JavaServer Pages, Third Edition, Hans Bergsten，O'Reilly & Associates, Inc.，Sebastopol, California, 2003. ISBN 0-596-00563-6

参见[编辑]

• JSTL
• Java EE
• JavaServer Faces
• Java Servlet
• SSJS
• WAR (file format)
• EAR (file format)
• JAR (file format)
• Apache Tomcat

外部链接[编辑]

• Sun's JSP product description
• JSR 245 (JSP 2.1)
• JSR 152 (JSP 2.0)
• JSR 53 (JSP 1.2)