JavaWeb-JSP

其他 2019-01-18 13:20:53 阅读次数: 0

序言

　　前面讲解了Servlet，了解了Servlet的继承结构，生命周期等，并且在其中的ServletConfig和ServletContext对象有了一些比较详细的了解，但是我们会发现在Servlet中编写一些HTML代码，是很不方便的一件事情，每次都需要out.println(HTML); 因此就出现了JSP，来解决这样的问题，JSP中的内容就是html，但是能够嵌套java语言，现在来详细了解一下JSP。
　　
　　在前面的学习过程中，页面相关的内容主要是通过html文件完成，而Servlet技术主要是在获取浏览器（客户端）提交的请求数据，或者是给浏览器（客户端）响应数据。在企业开发中，前端的页面（html文件）相关设计和美化工作都是前端工程师（美工）负责，后台的Java程序是由Java开发人员完成，前端给出的页面，不能满足后台开发人员的需求，这时就需要后台开发人员在Servlet中使用response获取输出流，拼接前端页面需要的html片段，这样会导致Servlet中的Java代码十分的臃肿，而且不利于前端人员维护页面。导致前后人员之间合作出现问题。针对这些问题，sun公司设计出JSP技术来解决。

　　JSP技术：Java Server Page。它的主要功能：可以直接在JSP文件中书写html代码，但是JSP文件最后会被翻译成对应的Java代码。这个翻译工作不需要开发人员做任何的事情，而直接由Java对应的机制完成。这样就可以保证前端工程师可以直接针对JSP文件进行页面设计和修改，后台人员可以在JSP页面中添加对应的业务程序。后台人员不用再在Servlet中通过response输出大量的html片段。其实不仅仅Java使用JSP技术代替html文件。微软的.net技术也推出的asp技术代替普通的html文件，php也推出了php技术代替html文件。

1、JSP本质

(1) 什么是JSP

　　JSP(Java Server Pages):是以Java语言为基础的动态网页开发技术，

JSP的特点：

Servlet特点：在Java源码中嵌入html源码

JSP特点：在html源码中嵌入java代码

(2) JSP的运行过程

来看一个图：
这里写图片描述
1、tomcat获得JSP文件后，先将JSP转成servlet，变成xxx.java(servlet源码)；

D:\java\tomcat7.0\apache-tomcat-7.0.53\apache-tomcat-7.0.53\work\Catalina\localhost\test01\org\apache\jsp 这个之下就是存放着jsp变成的servlet文件.java和编译文件.class　

2、tomcat将java文件编译成class文件；
这里写图片描述
3、tomcat运行class文件，并将结果输出到浏览器。

(3) JSP运行实例

创建一个jsp。查看其转换后的servlet代码。

1、新建JSP文件：NewFile.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    hahaha
</body>
</html>

2、Tomcat将JSP文件转换为NewFile_jsp.java　

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class NewFile_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private javax.el.ExpressionFactory _el_expressionfactory;
  private org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public void _jspInit() {
    _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
    _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;
    try {
      response.setContentType("text/html; charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                  null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\r\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>Insert title here</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\thahaha\r\n");
      out.write("</body>\r\n");
      out.write("</html>");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try { out.clearBuffer(); } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

可以看到：

public final class NewFile_jsp extends org.apache.jasper.runtime.HttpJspBase implements org.apache.jasper.runtime.JspSourceDependent

NewFile_jsp.java继承自HttpJspBase。来看看HttpJspBase的源码：

3、HttpJspBase.java

package org.apache.jasper.runtime;

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;

import org.apache.jasper.compiler.Localizer;

/**
 * This is the super class of all JSP-generated servlets.
 *
 * @author Anil K. Vijendran
 */
public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {

    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    @Override
    public final void init(ServletConfig config) 
        throws ServletException 
    {
        super.init(config);
        jspInit();
        _jspInit();
    }

    @Override
    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info");
    }

    @Override
    public final void destroy() {
        jspDestroy();
        _jspDestroy();
    }

    /**
     * Entry point into service.
     */
    @Override
    public final void service(HttpServletRequest request, HttpServletResponse response) 
        throws ServletException, IOException 
    {
        _jspService(request, response);
    }

    @Override
    public void jspInit() {
    }

    public void _jspInit() {
    }

    @Override
    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    @Override
    public abstract void _jspService(HttpServletRequest request, 
                                     HttpServletResponse response) 
        throws ServletException, IOException;
}

可以看到：

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage

看到了一个熟悉的类，HttpServlet，我们编写Servlet时就是继承自该类，这里也是继承HttpServlet，并且HttpJspBase的源码会发现，生命周期也是有init()方法，service()方法，destory()方法，相当于_jspService()方法就是servlet的service()方法的执行，所以说JSP也是一个servlet。

　　我们在JSP写的所有html代码，都会被转换为servlet中的out.write(html)代码来输出。看图：
这里写图片描述
小总结：
这里写图片描述
　　注意：jsp生成java源码，默认第一次生成，之后直接执行，除非内容修改，具体点说，由于JSP只会在客户端第一次请求的时候被编译，因此第一次请求JSP时会感觉比较慢，而之后的请求因为不会编译JSP，所以速度就快多了，如果将Tomcat保存的JSP编译后的class文件删除，Tomcat也会重新编译JSP。在开发Web程序的时候经常需要修改JSP,Tomcat能够自动检测到JSP程序的改动，如果检测到JSP源代码发生了改动，Tomcat会在下次客户端请求JSP时重新编译JSP,而不需要重启Tomcat，这种自动检测功能默认是开启的，检测改动会消耗少量的时间，在部署web应用程序的时候可以在web.xml中将它关掉。这也就是为什么我们能够在jsp页面直接修改内容，而不用重新启动服务器的原因。因为JSP就是servlet，那么生命周期也就是跟serlvet一样。JSP和servlet有一点区别就在于：jsp是先部署后编译，而servlet是先编译后部署。

2、JSP的语法

(1) JSP注释

JSP文件中存在这几类注释：

1、<%-- --%> ：jsp注释，
2、//　    　 ：java单行注释
3、/*  */　　 ：Java多行注释
4、<!-- -->  : 这个注释，会发送到浏览器端的源码中显示
区别：
     JSP注释不会在servlet文件中显示，而java注释则会，但其所有的注释到了浏览器端，
都不会出现在源码中，只有<!-- -->这个注释会到浏览器的网页源码中去。

注释分别在servlet中如何显示的？看图：
这里写图片描述

(2) JSP模版数据

　　JSP模版元素：就是JSP中属于静态的的HTML或XML代码，它的内容给是固定的，无论程序如何运行模版数据输出到客户端浏览器时都不会发生改变，当我们创建一个JSP时，模版就已经固定了。
　　它们是JSP文件最终用来响应客户端请求的HTML页面的主体，因而它们对于JSP显示是非常重要的。然而通常在开发过程中JSP的脚本变成人员不需要关心这部分内容，因为它们主要是由美工人员完成的。

(3) JSP元素

　 JSP元素：包含脚本元素、指令元素、动作元素三个。元素决定着程序的流程，元素是不会显示到浏览器的。这几个都会在接下来讲解到。

3、JSP脚本元素

　 JSP脚本元素就是JSP文件中用Java语言编写的脚本代码。在这些代码中可以包含任意的Java代码，可以进行函数声明和变量声明、可以对表达式求值、可以通过流程控制语句产生输出。脚本元素在JSP文件中主要用来处理业务逻辑操作。在JSP文件中，根据功能和形式上的不同，可以将脚本元素进一步分为以下三类。

(1) Java代码

使用<% 编写JSP中的java代码 %>，中间java代码必须遵循Java语法：
这里写图片描述
此处为什么能够使用out输出？这里就涉及到了JSP的九大内置对象了，后面会讲解到，到时候回过头来在看看这里，就会知道为什么可以使用。

先来看看，jsp变为servlet时的代码是如何编写的：
这里写图片描述
在JSP中JSP指令(后面会讲)：

　<%@ page language="java" contentType="text/html; 
　    charset=UTF-8" pageEncoding="UTF-8"%>

这句代码在servlet就变为了

　response.setContentType("text/html; charset=UTF-8");
　//这句代码的意思就是通知tomcat和浏览器都使用UTF-8码表，并且发送回浏览器的数据类型是text/html。

这是有JSP指令中画红色部分代码转变的，而指令中的pageEncoding=”UTF-8”的意思是JSP转换为Servlet时采用UTF-8码表编码，因为可能JSP中包含中文。

　　从上面可以发现，对于JSP模版数据来说，就原封不动的使用out.write()来输出到浏览器。而对于JSP元素来说，就会变成普通的java代码，因为在servlet中，就可以直接编写java代码。

(2) 脚本元素中的表达式

　　脚本元素中的表达式将一个常量、变量或者方法的返回值输出为一个字符串。它输出的字符串作为HTML页面的一部分最终输出到客户端显示。

使用<%=xxx %>来输出结果
这里写图片描述
　　使用<%=result %>来输出结果，servlet中就会将其转换为out.print(result)进行输出。输出各种类型数据：int、double、boolean、String、Object等。
这里写图片描述

(4) 脚本元素中的声明

　　JSP中申明方法与属性(全局变量)，使用<%! 方法、属性 %>。它用来将文件中用到的变量或方法封装起来。只有声明后的变量才能在其他地方调用。

【示例】在JSP中封装一个方法，使用它来将字符转换为UTF-8。代码如下：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<!--进行函数声明。将字符统一转换为UTF-8编码方式，用于避免中文乱码-->
<% !
　   String translate(String chi){
　     String result=null;
　     byte temp[];
　     try{
　       temp=chi.getBytes("UTF-8");
　       result=new String(temp);
　     }catch(……){
　       ……
　     }
　     result result;
　  }
%>

//调用上面声明的函数，输出结果
<%
    String source="你好，世界！";
    out.println(translate(source));
%>

在JSP开发中，经常遇到中文显示问题，就可以通过以上这种方式去解决。也可以将translate()方法的声明部分做成一个专门的代码段，取名为translate.inc。当其他页面需要转换字符的功能时，使用如下的命令将该代码段加进来，然后就可以在文件中调用它了。

<% @ include file="translate.inc"%>

4、JSP指令元素

　　指令用来申明JSP页面的一些属性，比如编码方式，文档类型。我们在servlet中也会申明我们使用的编码方式和响应的文档类型的，而JSP就是用指令来申明。上面我们也说到了一条指令，也就是page指令。

JSP指令格式：

<%@ directive {attribute=value}* %>

解释：

1、directive：指令名称，例如page指令
2、attribute=value：紧跟指令名称后面的就是各种属性，以键值对的形式书写
3、*：代表后面能跟0个或多个属性。

(1) page指令

page指令：用来声明JSP页面的属性等。

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

page指令，后面跟着三个属性，分别是language、contentType、pageEncoding。这只是其中的几个属性，并没有写全，page指令允许的属性如下表所示：

属性名称　　　　　　　　取值范围　　　　　　　　　         　描述

language　　　　　　　　java　　　　　　解释该JSP文件时采用的语言，一般为java语言，默认为java
extends　　　　　　　　任何类的全名　　 编译该JSP文件时继承哪个类，JSP为Servlet，因此当指明继承普通类时需要实现Servlet的init、destroy等方法
import　　　　　　　 任何包名、类名　　 引入该JSP中用到的类、包等，import是唯一可以声明多次的page指令属性，一个import可以引用uogelei，中间用英文逗号隔开，如<%@ page import="java.util.List,java.util.ArrayList"%>
session　　　　　　　　true、false　　　　该JSP内是否内置Session对象，如果为true，则内置Session对象，可直接使用，否则反之，默认为true
autoFlush　　　　　　　true，false　　　　是否运行缓存，如果为true，则使用out.println()等方法输出的字符串并不是立刻到达客户端服务器的，而是暂时存到缓存里，缓存满了或者程序执行完毕或者执行out.flush()操作时才到客户端，默认为true。
buffer　　　　　　　　none或者数字KB　　　指定缓存大小，当autoFlush设为true时有效，例如<%@ page buffer=10kb%>
isThreadSafe　　　　　　true，false　　　　是否线程安全，如果为true，则运行多个线程同时运行该jsp程序，否则只运行一个线程，其余线程等待，默认为false
isErrorPage　　　　　　true，false　　　　　指定该页面是否为错误显示页面，如果为true，则该JSP内置有一个Exception对象exception，可直接使用，否则没有，默认为false
errorPage　　　　　某个JSP页面的相对路径　　指明一个错误页面，如果该JSP程序抛出一个未捕捉的异常，则转到errorPage指定的页面，errorPage指定的页面通常isErrorPage属性为true，且内置的exception对象为未捕捉的异常
contentType　　　　　有效的文档类型　　　　 客户端浏览器根据该属性判断文档类型，例如 HTML格式为text/html、纯文本格式为text/plain、JPG图像为image/jpeg、GIF图像为image/gif、WORD文档为application/msword，该属性常跟着charset设置编码一起，作用是通知服务器和浏览器都使用同一个码表
info　　　　　　　　　　任意字符串　　　　  指明JSP的信息，该信息可以通过Servlet.getServletInfo()方法获取到
trimDirective Whitespaces　true、false　　是否去掉指令前后的空白字符，默认为false
pageEncoding　　　　UTF-8,ISO-8859-1等　　指定一张码表来对该JSP页面进行编码。

(2) include指令

比较简单，只有一种形式:

 <%@ include file="relativeURL"%>　　

relativeURL：本应用程序内另一个JSP文件或者HTML文件的路径，例如，网址内所有页面均有一个 统一风格的导航栏 和 页脚版权，那么就可以使用该指令将其包含进来。

　　在多个页面中，每一个页面的全部内容中有一部分是固定不变的，有一部分是变动的，如果在每个页面中都将不变的代码再写一遍太麻烦了，而且一旦这些不变的内容需要改动一点点，则需要在每个页面上都修改，太麻烦了，所以我们可以把不变的代码单独抽取出来生成一个页面，在每个页面中引入这个页面即可，即使修改也只要修改抽取出来的页面即可，这就是页面引入的用处。

例如：一个网页，一般它的logo是一个页面，而版权部分是一个页面，主体部分是另外一个页面：
这里写图片描述
再具体一点：
这里写图片描述
演示：一共创建top.jsp，body.jsp，footer.jsp和main.jsp四个页面，将top.jsp，body.jsp，footer.jsp三个页面引入到main.jsp页面上：
这里写图片描述
　　特点：include指令会将包含页面的源代码添加到使用include指令的页面中来，然后编译成class文件，而等下会讲到的一个JSP行为，作用跟include指令一样，但是不同的是，include行为是运行时单独执行包含页面，然后把执行的结果包含到本页面来，属于先运行后包含。

(3) taglib指令

　　JSP支持标签技术，后面会讲到标签的用法，jstl标签库的使用等。 taglib指令：主要是在页面上引入其他已经定义好的标签或者函数（其实就是在引入Java程序或者理解成类）。

　　在JSP页面上是可以书写Java代码，也可以书写html代码，一般公司中页面是由美工维护，而我们负责后台开发。因此不建议在JSP页面上嵌入过多的Java代码。这时就需要把Java代码从页面中剔除。将页面上需要书写的所有标签都封装到对应的单独的Java程序中，然后在页面中使用taglib指令引入。引入的这些Java程序可以通过对应的标签体现。其实这些标签的底层还是Java代码。仅仅只是JSP页面上没有了Java代码而已。
　　
例如：这里引入一个使用频率非常高的标签作为演示：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

在taglib指令中的属性：

 uri：是当前标签对应的Java代码封装之后绑定的名称空间（给java代码专门的命名）
 prefix：它是当前在页面上可以使用的标签的前缀。

JSP中的代码体现：
这里写图片描述
页面显示的效果：
这里写图片描述

5、JSP动作元素

　　前面讲了JSP语法，介绍了JSP页面中的内容有哪些，分别有什么作用，就两个东西，模块数据和元素。其中元素有包括脚本，指令，标签，脚本就是JSP中嵌入java代码，指令作用就是申明页面的属性，那标签是干嘛的，标签分为JSP自带内置的标签，和通过taglib指令来使用JSP标签库，或者自定义标签。现在我们先来讲一些JSP内置的标签。

　　虽然sun公司在设计JSP技术的时候，允许在JSP页面中嵌入java代码，但是这样会导致html、js、java等代码严重的耦合在同一个文件中，导致后期维护十分的麻烦。于是sun公司就将可以在jsp页面上书写的java提前已经封装到对应的标签中，然后让开发者在jsp页面上通过使用标签的方式来使用相应的java代码。其实这些标签的用途并不大，后期如果真的需要功能强大的java代码，需要开发人员自己手动封装标签的。

　　JSP内置的标签就被称为JSP行为(JSP Actions)。只要书写很少的标记代码就能使用JSP提供的丰富功能，JSP行为其实是对常用的JSP功能的抽象与封装，可以取代jsp脚本，让JSP中就少一些嵌入java代码的地方。

格式：

<jsp:elements ｛attribute="value"｝* />　　

解释：

jsp：标签的前缀，说明是jsp内置的标签，
elements：行为的名称，
attribute=value：使用键值对来编写属性
*：能指定0个或多个属性对

(1) 包含元素 include

　　　include行为用于运行时包含某个文件，如果被包含的文件为JSP程序，则先会执行JSP程序，然后在把执行的结果包含进来。作用是跟include指令一样的，唯一的区别就在于，include指令是将被包含的文件的源码加入到了本JSP程序中，然后在进行编译，属于静态包含，而include行为只是将被包含的文件的运行结果包含进自己，属于动态包含。
这里写图片描述

(2) 转发元素 forward

实现请求转发功能，Servlet中通过

request.getRequestDispatcher("someServlet").forward(request,response);

而在JSP中也能够实现相同的功能，只不过用的是forward行为，实际上forward行为就是对其进行了封装。

格式：

<jsp:forward page="someServlet">
  <jsp:param name="param1" value="value1"/>
  <jsp:param name="param2" value="value2"/>
</jsp:forward>

其中：

page:需要跳转到的页面或者servlet；
<jsp:param/>参数行为：带一些参数过去，name、value是以键值对的形式带过去的。

例如：
这里写图片描述
NewFile_jsp.java
这里写图片描述　　　　　　
使用return的好处是执行完上面的转发，就直接return，没有必要在执行下面的代码了，对参数使用了URLEncode进行编码，说明该可以直接传递中文，但是前提是要设置request.setCharacterEncoding(“UTF-8”);为什么这样做，看上面框起来中的代码。

(3) JavaBean调用元素 useBean

　　　Java bean行为是一组与Java Bean相关的行为，包括useBean行为、setProperty行为、getProperty行为等。

　　　JavaBean就是普通的Java类，也被称为POJO，只有私有的属性与对应的getter方法和setter方法，注意其中当私有的属性为boolean类型时，习惯上一般把getter方法写成isXxx();而不是getXxx()。

useBean行为　　

<jsp:useBean id="beanObject" class="className" scope="Value">　　

作用：在jsp中定义一个java bean对象， 　　

1、id：指明Java Bean对象的名称，JSP中可以使用该名称引用该Java Bean对象，相当于给new出来的对象取一个变量名，

2、class：Java Bean类的全名

3、scope：该java bean对象的作用范围，可以写的就四个，也就是JSP的四大作用域，page、request、session、application。
  （1）page：只能在当前JSP页面使用，如果不在JSP页面，那么就会失效
  （2）request：这个前面学过，A页面请求转发到B页面，那么使用的是同一个request，那么A,B页面都算是request的作用域，也就是通过请求转发的页面都是其作用域。
  （3）session：该作用域在一个web项目下任何位置应该读访问的到，只要cookie不关闭，并且cookie设置　　的访问路径为"/"。
  （4）application：其实就是Servlet中的servletContext，服务器下的所有项目都能访问到。

(4) 属性设置元素 setProperty

格式：

<jsp:setProperty name="beanName" property="propertyName" value="">

作用：对Java Bean对象进行属性的设置。

name：    java bean对象的名称，也就是在useBean行为中的id
property：对象中的属性名，
value：   要对其属性进行赋值的值

(5) 属性获取元素 getProperty

格式：

<jsp:getProperty name="beanName" property="propertyName" />

作用：获取JavaBean对象的某个属性值。

name:    java bean 对象的名称，也就是在useBean行为中的id
property：对象的属性名

例子：User.java　

public class User {
    private int id;
    private String username;
    private String password;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }   
}

NewFile.jsp

<body>
    <!-- 创建一个新的javabean对象user,会先判断在page作用域内是否有叫user对象的javabean，如果有则取它，如果没有则创建新的javabean对象  -->
    <jsp:useBean id="user" class="a.User" scope="page"></jsp:useBean>
    <!-- 对javabean对象的username进行赋值 -->
    <jsp:setProperty property="username" name="user" value="wu"/>
    <!-- 获取javabean对象的username属性 -->
    <jsp:getProperty property="username" name="user"/>
</body>

可以查看NewFile.jsp变为servlet后的源代码，看看我们写的javabean行为会被转换为何种语句：
这里写图片描述
　　这里出现了一个JSP九大内置对象中的一个，pageContext。现在简单提一句，pageContext就是JSP页面的管理者(上下文)，其中的getAttribute(name，scope)方法是获取指定作用域中的数据的，如果getAttribute(name)方法的话，默认是对page作用域进行操作，findAttribute(name)依次从page、request、session、application获得内容。　

　　在第一个红框中，就代表中我们的useBean行为，其中进行了一次判断，就是如果在page作用域中找不到user这个对象，那么就创建一个新的，否则就使用找到的这个user对象，

　　第二个红框中，代表着我们的setProperty行为，先找到user对象，然后在对其属性进行赋值。

　　第三个红框中，代表着我们的getProperty行为，也是先找到user对象，然后在获取其属性的值。

　　注意：对于Javabean行为来说，有一个特点的地方，就是当请求过来的参数对应Javabean的属性时，可以为其一次性设置所有的值。

格式如下：

//设置user的所有属性，属性值从request中自动取得，*代表所有属性。
<jsp:setProperty name="user" property="*" />

6、JSP九大内置对象

　　　之前那么一大段内容，就是为了讲解什么是JSP，JSP中的内容是怎么样的，到这里应该知道的差不多了， 但我们还要深入了解一些东西，我们知道JSP中的内容就只有两种，模版数据，和元素，元素就包括了指令呀，脚本呀，标签(行为)呀，脚本会慢慢被标签全部代替，也就是说JSP中基本上不会嵌入Java代码，但是我们也知道JSP会转换为servlet，在Servlet中，输出数据时，都需要通过response.getWrite()；但是在JSP中，直接使用out对象进行输出，为什么呢？这就是因为out为JSP的一个隐藏对象，JSP中内置了9个隐藏对象，使得JSP比Servlet使用起来更简单，更方便，这九个对象分别为：page、config、application、request、response、session、out、exception、pageContext。

page：      page对象代表当前JSP页面，是当前JSP编译后的Servlet类的对象。相当于this。
config：    标识Servlet配置，类型：ServletConfig，api跟Servlet中的ServletConfig对象是一样的，能获取该servlet的一些配置信息，能够获取ServletContext
application：标识web应用上下文，类型：ServletContext，详情就看Servlet中的ServletContext的使用
request:    请求对象，类型：httpServletRequest
response:   响应对象，类型：httpServletResponse
session：   表示一次会话，在服务器端记录用户状信息的技术
out：       输出响应体，类型：JspWriter
exception   表示发生异常对象，类型 Throwable，在上面我们介绍page指令中的一个errorPage属性时就有说到他
pageContext：表示 jsp页面上下文（jsp管理者），类型：PageContext

来看源码：
这里写图片描述
标记了红色的对象就是JSP独有的，其他的都是Servlet中的老东西。在这个由jsp转换为servlet的文件中，只能看到8个内置对象，少了exception对象，因为我们在将page指令时，说过一个isErrorPage属性，默认是false，被关闭了，所以其中并没有exception对象。

(1) out 对象

类型：JspWriter

　 jsp 输出底层使用 response.getWriter()；什么意思呢？这里就要讲解一下JSP缓存和Servlet缓存了，输出的过程是这样的：
这里写图片描述
JSP页面转换为Servlet后，使用的out对象是JspWriter类型的，所以是会先将要发送的数据存入JSP输出缓存中，然后，等JSP输出缓存满了在自动刷新到servlet输出缓存，等serlvet输出缓存满了，或者程序结束了，就会将其输出到浏览器上。除非手动out.flush()。

验证servlet输出缓存和JSP输出缓存和我们上面所说的是正确的。
这里写图片描述
　 分析：如果按没有jsp缓存和servlet缓存的话，输出的结果应该是aaaabbbbcccc，但是输出的却是bbbbaaaacccc，为什么呢？按照我们上面所说的原理进行分析，out对象是先将其输出到JSP缓存中，所以aaaa加入了jsp缓存，而response.getWriter().print(“bbbb”)是直接将bbbb输出到servlet缓存中，然后又使用out对象将cccc输出到jsp缓存，到程序结束，servlet缓存中有bbbb，然后jsp会将缓存中的内容就刷新到servlet缓存中，serlvet就是bbbbaaaacccc了，然后到浏览器也就得到我们的输出结果了。
这里写图片描述
如果在12行将注释去掉，那么输出的结果又会是什么呢？答案就是aaaabbbbcccc，过程自行分析。

(2) exception 异常对象

　　包含了异常的信息。使用它，必须结合page指令中的isErrorPage属性和errorPage属性。

【示例】exception.jsp抛异常的一个NullPointException，并且跳转到error.jsp错误显示页面。errorPage属性的意思是如果发生未捕捉到的异常，将会跳转到error.jsp页面。
这里写图片描述
error.jsp（其isErrorPage属性说明该页面是一个错误显示页面，则可以使用exception对象）
这里写图片描述
访问http://localhost:8080/test01/exception.jsp，观察结果：
这里写图片描述
【题外话】
一般开发的时候，会把整个项目中的常见的错误处理配置到当前项目的web.xml文件中。
这里写图片描述
将此项目设置错误信息配置后，访问本项目时出现404错误时浏览器会自动识别错误状态码并跳转到404.jsp页面，访问本项目时出现500错误时浏览器会自动识别错误状态码并跳转到500.jsp页面。

好处：如果没有设置友好页面，那么如果访问出现500错误并显示到浏览器页面上，显得网站做的太low了，竟然还会出现500错误。

(3) pageContext 对象

　　这个功能就比较强大了，比较牛逼，基本上什么他都有，因为是它是JSP页面的管理者(上下文)，所以JSP中的内置对象呀，它统统能够获得，下面介绍它的API。

1、获得其它八大内置对象 getXxx()
　  　pageContext.getOut();　　//获得out对象
      pageContext.getApplication();　　//获得application对象
                  等等....
2、对作用域的属性进行操作(四大作用域)
      对默认作用域的属性进行操作:page
      pageContext.getAttribute(name);　　//获得page作用域数据
      pageContext.setAttribute(name,value);　　//给page作用域设置内容
      pageContext.removeAttribute(name);　　//给page作用域移除内容

3、对指定作用域的属性进行操作
    　getAttribute(name,scope);　　//获得 指定作用域中的数据
      setAttribute(name,value);　　//给指定作用域设置内容
      removeAttribute(name ,scope)  移除指定作用域的内容（page/request/session/application）

4、提供作用域常量
　    PageContext.PAGE_SCOPE　　page
　　  PageContext.REQUEST_SCOPE　　request　　　　　　
　　　PageContext.SESSION_SCOPE　　response
　　　PageContext.APPLICATION_SCOPE　　application

5、一次获得指定名称内容
　　　findAttribute(name);　　//依次从page、request、session、application 获得内容

7、JSP的四大作用域

　　JSP的四大作用域指：page、request、session、application。这四大作用域，其实就是其九大内置对象中的四个，为什么说他们也是JSP的四大作用域呢？因为这四个对象都能存储数据，比如request.setAttribute()注意和request.setParameter()区分开来，一个是存储在域中的、一个是请求参数，session.setAttribute()、application其实就是SerlvetContext，自然也有setAttribute()方法。而page作用域的操作就需要依靠pageContext对象来进行了。在上面我们也有提到JSP的四大作用域，

1、page作用域：  
    代表变量只能在当前页面上生效。
2、request：    
    代表变量能在一次请求中生效，一次请求可能包含一个页面，也可能包含多个页面，比如页面A请求转发到页面B。
3、session：    
       代表变量能在一次会话中生效，基本上就是能在web项目下都有效，session的使用也跟cookie有很大的关系。
   一般来说，只要浏览器不关闭，cookie就会一直生效，cookie生效，session的使用就不会受到影响。
4、application：
     代表变量能一个应用下(多个会话)，在服务器下的多个项目之间都能够使用。比如baidu、wenku等共享帐号。

总结

　　通过上面一大堆一大堆的学习，我们应该知道这些东西：

1、什么是JSP？
　　JSP本质上就是一个servlet，因为servlet输出html太麻烦了，所以就有了JSP，JSP就是专门用来书写html的，当然其中也能写java代码。

2、JSP的内容包括什么？
　　模版数据和元素。其中元素有包括脚本(java代码)、指令(页面属性)、和行为(标签，为了JSP中不嵌入那么多java代码衍生的)

3、JSP中九大内置对象是哪九个？
　　　九大内置对象，page、config、appliction、request、response、session、out、exception、pageContext。

4、九大内置对象和servlet中对象的关系

page就是jsp转换为servletservlet对象本身，也就是this
config -- Servlet中的servletConfig
application -- Servlet中的ServletContext
request　　-- Servlet中的request
response　 -- Servlet中的response
session　　-- Servlet中的session　　　　
out　    　--　JspWriter
exception　　-- 异常对象
pageContext　-- 表示 jsp页面上下文（jsp管理者） 类型：PageContext，

　　其中pageContext对象最牛逼，有了他就拥有了天下，哈哈~

5、JSP中的四大作用域。
　　　page、request、session、application。其中操作page域中属性需要借助pageContext对象。

6、JSP中还有其他两大块内容
　　　一个是EL表达式，很重要，另一个是jstl标签库的使用，也很重要，在接下来的两节中，就会讲解到。敬请期待。

猜你喜欢

转载自blog.csdn.net/weixin_39190897/article/details/82493217
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022