JSP

1).JSP:

①. JSP 是简 Servlet 编写的一种技术, 它将 Java 代码和 HTML 语句混合在同一个文件中编写,

只对网页中的要动态产生的内容采用 Java 代码来编写，而对固定不变的静态内容采用普通静态

HTML 页面的方式编写。

②. Java Server Page: Java 服务器端网页. 在 HTML 页面中编写 Java 代码的页面.

2). helloworld:

新建一个 JSP 页面, 在 body 节点内的 <% %> 即可编写 Java 代码.

3). JSP 可以放置在 WEB 应用程序中的除了 WEB-INF 及其子目录外的其他任何目录中,
JSP 页面的访问路径与普通 HTML 页面的访问路径形式也完全一样。

4). JSP的运行原理:

JSP 本质上是一个 Servlet.

每个JSP 页面在第一次被访问时, JSP 引擎将它翻译成一个 Servlet 源程序,

接着再把这个 Servlet 源程序编译成 Servlet 的 class 类文件.

然后再由WEB容器（Servlet引擎）像调用普通Servlet程序一样的方式来

装载和解释执行这个由JSP页面翻译成的Servlet程序。

5). JSP 页面的隐含变量: 没有声明就可以使用的对象.

  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("
");
      out.write("
");
      out.write("<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional
                                       //EN" "http://www.w3.org/TR/html4/loose.dtd">
");
      out.write("<html>
");
      out.write("<head>
");
      out.write("<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
");
      out.write("<title>Insert title here</title>
");
      out.write("</head>
");
      out.write("<body>
");
      out.write("	");
           //我们编写java代码的位置
        Person person = new Person();
        System.out.println(person.getInfo());
    
      out.write("
");
      out.write("
");
      out.write("</body>
");
      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 {
            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);
    }
  }

JSP页面一共有 9 个隐含对象.

public void _jspService(HttpServletRequest request, HttpServletResponse response)throws java.io.IOException, ServletException {}

PageContext pageContext = null;

HttpSession session = null;

ServletContext application = null;

ServletConfig config = null;

JspWriter out = null;

Object page = this;

exception

使用 <% %> 编写的代码在此位置. 可以用到 request, response, pageContext, session
application, config, out, page 这 8 个隐含对象. (实际上还可以使用一个叫 exception 的隐含对象)

①. request: HttpServletRequest 的一个对象.

②. response: HttpServletResponse 的一个对象(在 JSP 页面中几乎不会调用 response 的任何方法.)

③. pageContext: 页面的上下文, 是 PageContext 的一个对象. 可以从该对象中获取到其他 8 个隐含对象. 也可以从中获取到当前

页面的其他信息. (学习自定义标签时使用它)

④. session: 代表浏览器和服务器的一次会话, 是 HttpSession 的一个对象. 后面详细学习.

⑤. application: 代表当前 WEB 应用. 是 ServletContext 对象.

⑥. config: 当前 JSP 对应的 Servlet 的 ServletConfig 对象(几乎不使用). 若需要访问当前 JSP 配置的初始化参数,

需要通过映射的地址才可以.

映射 JSP:

<servlet>
<servlet-name>hellojsp</servlet-name>
<jsp-file>/hello.jsp</jsp-file>
<init-param>
<param-name>test</param-name>
<param-value>testValue</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>hellojsp</servlet-name>
<url-pattern>/hellojsp</url-pattern> 
</servlet-mapping>

⑦. out: JspWriter 对象. 调用 out.println() 可以直接把字符串打印到浏览器上.

⑧. page: 指向当前 JSP 对应的 Servlet 对象的引用, 但为 Object 类型, 只能调用 Object 类的方法(几乎不使用)

⑨. exception: 在声明了 page 指令的 isErrorPage="true" 时, 才可以使用.

<%@ page isErrorPage="true" %>

pageContext, request, session, application(对属性的作用域的范围从小到大)
out, response, config, page
exception

<%@page import="java.util.Date"%>
<%@ 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>
    <%
        Date date = new Date();
        System.out.println(date);
    %>

    <%
        String str = date.toString();

        //没有声明就可以使用的对象
        //1. request
        String name = request.getParameter("name");
        System.out.println(name);

        //2. response:    HttpServletRequest的一个对象(在JSP页面中几乎不会调用response的任何方法)
        Class clazz = response.getClass();
        System.out.println(clazz);//class org.apache.catalina.connector.ResponseFacade
        System.out.println(response instanceof HttpServletResponse);//true

        //3. pageContext:页面的上下文，是PageContext 的一个对象，可以从该对象中获取到其他8个隐含对象
        //也可以从中获取到当前页面的其他信息（学习自定义标签使用），代表当前的jsp页面
        ServletRequest req = pageContext.getRequest();
        System.out.println(req == request);//true  

        //4. Session :代表浏览器和服务器的一次对话，是HttpSession的一个对象，后面详细学习
        System.out.println(session.getId());//5C9B9591D1684A26C9232B2E988CC372

        //5. application：代表当前WEB引用，是 ServletContext 对象
        System.out.println(application.getInitParameter("user"));//hmm
        System.out.println(application.getInitParameter("password"));//123456

        //6.config  : 当前jsp 页面对应的Servlet 的 ServletConfig 对象（开发时候几乎不用）

        //7. out :JspWriter 对象  ，调用out.println() 可以直接把字符串打印到浏览器上。
        out.println(request.getParameter("name"));
        out.print("<br/>");//换行的方法
        out.println(application.getInitParameter("password"));//123456

        //8. page ：指向JSP对应的Servlet对象的引用，但为Object类型，只能调用Object类的方法 (几乎不使用)

        //9. exception :  在声明了 Page指令的 isErrorPage = "true"时，才可以使用
        //<%@ page isErrorPage="true"   % >

        
        //pageContext, request, session, application(对属性的作用域的范围从小到大)
        //out, response, config, page 
        //exception
    %>

</body>
</html>

6). JSP模版元素: JSP页面中的静态HTML内容称

7). JSP表达式（expression）提供了将一个 java 变量或表达式的计算结果输出到客户端的简化方式，
它将要输出的变量或表达式直接封装在<%= 和 %>之中。

<% 
Date date = new Date();
out.print(date);
%>
<%= date %>

8). JSP脚本片断（scriptlet）是指嵌套在<% 和 %>之中的一条或多条Java程序代码。
多个脚本片断中的代码可以相互访问

<% 
String ageStr = request.getParameter("age");
Integer age = Integer.parseInt(ageStr);

if(age >= 18){
%>
成人...
<%
}else{
%>
未成人...
<%
}
%>

9). JSP 声明: 将 Java 代码封装在<%！和 %>之中,它里面的代码将被插入进 Servle t的 _jspService 方法的外面(在 JSP 页面中几乎从不这样使用)

10). JSP注释的格式：<%-- JSP 注释 --%>

区别: JSP 注释可以阻止 Java 代码的执行.

All that work will definitely pay off