Jsp入门实战上-JavaWeb我画你阅

前面讲了servlet入门实践现在开始介绍jsp入门实践，开发环境的搭建请参考我前面的tomcat的文章，jsp入门教程分为上下两部分，第一部分简单讲解：jsp语法的规范，以及三大编译指令，七个动作指令和九大内置对象,生命周期讲解等。

全部代码下载：链接

1.jsp简介：

JSP全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计，它[1] 是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML（标准通用标记语言的子集）文件(.htm,.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件，后缀名为(*.jsp)。用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。
第一个jsp程序：

在eclipse中建立动态web工程
在WebContent上右击建立jsp文件
在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>
<%
  out.print("hello peace");
%>
</body>
</html>

在浏览器中输入如下：http://localhost:8080/工程名/NewFile.jsp
显示如下：
JSP作为servlet的变体，jsp的文件会被翻译成servlet文件：文件位置为Tomcat按住给你目录：apache-tomcat-7.0.64/work/Catalina/localhost/stuJsp/org/apache/jsp

打开java文件可以看到该文件根servlet的文件类似：有_jspInit()，jspDestroy()，_jspService()方法。并将jsp文件中的代码生成了_jspService()方法中的代码

2.JSP语法：

2.1.JSP脚本：

脚本程序，就是为了在HTML中穿插java代码，可以包含任意语法真确的java语句，变量，方法或表达式。生成servlet源码时该处的代码被放到_jspService()方法中

脚本程序的语法:
<% 代码片段 %>
就像第一个jsp程序那样

<%
  out.print("hello peace");
%>

注意：脚本中不能出现标签和jsp元素，记住只能写java就行；但是可以穿插写：如下：

<%
  for(int i=0;i<5;i++)
  {
    out.print("hello peace"+i);
%>
  <br/>
 <%
   out.print("换行符穿插在中间了,一样会被循环输出");
  }//for循环结束
 %>

2.2.JSP声明：

一个声明语句可以声明一个或多个变量、方法，供后面的Java代码使用。在JSP文件中，您必须先声明这些变量和方法然后才能使用它们。生成servlet源码时该处的代码成为类的属性和方法;

JSP声明的语法：
<%! declaration; [ declaration; ]+ … %>
演示如下：

<%! private int i=10; %> 
 <%!
    public void test(){
     int a=0;
     int b=2;
     a=a+b;
     System.out.print(a);
 }
 %>

查看生成的servlet文件可以知道刚才在jsp声明的变量和方法，成为了相应的属性和方法

2.3JSP表达式：

一个JSP表达式中包含的脚本语言表达式，先被转化成String，然后插入到表达式出现的地方，作用相当于脚本中的out（输出）
由于表达式的值会被转化成String，所以您可以在一个文本行中使用表达式而不用去管它是否是HTML标签。
表达式元素中可以包含任何符合Java语言规范的表达式，但是不能使用分号来结束表达式。
生成servlet源码时该处的代码被放到_jspService()方法中

JSP表达式的语法格式
<%= 表达式 %>
演示如下：

<%--在脚本处声明的变量是局部变量不能带有修饰符 --%>
    <%
      String nick="sisi";
      int a=10,b=10;
    %>
    3.jsp表达式：<br/>
    <%--表达式可以输出相当于out.write 不需要分号结束--%>
      <%=(a-b) %>
      <%=nick %>
      <hr/>

2.4JSP注释：

JSP注释不会出现在html的源码中可以用来注释jsp的代码，html注释会出现在html的源码中；

JSP注释的语法格式：
<%– 这里可以填写 JSP 注释 –%>
演示如下:

 1.jsp注释：<br/>
  <%-- 这些注释不会出现在html的源码中 可以用来注释jsp的代码--%>

3.三大编译指令：

JSP编译指令用来设置与整个JSP页面相关的属性;
主要有三大编译指令：

<%@ page ... %>    定义页面的依赖属性，比如脚本语言、error页面、缓存需求等等
<%@ include ... %>    包含其他文件
<%@ taglib ... %>    引入标签库的定义，可以是自定义标签

3.1page指令介绍：

Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令。

Page指令的语法格式：
<%@ page attribute=”value” %>
属性：
演示如下：

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

3.2include指令介绍：（静态包含）

JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。

Include指令的语法格式如下：
<%@ include file=”url” %>
Include指令中的文件名实际上是一个相对的URL。如果您没有给文件关联一个路径，JSP编译器默认在当前路径下寻找。
演示如下：

<%--  1.原理是把被包含的页面（header.jsp）
的内容翻译到包含页面(index.jsp)中,合并成翻译成一个java源文件，
再编译运行！！，这种包含叫静态包含（源码包含）
  2.被包含页面中不需要出现全局的html标签了！！！
（如html、head、body）--%>
<%@include file="/common/header.jsp"%>

3.3taglib指令介绍：

JSP API允许用户自定义标签，一个自定义标签库就是自定义标签的集合。Taglib指令引入一个自定义标签集合的定义，包括库路径、自定义标签。

taglib指令的语法：
<%@ taglib uri=”uri” prefix=”prefixOfTag” %>
uri为属性确定的标签位置，prefix属性指定标签库的前缀。此处后面会进一步介绍；
演示如下：

自己定义的标签库
<%@ taglib uri="http://rlovep.com" prefix="rlovep" %>

4.七大动作指令介绍：

动作指令与编译指令不同，编译指令时通知servlet引擎的处理消息，而动作指令只是运行时的动作。编译指令在将JSP编译成Servlet时起作用，而处理指令通常可替换成JSP脚本，它只是JSP脚本的标准化写法。
（1）JSP：forward 执行页面转向，将请求的处理转发到下一个页面。
（2）JSP：param 用于传递参数，必须与其他支持参数的标签一起使用
（3）JSP：include 用于动态引入一个JSP页面
（4）JSP：plugin 用于下载JavaBean或者Applet到客户端执行
（5） JSP：useBean 创建一个Javabean实例
（6) JSP：setProperty 设置JavaBean实例的属性值
（7）JSP：getProperty 获取JavaBean实例的属性值

4.1jsp:forward指令　

jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。

语法格式如下所示：
page属性：page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，可以是一个JSP页面或者一个 Java Servlet.
执行forward指令时，用户请求的地址依然没有发生改变，仍然是一次请求，但页面内容完全变为被forward目标页的内容。执行forward指令转发请求时，客户端的请求参数不会丢失。类似于servlet中的
getRequestDispatcher(“/GetData”).forward(request, response);
可以附带增加额外的请求参数：配合JSP：param动作指令

<%--转发 jsp:foward
    参数 jsp:param
<jsp:forward page="/action2.jsp">
    <jsp:param value="peace" name="name"/>
    <jsp:param value="123456" name="pass"/>
</jsp:forward>
--%>

4.2jsp:include指令（动态包含）

jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面

语法格式如下：
前面介绍过include的编译指令与前面不同的是这里的是动态包含，静态包含是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。如果被包含的页面是jsp一样会另一个生成servlet；
属性介绍：
page：被包含页面的url
flush：布尔属性，定义在包含资源前是否刷新缓存区。
可以附带增加额外的请求参数：配合JSP：param动作指令

<%--动态包括 --%>
动态包括：
<jsp:include page="/common/header1.jsp">
     <jsp:param value="lucc" name="name"/>
</jsp:include>

4.3jsp:userBean，setProperty，getProperty指令

这三个指令都是与JavaBean相关的指令，其中userBean指令用于在JSP页面中初始化一个java实例，setProperty指令用于为JavaBean实例的属性设置值；getProperty指令用于输出JavaBean实例的属性。

jsp:useBean动作简单的语法为：

其中，id属性是JavaBean的实例名，class属性确定JavaBean的实现类。scope属性用于指定JavaBean实例的作用范围。

jsp：setProperty的语法格式：

其中，name属性是要确定JavaBean的实例名，property属性要确定设置属性的属性名，value属性时要确定属性名对应的值。

jsp:getProperty的语法格式:

其中，name属性时要确定JavaBean的实例名，name属性是指定要获取的属性名对应的值。

演示如下：

<%--useBean setProperty getProperty --%>
<%--创建Student的实例 
实例名称为student
属性范围为page
--%>
<hr/>
<jsp:useBean id="student" class="com.rlovep.entity.Student" scope="page"/>
<%--设置student的name值 --%>
<jsp:setProperty name="student" property="name" value="peace"/>
<%--输出 student的name值--%>
name:<jsp:getProperty name="student" property="name" />

4.3jsp:param,plugin指令

param用于设置参数值，这个指令本身不能单独使用，因此单独的param指令没有实际意义，param指令可以与以下指令结合使用
jsp：include jsp：forward jsp：plugin。使用方法上面已经介绍；
plugin指令主要用于下载服务器端的JavaBean或Applet到到客户端执行，由于程序在客户端执行，因此客户端必须安装虚拟机。该指令用处较少，不做介绍；

4.4整体演示如下：

需要建立，action.jsp本文件，以级转发页面action2.jsp，被包含页面/common/header1.jsp，JavaBean：Student类

<%--转发 jsp:foward
    参数 jsp:param
<jsp:forward page="/action2.jsp">
    <jsp:param value="peace" name="name"/>
    <jsp:param value="123456" name="pass"/>
</jsp:forward>
--%>
<%--动态包括 --%>
动态包括：
<jsp:include page="/common/header1.jsp">
     <jsp:param value="lucc" name="name"/>
</jsp:include>
<%--useBean setProperty getProperty --%>
<%--创建Student的实例 
实例名称为student
属性范围为page
--%>
<hr/>
<jsp:useBean id="student" class="com.rlovep.entity.Student" scope="page"/>
<%--设置student的name值 --%>
<jsp:setProperty name="student" property="name" value="peace"/>
<%--输出 student的name值--%>
name:<jsp:getProperty name="student" property="name" />

5. 9大内置对象介绍

JSP脚本中包含9个内置对象，这9个内置对象都是Servlet API接口的实例，只是JSP规范对他们默认进行了初始化（由JSP页面对应的Servlet的_jspService()方法来创建这些实例）。也就是它们已经是对象，可以直接使用。

JSP初始化该9个对象的地方可以通过生成的servlet类看到如下：

request、response两个对象是_jspService()方法的形参，当Tomcat调用该方法时会初始化这两个对象。而page、pageContext、application、config、session、out都是_jspService()方法的局部变量，由该方法完成初始化。

5.1稍简单再介绍:详细介绍可以观看我的Servlet入门实践

application：javax.servlet.ServletContext的实例，该实例代表JSP所属的Web应用本身，可用于JSP页面，或者在Servlet之间交换信息。常用的方法有getAttribute(StringattName)、setAttribute(String attName , String attValue)和getInitParameter(StringparamName)等。
config：javax.servlet.ServletConfig的实例，该实例代表该JSP的配置信息。常用的方法有getInitParameter(StringparamName)和getInitParameternames()等方法。事实上，JSP页面通常无须配置，也就不存在配置信息。因此，该对象更多地在Servlet中有效。
exception：java.lang.Throwable的实例，该实例代表其他页面中的异常和错误。只有当页面是错误处理页面，即编译指令page的isErrorPage属性为true时，该对象才可以使用。常用的方法有getMessage()和printStackTrace()等。
out：javax.servlet.jsp.JspWriter的实例，该实例代表JSP页面的输出流，用于输出内容，形成HTML页面。
page：代表该页面本身，通常没有太大用处。也就是Servlet中的this，其类型就是生成的Servlet类，能用page的地方就可用this。
pageContext：javax.servlet.jsp.PageContext的实例，该对象代表该JSP页面上下文，使用该对象可以访问页面中的共享数据。常用的方法有getServletContext()和getServletConfig()等。这个对象存储了request对象和response对象的引用。application对象，config对象，session对象，out对象可以通过访问这个对象的属性来导出。PageContext类定义了一些字段，包括PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE， APPLICATION_SCOPE。它也提供了40余种方法，有一半继承自javax.servlet.jsp.JspContext 类。其中一个重要的方法就是removeArribute()，它可接受一个或两个参数。比如，pageContext.removeArribute(“attrName”)移除四个scope中相关属性，但是下面这种方法只移除特定scope中的相关属性：
pageContext.removeAttribute(“attrName”, PAGE_SCOPE);
request：javax.servlet.http.HttpServletRequest的实例，该对象封装了一次请求，客户端的请求参数都被封装在该对象里。这是一个常用的对象，获取客户端请求参数必须使用该对象。常用的方法有getParameter(String paramName)、getParameterValues(StringparamName)、setAttribute(String 8. 8/ attrName,Object attrValue)、getAttribute(StringattrName)和setCharacterEncoding(String env)等。
response：javax.servlet.http.HttpServletResponse的实例，代表服务器对客户端的响应。通常很少使用该对象直接响应，而是使用out对象，除非需要生成非字符响应。而response对象常用于重定向，常用的方法有getOutputStream()、sendRedirect(java.lang.String location)等。
session：javax.servlet.http.HttpSession的实例，该对象代表一次会话。当客户端浏览器与站点建立连接时，会话开始；当客户端关闭浏览器时，会话结束。常用的方法有：getAttribute(String attrName)、setAttribute(StringattrName, Object attrValue)等。

5.2四个域对象：

四个域对象：
pageContext——– page域
request ——– request域
session——– session域
application ——–context域
域对象作用：
保存数据和获取数据，用于数据共享。
域对象方法：
setAttribute(“name”,Object) 保存数据
getAttribute(“name”) 获取数据
removeAttribute(“name”) 清除数据
域对象作用范围：
page域：只能在当前jsp页面中使用（当前页面）
request域：只能在同一个请求中使用（转发）
session域：只能在同一个会话（session对象）中使用（私有的）
context域：只能在同一个web应用中使用。（全局的）

5.3 整体演示如下：

<%@ 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>
<%--out对象：对应jspwriter
 --%>
<%
  /* for(int i=0;i<=1024;i++){
      out.write("a");
  }
System.out.println("当前缓存区大小："+out.getBufferSize());
System.out.println("剩余缓存区大小："+out.getRemaining()); */
//如果不刷新则，123先输出；
//out.flush();
response.getWriter().write("123");
%>
<%--
application对象：对应servlet中的context
存储的属性，是整个应用共享的；同样可以获得配置参数；
 --%>
<%
//存储属性
application.setAttribute("name", "peace");
%>
<%=application.getInitParameter("keys") %>
<%--
config对象：对应servlet中的config
用处不是很大
 --%>
 <%=config.getServletName() %>
 <%--
exception对象：在错误页面中有效，可以获得异常属性
亲发生错误：该对象只有当编译指令page的isErrorPage="true"才有效
<%=exception.getMessage() %>
 --%>
 <%--
request对象：对应servlet中的request
 --%>
 <%=request.getLocalName() %>
 <%--
response对象：对应servlet中的response
 --%>
<%
    response.getWriter().println("hello respose");
%>
<%--
session对象：对应servlet中的session
 --%>
 <%
    session.setAttribute("pass", "567");
 %>
 <%--
pagecontext对象：jsp的页面对象
可以获得其他八个对象：
 --%>
 <%
    //获得其他对象
    response.getWriter().write("是否相等?"+(out==pageContext.getOut())+"<br/>");
 %>
 <%--可以往不同的域中存对象 --%>
 <%
    pageContext.setAttribute("message", "wang");
    pageContext.setAttribute("age", "22", PageContext.REQUEST_SCOPE);
    pageContext.setAttribute("qq", "374126165", pageContext.SESSION_SCOPE);
    pageContext.setAttribute("tl","1881679",pageContext.APPLICATION_SCOPE);
    //重定向到另一个页面取得数据：
    response.sendRedirect(request.getContextPath()+"/pageget.jsp");
    //删除存储的对象
    pageContext.removeAttribute("age",PageContext.REQUEST_SCOPE );
 %> 
</body>
</html>

6.JSP生命周期讲解：

理解JSP底层功能的关键就是去理解它们所遵守的生命周期。JSP生命周期就是从创建到销毁的整个过程，类似于servlet生命周期，区别在于JSP生命周期还包括将JSP文件编译成servlet。

6.1JSP执行过程：

访问：http://localhost:8080/工程名/NewFile.jsp

访问到NewFile.jsp页面，tomcat扫描到jsp文件，在/work/Catalina/localhost/stuJsp/org/apache/jsp把jsp文件翻译成java源文件
(NewFile.jsp -> NewFile_jsp.java) （翻译）
tomcat服务器把java源文件编译成class字节码文件（编译）
（NewFile_jsp.java ->NewFile_jsp.class）
tomcat服务器构造NewFile_jsp类对象
tomcat服务器调用NewFile_jsp类里面方法，返回内容显示到浏览器。

第一次访问jsp：走（1）（2）（3）（4）
之后的访问：走（4）
注意：jsp文件修改了或jsp的临时文件被删除了，要重新走翻译（1）和编译（2）的过程

6.2JSP生命周期：

JSP编译：
当浏览器请求JSP页面时，JSP引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过，或者在上次编译后被更改过，则编译这个JSP文件。编译为servlet；
JSP初始化：
容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。你可以重写该方法：在jsp声明段

<%! 
public void jspInit(){
    initVar++;
   System.out.println("jspInit(): JSP被初始化了"+initVar+"次");
}
%>

JSP执行：
这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。每一次服务请求都会执行_jspService()方法。
JSP清理：
JSP生命周期的销毁阶段描述了当一个JSP网页从容器中被移除时所发生的一切，一般只有在容器停止部署该工程才执行：jspDestroy()方法你可以进行重写

<%!
 public void jspDestroy(){ 
          destroyVar++;   
        System.out.println("jspDestroy(): JSP被销毁了"+destroyVar+"次"); 
  } %>

JSP与servlet的生命周期对比

Servlet的生命周期：
    1）构造方法（第1次访问）
    2）init方法（第1次访问）
    3）service方法
    4）destroy方法
Jsp的生命周期:
    1）翻译： jsp->java文件
    2）编译： java文件->class文件（servlet程序）
    3）构造方法（第1次访问）
    4）init方法（第1次访问）：_jspInit()
    5）service方法：_jspService()
    6）destroy方法：_jspDestroy()

6.3演示如下：

<%@ 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>
<%! 
  //记录执行次数：
  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+"次请求");
  //对各个的执行次数计数
  String content1="初始化次数 : "+initVar;
  String content2="响应客户请求次数 : "+serviceVar;
  String content3="销毁次数 : "+destroyVar;
%>
<%-- 输出显示 --%>
<h1><%=content1 %></h1>
<h1><%=content2 %></h1>
<h1><%=content3 %></h1>
</body>
</html>

显示如下：

来自一条小鲨鱼wpeace（rlovep.com）