JSP快速学习指南

最新推荐文章于 2024-04-09 15:55:33 发布

iversonlee

最新推荐文章于 2024-04-09 15:55:33 发布

阅读量953

点赞数

分类专栏：【java ee】文章标签： jsp javabeans bean servlet html include

【java ee】专栏收录该内容

22 篇文章 0 订阅

订阅专栏

第一章 JavaServer Pages入门
什么是JavaServer Pages?
JavaServer Pages是一种用于开发包含有动态内容的Web页面的技术。JSP页面包含着标准的标记语言元素，如HTML标记，还包含有一些特殊的JSP元素，从而允许服务器在页面中插入动态内容。

JSP的优点
* JSP同时支持基于脚本和基于元素的动态内容，并允许开发人员创建定制标记库来满足特定于应用的需求。
* JSP页面可以编译从而完成高效的服务器处理。
* JSP页面可以与处理业务逻辑的Servlet结合使用，这是Java Servlet模板引擎所推崇的模式。
* JSP是一个规范，而不是一个产品。
* JSP是J2EE的一个集成部分，而J2EE是面向企业类应用的一个完整平台。

第二章 JSP概述
JSP处理
服务器需要一个JSP容器(JSP container)来处理JSP页面。JSP容器要负责截获对JSP页面的请求。为了处理页面中的所有的JSP元素，容器首先要将JSP页面转换为一个Servlet，这称为JSP页面实现类(JSP page implementation class)。这种转换相当简单，所有模板文本都转换为println()语句，而所有JSP元素则转换为实现相应动态行为的Java代码。然后容器再编译此Servlet类。

JSP元素
可以使用的JSP元素有三类：指令(directive)、动作(action)、脚本(scripting)。在JSP2.0中增加了一个新的构造，即EL(Expression Language，表达式语言)表达式。

指令元素
它指定了有关页面本身的信息，这些信息在请求之间一直保持不变。
例如：
<%@ page ... %>        定义依赖于页面的属性
<%@ include ... %>    在翻译阶段包含一个文件
<%@ taglib .. %>    声明一个标记库

标准动作元素
动作元素通常基于某些信息完成一些动作，每次浏览器请求JSP页面时都需要这些信息。
例如：
<jsp:useBean>        置一个JavaBeans组件在页面中可用
<jsp:getProperty>    从一个JavaBeans组件取得一个性质值，并将其增加到响应中

定制动作元素和JSP标准标记库
JSP规范定义了如何开发定制动作(custom action)来扩展JSP语言，可以将定制动作开发为Java类，也可以开发为带有JSP元素的文本文件。JSTL(JSP Standard Tag Library，JSP标准标记库)就是这样的一个扩展。

脚本元素
利用脚本元素可以在一个JSP页面中增加小段代码。
例如：
<% ... %>    Scripting(小脚本)，用于嵌入脚本代码
<%= ... %>    表达式
<%! ... %>    声明

EL表达式
EL是一种简单的语言，用于访问请求数据和通过应用类置为可用的数据。

JavaBeans组件
简单地说，JavaBeans组件就是遵循某种编码约定的Java类。JavaBeans组件通常用做应用实体表述信息的容器。

第三章生成动态内容
第一个JSP页面
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>JSP is Easy</title>
</head>
<body bgcolor="white">

    <h1>JSP is as easy as ...</h1>

    <%-- Calculate the sum of 1 + 2 + 3 dynamically --%>
    1 + 2 - 3 = <c:out value="${1 + 2 - 3}" />

</body>
</html>

JSP注释
样式：
<%-- Calculate the sum of 1 + 2 + 3 dynamically --%>

模板文本template text
加粗的内容即是模板文本，它就是常规的HTML：
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>JSP is Easy</title>
</head>
<body bgcolor="white">
    <h1>JSP is as easy as ...</h1>
    <%-- Calculate the sum of 1 + 2 + 3 dynamically --%>
    1 + 2 - 3 = <c:out value="${1 + 2 - 3}" />
</body>
</html>

JSP动作元素
动作表示为JSP页面中类HTML(HTML-like)的元素。如果动作元素有动作体，则表示为一个开始标记(可能带有属性/值对)、一个动作体，以及一个结束标记。
<prefix:action_name attr1="value1" attr2="value2">
action_body(动作体)
</prefix:action_name>
如果没有动作体，可以简写为
<prefix:action_name attr1="value1" attr2="value2" />
动作元素(通常也称为标记)被分组置于库中，这些库成为标记库(tag librarie)。

JSP表达式语言
JSTL 1.0引入了一种简单的表达式语言(Expression Language, EL)，从而可以基于取自不同来源的运行时数据设置动作属性。
EL表达式总是以${分隔符开头，并以}结束。

第四章 JavaBeans

什么是bean？
bean就是遵循某些代码约定的Java类，从而可以在更大型的应用中作为组件由工具加以使用。JavaBeans规范将bean总结为支持以下特性的类：
* 自省(Introspection)，从而使构建工具可以分析出bean如何工作。
* 自定(Customization)，从而在使用一个应用构建工具时，用户可以定制bean的外观和行为。
* 事件(Event)，作为一个简单的通信信号量从而向bean通知其感兴趣的信息。
* 性质(Property)，既可以通过一个工具来完成定制，也可以用于程序化使用。
* 持久性(Persistence)，从而可以在一个应用构建工具中定制bean，然后保存其状态，并在以后重新载入。

JavaBeans命名约定
bean性质要通过获取方法(getter)和设置方法(setter)来访问，它们统称为bean的存取方法(accessor)。获取方法和设置方法名分别包括单词get或set，再加上性质名(各单词首字母大写)。常规获取方法没有参数，不过会返回性质类型的一个值，而设置方法则有一个性质类型的参数，且返回类型为void。
示例：
package net.jialing.beans;

import java.io.Serializable;

public class HelloBean implements Serializable {
    private String welcome = "Hello World! It's my first JavaBean!";

    public HelloBean() { }

    public String getWelcome() {

            return welcome;
    }

    public void setWelcome(String s)
    {
        welcome = s;
    }
}

为bean类使用一个包名
可以通过Java语句做到：
package com.company.beans
public class MyBean {
...
}
如果未声明包名，就不能以一种可移植的方式在JSP页面中使用bean。

bean类必须有一个无参数的构造函数。

在JSP页面中声明bean
示例：
<html>
<head>
    <title>Test Bean</title>
</head>
<body bgcolor="white">
    <h1>Test Bean</h1>

    <jsp:useBean id="hello" class="net.jialing.beans.HelloBean" />

    <h2> <jsp:getProperty name="hello" property="welcome" /> </h2>

</body>
</html>

<jsp:useBean>动作是JSP标准动作之一。此动作将创建由class属性所指定bean类的一个实例，并将其与id属性所指定名相关联。这个名字在此页面必须是唯一的，而且必须是一个合法的Java变量名。

读取bean性质

使用<jsp:getProperty>动作
要将welcome的属性值包含到页面中，只需使用以下标记：
<jsp:getProperty name="hello" property="welcome" />

使用JSP表达式语言
实现上述功能，只需这样：
${hello.welcome}

设置bean性质

使用<jsp:setProperty>动作
<jsp:setProperty name="h" property="hello" value="OK,man!!!"/>

示例：
<html>
<head>
    <title>Test Bean</title>
</head>
<body bgcolor="white">
    <h1>Test Bean</h1>

    <jsp:useBean id="h" class="net.jialing.beans.HelloBean" />
    <h2> ${h.hello} </h2>

<jsp:setProperty name="h" property="hello" value="OK,man!!!"/>

    <h2> ${h.hello} </h2>

</body>
</html>

使用JSTL <c:set>动作
<c:set target="${hello}" property="welcome" value="OK,man!!!" />

第五章定制标记库和JSP标准标记库

什么是定制标记库？
JSP标准动作都是为JSP页面中通常需要的功能所提供的类HTML元素。为了扩展动作元素集，可以开发新的动作，一种方式是由程序员开发为Java类，另一种方式是由网页设计人员开发为标记文件(tag files)，这是一种特殊类型的JSP文件。这些动作都被称为定制动作(custom action)。
从本质上说，定制动作要么实现为一个Java类，要么实现为一个标记文件。类或标记文件的名字以及容器调用定制动作所需的其他信息均在一个名为TLD(Tag Library Descriptor，标记库描述文件)的文件中指定。定制标记库(Tag Library)就是TLD以及对应一组相关定制动作的全部文件的集合。

开发简单的标记处理器

首先实现标记处理器类：
package net.jialing.tags;

import java.io.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;

public class HelloTag extends SimpleTagSupport {

    private String name="";

    public void setName(String n)
    {
        name = n;
    }

    public void doTag() throws JspException, IOException {

        String output;
        if(name=="")
            output = "Hello!";
        else
            output = "Hello "+name+"!";

        getJspContext().getOut().println(output);
    }
}

此标记处理器类扩展了SimpleTagSupport类，从而可以轻松地得到大多数SimpleTag接口方法。它仅对一个名为name的属性实现了一个设置方法，并实现了doTag()方法。

下一步创建TLD文件。以下是一个库的最小TLD文件：
<?xml version="1.0" encoding="ISO-8859-1" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">

<tlib-version>1.0</tlib-version>
<short-name>test</short-name>
<uri>net.jialing.tags</uri>

<tag>
    <name>hello</name>
    <tag-class>net.jialing.tags.HelloTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <name>name</name>
    </attribute>
</tag>
</taglib>
将此TLD文件置于应用的WEB-INF/tlds目录，可以取名为mylib.tld。

第三步，JSP页面可以使用该动作了：
<%@ taglib prefix="jialing" uri="net.jialing.tags" %>
<html>
    <body bgcolor="white">
        <jialing:hello name="Michael" />
    </body>
</html>

使用bean还是定制动作？
答案是“看情况”，bean擅长作为信息载体，而定制动作在处理信息方面更加突出。定制动作可以将bean用做输入和输出。

第六章处理输入和输出

用JSTL动作访问参数值
示例：
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>User Info Entry Form</title>
</head>
<body bgcolor="white">
    <form action="input.jsp" method="post">
        <table><tr>
            <td>Name: </td>
            <td><input type="text" name="userName"></td>
            </tr>
            <tr>
            <td></td>
            <td><input type="submit" value="Send Data"></td>
            </tr>
        </table>
     </form>
     You entered:<br>
     Name: <c:out value="${param.userName}" /><br>
</body>
</html>

param是一个隐式的EL变量，它表示发送至页面的所有的请求参数的一个集合。

第七章在JSP页面、请求和用户间共享数据

将控制从一个页面传递到另一个页面
<jsp:forward page="somepage.jsp" />
<jsp:forward>动作会停止一个页面的处理，并开始处理page属性所指定的页面，这称为目标页面(target page)。这种控制绝对不能返回到原页面。
目标页面可以访问请求的所有相关信息，包括所有请求参数。将控制传递到另一个页面时，通过一个或多个嵌套<jsp:param>动作元素，还可以增加另外的请求参数。
<jsp:forward page="somepage.jsp" >
   <jsp:param name="msg" value="msg value" />
</jsp:forward>

重定向
<c:redirect>
属性：

url	链接地址
context	上下文路径，可选

第八章将定制标记库开发为标记文件
从JSP规范2.0以来，定制标记库动作可以采用两种方法实现：一种是作为Java类，另一种是作为包含有JSP元素的常规文本文件。

创建和使用标记文件
标记文件(tag file)是包含有JSP元素的文本文件，这些JSP元素实现了定制动作的功能。必须使用.tag文件扩展名，以使Web容器能识别此类文件。创建一个标记文件与创建JSP页面并无不同。标记文件一旦创建和安装，类似于用Java实现的定制动作，也能用同样的方式使用。
示例：copyright.tag
<%@ tag body-content="empty" %>

<jsp:useBean id="now" scope="application" class="java.util.Date" />
Copyright © ${now.year + 1900} Jialing.net

多数情况下，标记文件的作者只关心示例所用的属性，即body-content。这个属性定义了定制动作元素的体应当如何处理，它必须取以下值之一：empty、scriptless(默认)或tagdependent。如果取值为empty，那么试图使用定制动作元素的体将会导致一个语法错误。scriptless值表示体中可以包含任何JSP元素，脚本元素除外。tagdependent值表示动作元素体则处理为纯模板文本。

JSP页面若要使用由Web应用结构中的标记文件所表示的标记库，就必须使用taglib指令来声明，与前面章节略有不同：
...
<%@ taglib prefix="my" tagdir="/WEB-INF/tags" %>
...
<html>
    <body>
    ...
    <my:copyright />
    </body>
</html>

在此使用的是tagdir属性而不是uri。tagdir属性值是一个上下文相对路径。
JSP容器处理此JSP页面时，它会在WEB-INF/tags目录中找到copyright.tag文件，并将其转换为容器可以调用的格式。转换细节在JSP规范中未做限制，这样容器开发商就可以提供更灵巧的实现。Tomcat将标记文件转换为一个Java类，并进行编译。

访问属性值
示例：hello.tag
<%@ tag body-content="empty" %>
<%@ attribute name="name" required="true" %>
<h1> Hello ${name} !</h1>

使用未声明属性
有时声明所有属性是一件很琐碎的事情，这时可以使用tag指令的dynamic-attributes属性。此属性声明了该标记文件能够接受任何定制动作元素属性。
示例：header.tag
<%@ tag body-content="empty" dynamic-attributes="dynattrs" %>
<%@ attribute name="caption" required="true" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<table
<c:forEach items="${dynattrs}" var="a">
    ${a.key}="${a.value}"
</c:forEach>
>
<caption>${caption}</caption>
<tr>
    <th>Name</th>
    <th>Value</th>
</tr>
<c:forEach items="${header}" var="h">
    <tr>
      <td>${h.key}</td>
      <td>${h.value}</td>
    </tr>
</c:forEach>
</table>

用在JSP文件中：header.jsp
<%@ page contentType="text/html" %>
<%@ taglib prefix="my" tagdir="/WEB-INF/tags" %>

<html>
<head>
    <title>Headers</title>
</head>
<body bgcolor="white">
    <my:headers caption="Request Headers"
      border="1" cellspacing="0" cellpadding="5" />
</body>
</html>

处理动作体
下面一个示例将HTML中特殊的专用码转换未HTML元素：
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="my" tagdir="/WEB-INF/tags/mytags" %>

<%-- Create test data --%>
<c:set var="message">
This is just a lot of text that the browser will format to
fit the browser window. Attempts to <blink> add HTML elements
are dealt with by conversion to character entities.
[code]
This part I want the browser to leave alone, so that
all my indentations are left intact:

    public class Foo {
      public String getBar() {
        return bar;
      }
    }
[/code]
And then some regular text again.
</c:set>
<html>
<head>
    <title>Online Forum</title>
</head>
<body bgcolor="white">
    <h1>Online Forum</h1>
    Here's a formatted message:
    <p>
      <my:htmlFormat>
        ${message}
      </my:htmlFormat>
    </p>
</body>
</html>

处理体：htmlFormat.tag
<%@ tag body-content="scriptless" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%-- Capture the body evaluation result in a variable --%>
<jsp:doBody var="bodyRes" />

<%-- Convert special characters to character entities --%>
<c:set var="escapedBody" value="${fn:escapeXml(bodyRes)}" />

<%-- Replace "[code]/[/code]" with "<pre>/</pre>" --%>
<c:set var="convBody"
value="${fn:replace(escapedBody, '[code]', '<pre>')}" />
<c:set var="convBody"
value="${fn:replace(convBody, '[/code]', '</pre>')}" />

<%-- Output the result --%>
${convBody}

标准动作<jsp:doBody>只能用于标记文件中。它将计算定制动作元素的体，这说明体中的所有的动作元素都要得到调用，它们生成的输出要与模板文本相混合。
<jsp:doBody>的属性

var	可选，将体的计算结果作为一个String加以保存的变量的名
varReader	可选，将体的计算结果作为一个java.io.Reader加以保存的变量的名
scope	可选，变量的作用域，可取值包括：page、request、session或application。默认为page

第九章拾遗补缺
包含页面片断
JSP include指令会在翻译阶段读取指定页面的内容(JSP页面转换为Servlet时)，并将其与原始页面合并：
<%@ include file="header.htmlf" %>

include指令与<jsp:include>动作之间的区别

语法	何时使用	内容
<%@ include file="URI" %>	翻译阶段	在JSP页面转换为Servlet之前与静态文本合并
<jsp: include page="URI" flush="true\|false" />	请求处理阶段	执行页面或Servlet所生成的响应文本