JSP简介

JSP（全称JavaServer Pages）是由Sun Microsystems公司主导创建的一种***页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。

浅析html，servlet，jsp：

Html：用来显示页面，不能写java代码。
Servlet:可以写页面，也可以在页面中写代码，但是写页面麻烦。
JSP：html+servlet，在页面中可以使用html标签也可以使用java代码，一般Servlet和JSP结合使用，Servlet负责业务，JSP负责显示。（JSP本质也是一个Servlet）

jsp主要构成：HTML网页代码、Java代码片段、JSP标签几部分组成，后缀是.jsp。

注：JSP文件的运行依赖于WEB服务器，也就是说如果不是通过WEB服务器，浏览器是不能直接打开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>
	
</body>
</html>

JSP指令写法

<%@ 指令名字 %>

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

page指令

language：表明jsp页面中可以写java代码
contentType：说明文件是什么类型，告诉浏览器内容类型，以及使用什么编码
pageEncoding jsp内容编码

扩展：
4. extends 用于指定jsp翻译成java文件后，继承的父类是谁。
5. import 导包使用的，一般不用手写。
6. session: 值可选的有true or false ，用于控制在这个jsp页面里面，是否能够直接使用session对象。
7. errorPage：指的是错误的页面，值需要给错误的页面路径
8. isErrorPage：errorPage 用于指定错误的时候跳转到哪一个页面去。 isErroPage , 就是声明某一个页面到底是不是错误的页面。
9. isThreadSafe 是否单线程模式
10.isELIgnored 是否忽略EL表达式

include指令

include是静态包含指令，主要是用于在当前页面中引入其他页面。
作用:包含另外一个jsp的内容进来,把另外一个页面的所有内容拿过来一起输出。所有的标签元素都包含进来。

   <%@ include file=”页面地址”%>

taglib指令

定义JSP可以使用的标签库（见JSTL）

	<%@ taglib prefix=""  uri=""%> 
	<%-- uri: 标签库路径
		prefix : 标签库的别名  --%>

JSP脚本元素

在JSP中我们主要通过脚本元素来编写Java代码，这些Java代码一般会在页面被访问时调用。

1.JSP脚本片段

脚本片段是嵌入到JSP中Java代码段，格式以<%开头，%>结尾，两个%号之间编写Java代码块。主要是用于编写一些逻辑代码，比如：if判断、for循环

	<% pageContext.setAttribute("name", "page"); %>

2.JSP表达式

JSP表达式用来直接将Java变量输出到页面中，格式以<%=开头，以%>结尾，中间是要输出的内容。主要是用于把Java表达式的运行结果输出显示到页面上

	<%=pageContext.getAttribute("name")%>

3.JSP声明

JSP声明中的内容会被直接写到类中，格式以<%!开头，以%>结尾，中间是Java代码。主要是用于声明一些成员变量或者成员方法

<%! private int num = 0; %>
<%--相当于在类中声明了一个成员变量  --%>

JSP 动作标签

JSP动作标签与HTML标签不同，HTML标签由浏览器来解析，而JSP动作标签需要服务器（Tomcat）来运行。

<jsp:include page="页面地址"> </jsp:include>
作用：将其他页面包含到当前页面中,是动态包含,即不把包含的页面所有元素标签全部拿过来输出，而是把它的运行结果拿过来。
原理：当使用动态包含时，Tomcat会在生成的Servlet中加入如下代码：
org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, “target.jsp”, out, false);

动态包含与静态包含的区别：
1):静态包含使用include指令，动态包含使用jsp:inclued标签
2)静态包含会直接将目标页面复制到生成的Servlet中，动态包含是在生成的servlet中使用include()方法来引入目标页面。
3)当目标页面发生改变时，静态包含不能体现，动态包含可以体现

<jsp:forward page="页面地址"></jsp:forward>
作用：在页面中用于转发操作,前往哪一个页面。
使用JSP脚本片段编写

<% 
	//请求转发
	request.getRequestDispatcher("页面地址").forward(request, response);
%>

子标签：<jsp:param value="paramValue" name="paramName"/>
作用：在转发时设置请求参数，通过request.getParameter()在目标页面获取请求参数。

	<jsp:forward page="页面地址">
		<jsp:param value="paramValue" name="paramName"/>
	</jsp:forward>

获取参数

<%= request.getParameter("paramName")%>

JSP九个隐含对象（内置对象）

隐含对象即JSP中无需创建可以直接使用的对象

四个域对象

pageContext（PageContext）：当前页面的上下文，也是一个域对象。
request（HttpServletRequest）：HttpServletRequest对象
session（HttpSession）：HttpSession对象
application（ServletContext）：ServletContext对象

1.域对象主要方法
public void setAttribute(String name, Object o):在当前域中放入数据
public Object getAttribute(String name) :根据名字获取当前域中的数据
public void removeAttribute(String name):根据名字删除当前域中的数据

	使用域对象存储数据<br>
	<%
		pageContext.setAttribute("name", "page");
		request.setAttribute("name", "request");
		session.setAttribute("name", "session");
		application.setAttribute("name", "application");
	%>
	取出四个作用域中的值<br>
	<%=pageContext.getAttribute("name")%>
	<%=request.getAttribute("name")%>
	<%=session.getAttribute("name")%>
	<%=application.getAttribute("name")%>

2.四个域对象范围

pageContext(页面) : 当前JSP页面。页面范围内的数据，只能在当前页面中获取，一旦转到其他页面当前域中的数据便失效，不能获取。
Request（请求) : 仅限于一次请求。区分一次请求主要是看是不是同一个request。比如：转发是表示一个请求，重定向是多个请求。
Session（会话) : 仅限于一次会话（多次请求与响应）当中。只要没有关闭浏览器或设置session失效，就可以在域中获取到Session中的数据。

打开浏览器到关闭浏览器，这一个完整的上网过程可以叫做一个会话。

Application（应用）：整个WEB应用。在这个域对象中设置的数据在所有的域中都能获取。

3.PageContext特有功能

1）可以获取指定域中的数据：getAttribute(String name, int scope)
2）可以向指定域中设置数据：setAttribute(String name, Object value, int scope)

关于int scope参数：

PageContext.PAGE_SCOPE 值为 1
PageContext.REQUEST_SCOPE 值为 2
PageContext.SESSION_SCOPE 值为 3
PageContext.APPLICATION_SCOPE 值为 4

3）全域查找：Object findAttribute(String name)
4）可以获取其他八个隐含对象。

其他隐含对象

out（JspWriter）：相当于response.getWriter()获取的对象，用于在页面中显示信息。
config（本质：ServletConfig）：对应Servlet中的ServletConfig对象。
page（Object）：对应当前Servlet对象，实际上就是this。
exception（本质：Throwable）：错误页面中异常对象
response（本质：HttpServletResponse）：HttpServletResponse对象

JSP运行原理

Tomcat在运行JSP时，并不是直接显示JSP页面，而是将JSP页面转换成了一个Java类，即Servlet。

jspTest01.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>
	<h1>haha</h1>
	<% response.getWriter().write("jsp"); %>
</body>
</html>

我们编写的JSP，Tomcat会自动生成Servlet源码再编译成.class文件，这两个文件存放在work目录下。

Tomcat目录介绍

jspTest01_jsp.java

package org.apache.jsp;

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

public final class jspTest01_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  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 static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

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

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

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  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 java.lang.String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
      return;
    }

    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("\t<h1>haha</h1>\r\n");
      out.write("\t");
 response.getWriter().write("jsp"); 
      out.write("\r\n");
      out.write("</body>\r\n");
      out.write("</html>\r\n");
      out.write("\r\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              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);
    }
  }
}

jspTest01_jsp类继承了org.apache.jasper.runtime.HttpJspBase，HttpJspBase又继承了HttpServlet，所以说（JSP） jspTest01_jsp也是一个Servlet。当我们访问JSP时服务器就是调用该JSP生成的Servlet类来响应请求的。

JSP里的注释

1.写HTML代码的地方，写HTML注释，只能注释HTML。 HTML的注释内容，在浏览器源码里能够看到
2.JSP的注释：<%-- --%>,在浏览器源码里看不到

JSP(了解)