JSP

二、  JSP

 

1.  JSP 简介

* 什么是 JSP？
  1. JSP（Java Server Pages，即：Java 服务器页面），是一种跨平台的动态网页技术标准，由 Sun Microsystems 公司倡导、多家公司参与建立。它在 HTML 文件中插入 Java 程序段(Scriptlet) 和 JSP 标签(tag)，从而形成 JSP 文件(*.jsp)
  2. JSP 本质上是一种简化的 Java Servlet，主要用于实现 Java web 应用程序的用户界面部分
  3. 一次编写，到处运行：用 JSP 开发的 Web 应用是跨平台的，既能在 Linux 下运行，也能在其他操作系统上运行
  4. JSP 标签通常以 "<%" 开头，以 "%>" 结束
  5. JSP 标签有多种功能，比如访问数据库、记录用户选择信息、访问 JavaBeans 组件等，还可以在不同的网页中传递控制信息和共享信息
  6. JSP 编译过程包括三个步骤：
       1）解析 JSP 文件
       2）将 JSP 文件转化为 Servlet（这种转化只是简单地将所有模板文本改用 println() 语句，并且将所有的 JSP 元素转化成 Java 代码）
       3）将 Servlet 编译成可执行类
       注意：编译是直接将编写的代码从一种语言翻译为另一种更低层级语言的过程；而转译是将代码从一种语言翻译到另一种同层级语言的过程
  7. Eclipse 会将 JSP 转译成对应的 Servlet 类（即：你的JSP名_jsp.java）存放在以下目录中
       即：eclipse-workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\work\Catalina\localhost\你的项目名\org\apache\jsp\你的JSP名_jsp.java

* Web 服务器是如何使用 JSP 来创建网页的呢？
    1）浏览器发送一个 HTTP 请求给服务器
    2）Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎
    3）JSP 引擎将 JSP 文件转化为 Servlet
    4）JSP 引擎将 Servlet 编译成可执行类，并且将原始请求传递给 Servlet 引擎（“ 容器相当于小轿车，引擎也就是发动机（干实事的）”）
    5）然后，Servlet 引擎载入并执行 Servlet 类。在执行过程中，Servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器
    6）Web 服务器以静态 HTML 网页的形式将 HTTP response 返回浏览器中
    7）最终，Web 浏览器处理 HTTP response 中动态产生的 HTML 网页，就好像在处理静态网页一样
  以上提及到的步骤可以用下图来表示：

 

2.  JSP 生命周期

* JSP 生命周期可被定义为从创建到销毁的整个过程，类似于 Servlet 生命周期，区别在于 JSP 生命周期还包括将 JSP 文件编译成 Servlet。以下是 JSP 生命周期中所遵循的四个主要阶段：
    1）编译阶段：Servlet 容器编译 Servlet 源文件，生成 Servlet 类
    2）初始化阶段：加载与 JSP 对应的 Servlet 类，创建该类的实例，并调用它的初始化方法
    3）执行阶段：调用与 JSP 对应的 Servlet 实例的服务方法
    4）销毁阶段：调用与 JSP 对应的 Servlet 实例的销毁方法，然后销毁 Servlet 实例
  很明显，JSP 生命周期和 Servlet 生命周期非常相似，下面给出图示：

/**
 * JSP 生命周期代码实例
 *
 * 代码来源于 RUNOOB.COM
 */
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>






<%! 
  private int initVar=0;
  private int serviceVar=0;
  private int destroyVar=0;
%>
  
<%!
  public void jspInit(){
    initVar++;
    System.out.println("jspInit(): JSP被初始化了"+initVar+"次");
  }
  public void jspDestroy(){
    destroyVar++;
    System.out.println("jspDestroy(): JSP被销毁了"+destroyVar+"次");
  }
%>

<%
  serviceVar++;
  System.out.println("_jspService(): JSP共响应了"+serviceVar+"次请求");// void _jspService(HttpServletRequest request, HttpServletResponse response) { // 服务端处理代码 }

  String content1="初始化次数 : "+initVar;
  String content2="响应客户请求次数 : "+serviceVar;
  String content3="销毁次数 : "+destroyVar;
%>
菜鸟教程 JSP 测试实例
<%=content1 %>
<%=content2 %>
<%=content3 %>

JSP 生命周期代码实例

 

 3.  JSP 语法

* 1. JSP 四种注释：
       A. 显式注释：指在客户端可以看见
            1）Html 注释：
                a.这种注释方法只能在 "<% %>" 外面，否则无效
                b.会被转译，也会被发送，但是不会被浏览器执行
       B. 隐式注释：指在客户端看不见，但在服务器端可以看见
            2）JSP 注释：<%-- 注释 --%>
                a.这种注释方法只能在 "<% %>" 外面，否则无效
                b.不会被发送至浏览器，甚至不会被编译
            3）Java 单行注释：// 注释
                a.这种注释方法只能在 "<% %>" 里面，否则无效
                b.会被转译，但是不会被 Servlet 执行
            4）Java 多行注释：/* 注释 */
                a.这种注释方法只能在 "<% %>" 里面，否则无效
                b.会被转译，但是不会被 Servlet 执行

* 2. JSP 三种指令：JSP 指令用来设置与整个 JSP 页面相关的属性。语法：<%@ directive attribute="value" ... %>
       1）<%@ page attribute="value" ... %> ：定义页面的依赖属性，比如脚本语言、error页面、缓存需求等等
           ① language：定义 JSP 页面所用的脚本语言，默认是 Java
           ② import：导入要使用的 Java 包，不同的包使用逗号隔开
           ③ pageEncoding：设置 JSP 文件的数据编码格式
           ④ contentType="text/html; charset=utf-8"：设置 JSP 数据响应给浏览器时，浏览器的解析和编码格式
           ⑤ session：指定 JSP 页面是否使用 Session，默认开启（true 表示开启，false 表示关闭）
           ⑥ errorPage：指定当 JSP 页面发生异常时跳转的错误处理页面
           ⑦ extends：指定 Servlet 要继承的父类（包名+类名）
           如：<%@ page language="java" import="java.util.*,java.lang.*" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
 
       2）<%@ taglib attribute="value" ... %> ：引入标签库的定义，可以是自定义标签
           如：引入 JSTL 核心标签库：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
 
       3）<%@ include file="relative URL" ... %> ：静态引入其他文件，在 JSP 文件被转换成 Servlet 的时候引入文件
           如：<%@ include file="要引入的 JSP 文件的相对路径" %>
             a.会将引入的 JSP 和当前 JSP 一起转译成同一个 Java 文件(Servlet)。在网页中也就显示了合并后的显示效果
             b.静态引入的 JSP 不会单独转译成 Java 文件(Servlet)，所以当前 JSP 和静态引入的 JSP 中不允许在 Java 代码块中声明同名变量，否则编译报错
             c.区别于动态引入： // 在 JSP 行为标签中会详细解释
             d.静态引入和动态引入的优点：降低 JSP 代码的冗余，便于维护升级

* 3. JSP 脚本代码块：<% Java 代码 %>
       1）特点：
            a.与其等价的 XML 语句： Java 代码 
            b.脚本代码块中可以包含任意量的 Java 语句、变量、方法或表达式
            c.脚本代码块中的 Java 代码会被原样转译到 JSP 对应的 Servlet 类中（即：你的JSP名_jsp.java）的 _jspService() 方法中
            d.脚本代码块中声明的变量都是局部变量
       2）缺点：
            a.使用脚本代码块在 JSP 中进行逻辑判断：书写麻烦，阅读困难

* 4. JSP 声明代码块：<%! Java 代码 %>
       1）特点：
            a.与其等价的 XML 语句： Java 代码 
            b.用于声明一个或多个 Java 变量和方法
            c.声明的 Java 变量和方法会转译到对应的 Servlet 类中（即：你的JSP名_jsp.java）作为全局变量和公共函数
       2）注意：
            a.声明代码块声明的变量和方法，需要在脚本代码块中被调用

* 5. JSP 表达式：<%= 变量名或者方法名() %>
       1）特点：
            a.与其等价的 XML 语句： 变量名或者方法名() 
            b.帮助我们快速的获取变量的值或者方法的返回值作为数据响应给浏览器
            c.可以在符合 JSP 语法要求的任意位置
       2）注意：
            a.不能在变量名或者方法后使用分号

* 6. JSP 行为标签：也被称为 JSP 动作元素，JSP 行为标签使用 XML 语法结构来控制 Servlet 引擎，行为标签基本上是一些预先就定义好的函数
       1）它能够动态插入一个文件，引导用户去另一个页面，重用 JavaBean 组件，动态定义 XML 元素，为 Java 插件产生相关的 HTML 等等
       2）语法： 或 jsp:action_name>
            a.所有的动作元素都有这两个属性：id 属性和 scope 属性
            b.id 属性是动作元素的唯一标识，可以在 JSP 页面中引用
            c.动作元素创建的 id 值可以通过 PageContext 来调用。
            d.scope 属性用于识别动作元素的生命周期
            e.id 属性和 scope 属性有直接关系，scope 属性定义了相关联 id 对象的寿命
            f.scope 属性有四个可能的值：page，request，session，application 

       3）动态引入其他文件，即在页面被请求的时候引入文件
            如：要引入的 JSP 文件的相对路径" flush="true”>
              a.会将引入的 JSP 单独转译，在当前 JSP 已经转译好的 Java 文件(Servlet)中调用引入的 JSP 的转译的 Servlet 文件。在网页中也就显示了合并后的显示效果
              b.动态引入的 JSP 单独转译，所以允许文件中声明同名变量

       4） ：把请求转到另外的页面
            如：
              a.从一个 JSP 文件向另一个文件传递一个包含用户请求的 Request 对象
              b.本质上是一次请求转发，所以地址信息不发生改变
              c.在转发标签中间可以通过添加： 标签来添加以 ? 的形式拼接在转发路径后面的数据

       5） ：用来装载一个将在 JSP 页面中使用的 JavaBean，使得我们既可以发挥 Java 组件重用的优势，同时也体现了 JSP 区别于 Servlet 的方便性
            a.在类载入后，我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索 bean 的属性

       6)  : 用来设置已经实例化的 JavaBean 对象的属性，有两种用法：
            ① 在 jsp:useBean 元素的外面（后面），即：
               
               
               注意：此时，不管 jsp:useBean 是找到了一个现有的 Bean，还是新创建了一个 Bean 实例，jsp:setProperty 都会执行
            ② 在 jsp:useBean 元素的里面，即：
               
                 
               
               注意：此时，jsp:setProperty 只有在新建 Bean 实例时才会执行，如果是使用现有实例则不执行 jsp:setProperty

       7） ：提取指定 Bean 属性的值，转换成字符串，然后输出
 
       8） 、 、  这些动作元素用来动态定义 XML 元素。动态是非常重要的，这就意味着 XML 元素在编译时是动态生成的而非静态，如（此段代码来源于 W3Cschool）：
           
              
                 Value for the attribute
              
              
                 Body for XML element
              
           
           执行时生成 HTML 代码如下：
           
              Body for XML element
           

 

4.  JSP 九大内置对象

* 1. JSP 内置对象：是指 JSP 容器为每个 JSP 页面提供的 Java 对象，开发者可以在 JSP 中直接使用它们而不用显式声明，故 JSP 内置对象也被称为 JSP 隐式对象
* 2. 注意：JSP 内置对象在 JSP 页面的 JSP 脚本代码块或者 JSP 表达式中使用，不能够在 JSP 声明代码块中使用
* 3. JSP 九大内置对象：
       1）pageContext 对象：是 javax.servlet.jsp.PageContext 类的实例，用来代表当前整个 JSP 页面
            a.封存了其他内置对象，也就是封存了当前 JSP 页面的运行信息
            b.注意：每个 JSP 页面单独拥有一个 pageContext 对象
            c.作用域：当前 JSP 页面
            d.PageContext 类定义了一些字段，包括 PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE，APPLICATION_SCOPE
            e.重要方法：
                pageContext.removeArribute("attrName");// 移除四个 scope 中相关属性
                pageContext.removeAttribute("attrName", PAGE_SCOPE);// 移除特定 scope 中的相关属性

       2）request 对象：是 javax.servlet.http.HttpServletRequest 类的实例
            a.由 Web 服务器创建，封存了当前请求数据
            b.作用域：一次请求
            c.通过请求转发，将数据流转给另一个 Servlet
       3）response 对象：是 javax.servlet.http.HttpServletResponse 类的实例
            a.由 Web 服务器创建，将请求的处理结果响应给浏览器
            b.设置响应头，重定向
       4）session 对象：是 javax.servlet.http.HttpSession 类的实例
            a.用来存储同一用户的不同请求的共享数据
            b.作用域：一次会话
       5）application 对象:也就是 ServletContext 对象，是 javax.servlet.ServletContext 类的实例
            a.一个项目中只有一个
            b.存储用户共享数据
            c.作用域：当前项目内
            d.通过向 application 对象中添加属性，当前 Web 项目中的所有 JSP 文件都能访问到这些属性

       6）config 对象：也就是 ServletConfig 对象，是 javax.servlet.ServletConfig 类的实例
            a.主要是用来获取 web.xml 中的配置数据，完成一些初始化数据的读取
            
       7）out 对象：是 javax.servlet.jsp.JspWriter 类的实例，用来在 response 对象中写入内容
            a.JSP 内部使用
            b.带有缓冲区的响应对象，效率高于 response 对象
            c.作用域：当前 JSP 页面
            d.重要方法：
                out.print(dataType dt);// 输出 Type 类型的值
                out.println(dataType dt);// 输出 Type 类型的值然后换行
                out.flush();// 刷新输出流

       8）page 对象：代表了当前 JSP 页面，相当于 Java 中的 this 对象
       9）exception 对象：包装了从当前 JSP 页面中抛出的异常信息
            a.注意：使用此对象需要在 page 指令中添加属性：isErrorPage="true"

  4. 其中，九大内置对象中的 pageContext 对象、request 对象、session 对象、application 对象也被称为四大作用域对象
       a.作用：完成数据流转