JavaWeb之JSP基本原理

超、凢脫俗 2021-06-24 16:11 364阅读 0赞

## 一、JSP的作用 ##

*  Servlet：  
    缺点：不适合设置html响应体，需要大量的`response.getWriter().print("");`  
    优点：动态资源，可以编程。
 *  html：  
    缺点：html是静态页面，不能包含动态信息  
    优点：不用为输出html标签而发愁
 *  jsp(java server pages)：  
    优点：在原有html的基础上添加java脚本，构成jsp页面。

## 二、JSP和Servlet的分工 ##

*  JSP：  
    作为请求发起页面，例如显示表单、超链接。  
    作为请求结束页面，例如显示数据。
 *  Servlet：  
    作为请求中处理数据的环节。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

## 三、JSP的组成 ##

*  jsp = html + java脚本 + jsp标签(指令)
 *  jsp中无需创建即可使用的对象一共有9个，被称之为9大内置对象。例如：request对象、out对象
 *  3种java脚本：  
    `<%...%>`：java代码片段(常用)，用于定义0~N条Java语句！方法内能写什么，它就可以放什么！  
    `<%=...%>`：java表达式，用于输出(常用)，用于输出一条表达式（或变量）的结果。response.getWriter().print( … );这里能放什么，它就可以放什么！  
    `<%!...%>`：声明，用来创建类的成员变量和成员方法(基本不用，但容易被考到)，类体中可以放什么，它就可以放什么！

### 演示：JSP中java脚本的演示 ###

理解`<%...%>`和`<%!...%>`中使用和声明变量的区别。

<body>
    	This is my JSP page.
    	<br>
    	<%
    		int a = 10;
    	%>
    	out.print(a);的结果：
    	<%
    		out.print(a);
    	%>
    	<br> 
    	< % = a % >的结果：
    	<%=a%>
    	<br>
    	<%!
    		int a = 100;
    		public void fun1() {
    			System.out.print(a);
    		}
    	%>
    	out.print(this.a++);的结果：
    	<%
    		out.print(this.a++);
    	%>
    	<br>
    	<%
    		fun1();
    	%>
    </body>

循环输出HTML元素：

<body>
    
    	<table border="1" align="center" width="60%">
    		<tr>
    			<td>姓名</td>
    			<td>年龄</td>
    		</tr>
    		<%
    			for (int i = 0; i <= 10; i++) {
    		%>
    		<tr>
    			<td>veeja</td>
    			<td>18</td>
    		</tr>
    		<%
    			}
    		%>
    	</table>
    </body>

### 演示：JSP和Servlet分工的案例 ###

**功能描述：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
**代码：**  
![在这里插入图片描述][2019052919011222.png]

*  form.jsp
    
        <body>
        	<form action="/day11_1/AServlet" method="post">
        		整数1：<input type="text" name="num1" /><br>
        		整数2：<input type="text" name="num2" /><br>
        		<input type="submit" value="提交" />
        	</form>
        </body>
 *  AServlet.java
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
        		throws ServletException, IOException { 
        	// 获取参数
        	String s1 = request.getParameter("num1");
        	String s2 = request.getParameter("num2");
        
        	// 转换成int类型
        	int num1 = Integer.parseInt(s1);
        	int num2 = Integer.parseInt(s2);
        
        	// 运算过程：将两个数相加
        	int sum = num1 + num2;
        
        	// 把结果保存到request域中去
        	request.setAttribute("result", sum);
        
        	// 转发到result.jsp
        	request.getRequestDispatcher("/jia/result.jsp").forward(request,
        			response);
        }
 *  result.jsp
    
        <body>
        	结果是：
        	<%
        		Integer result = (Integer) request.getAttribute("result");
        	%>
        	<%=result%>
        </body>

## 四、JSP的原理 ##

JSP其实是一种特殊的Servlet。

1.  当界面第一次被访问时，服务器会把jsp编译成`.java`文件（这个java其实是一个Servlet类）
2.  然后再把java编译成`.class`
3.  然后创建该类对象
4.  最后调用它的`service()`方法
5.  第二次请求同一jsp的时候，直接调用jsp对应的`.java`源代码。

我们可以在Tomcat下的work目录里找到编译后的class文件。  
![在这里插入图片描述][20190615205123872.png]  
我们可以打开看一下，看里面的`_jspservice()`方法：

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("\r\n");
          out.write("\r\n");
          out.write("\r\n");
    
    	String path = request.getContextPath(); // 获取项目名
    	/* http://localhost:8080/day11_1/ */
    	String basePath = request.getScheme() + "://"
    			+ request.getServerName() + ":" + request.getServerPort()
    			+ path + "/";
    
          out.write("\r\n");
          out.write("\r\n");
          out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
          out.write("<html>\r\n");
          
          ......
          ......
          ......
          
          out.write("</html>\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);
        }
      }

上面的代码我只截取了一部分，我们可以看到：

1.  在JSP中的静态信息（例如`<html>`等）在.java文件中都是使用out.write()完成打印！这些静态信息都是作为字符串输出给了客户端。
2.  JSP的整篇内容都会放到名为\_jspService的方法中！你可能会说`<@page>`不在.java文件中，`<%@page>`我们先不考虑。

### jsp脚本 ###

我们再讨论一下jsp脚本。JSP脚本一共三种形式：

1.  `<%...%>`：内容会直接放到.java文件中；  
    比如jsp中的
    
        <%
        	String path = request.getContextPath(); // 获取项目名
        	/* http://localhost:8080/day11_1/ */
        	String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
        %>
    
    在.java中就是：
    
        String path = request.getContextPath(); // 获取项目名
        /* http://localhost:8080/day11_1/ */
        String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
2.  `<%=…%>`：内容会放到out.print()中，作为out.print()的参数；  
    比如jsp中的：
    
        <%=basePath%>
    
    在.java中就会是：
    
        out.print(basePath);
3.  `<%!…%>`：内容会放到\_jspService()方法之外，被类直接包含；  
    现在我们已经知道了，JSP其实就是一个类，一个Servlet类。`<%!...%>`的作用是在类中添加方法或成员的，所以`<%!...%>`中的内容不会出现在`_jspService()`中。

### jsp注释 ###

JSP是需要先编译成.java，再编译成.class的。  
其中`<%-- ... --%>`中的内容在JSP编译成.java时会被忽略的，即JSP注释。  
也可以在JSP页面中使用html注释：``，但这个注释在JSP编译成的.java中是存在的，它不会被忽略，而且会被发送到客户端浏览器。但是在浏览器显示服务器发送过来的html时，因为``是html的注释，所以浏览器是不会显示它的。但是我们可以使用浏览器的查看源代码看到这些内容。

--------------------

end.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20210615/551ae5aa53a04e3d9f8fed5144ab5860.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20210615/d65f438e56c64f8183e4b287305d7ce0.png
[2019052919011222.png]: /images/20210615/28c649c86a174e0dbe7979cd5edf8c28.png
[20190615205123872.png]: /images/20210615/1d2d0230766349b08fd79426727450b0.png