JSP

最新推荐文章于 2023-02-20 18:15:30 发布

九州殊口二

最新推荐文章于 2023-02-20 18:15:30 发布

阅读量186

点赞数 1

分类专栏： JavaWeb

本文链接：https://blog.csdn.net/QAQ123666/article/details/100173815

版权

JavaWeb 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

了解就行，已经被淘汰的技术。

文章目录

1. 什么是JSP
2.为什么要用JSP
3.为什么放弃JSP
4.jsp和Servlet的分工：
5.Jsp的组成
6.Jsp的Java脚本演示
7.Jsp与Servlet分工演示
8. jsp原理
9.jsp注释
10.三大指令
11.九大内置对象
- 1.pageContext
12.动作标签

1. 什么是JSP

JSP即java server pages，它是JavaWeb的动态资源，其实它就是Servlet。
JSP = html + java脚本 + jsp动作标签(包含EL表达式)

2.为什么要用JSP

Servlet：

缺点：不适合设置html响应体，需要大量的response.getWriter().print("<html>")输出HTML代码
优点：动态资源，可以编程。
html：

缺点：html是静态页面，不能包含动态信息
优点：不用为输出html标签而发愁
jsp(java server pages)：

优点：在原有html的基础上添加java脚本，构成jsp页面。

3.为什么放弃JSP

为了前后端分离，降低耦合度，不把前后端代码混到一起。
详见：JavaWeb项目为什么我们要放弃jsp？为什么要前后端解耦？为什么要动静分离？

4.jsp和Servlet的分工：

JSP：

作为请求发起页面，例如显示表单、超链接。
作为请求结束页面，例如显示数据。
Servlet：

作为请求中处理数据的环节。

JSP就像是服务员，servlet就像是后厨厨师，客户<–>JSP<–>servlet
在这里插入图片描述

5.Jsp的组成

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

6.Jsp的Java脚本演示

案例一：

<!-- 它是jsp指令，也是一种特殊的标签！ -->
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!-- java代码的片段 -->
<%
String path = request.getContextPath();//获取项目名
/*
http://localhost:8080/day11_1/
*/
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  	<!-- 向页面输出basePath -->
    <base href="<%=basePath%>">
    <!-- <base标签中的超链接写在文件每一个超链接前面 -->
    <title>My JSP 'index.jsp' starting page</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
  </head>
  
  <body>
    This is my JSP page. <br>
    <%
    	int a = 10;
    %>
    
    <%
    	out.print(a++);
    %>
    <br/>
    /*
		<%=a %>的作用是输出a，等同于<% out.print(a++); %>
	*/    
	<%=a %>
    <%!
    	int a = 100; //局部变量
    	public void fun1() {
    		System.out.println(a);
    	}
    %>

    <%
    	out.print(this.a++);//加this表示成员变量，不加的话是上面那个局部变量
    	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>张三</td>
		<td>29</td>
	</tr>
<%
	}
%>
</table>
    
</body>

运行截图：在这里插入图片描述

7.Jsp与Servlet分工演示

案例：完成加运算
在这里插入图片描述
AServlet:

public class AServlet extends HttpServlet {
	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);
	}
}

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>

result.jsp:

<body>
	<%
		Integer result = (Integer)request.getAttribute("result");
	%>
	<%=result %>
</body>

8. jsp原理

jsp其实是一种特殊的Servlet

当jsp页面第一次被访问时，服务器会把jsp编译成java文件（这个java其实是一个servlet类）
然后再把java编译成.class
然后创建该类对象
最后调用它的service()方法
第二次请求同一jsp时，直接调用service()方法。
在tomcat的work目录下可以找到jsp对应的.java源代码。
源代码中，java语句不变，html语句变成字符串输出

例如JSP中：
abcdefg
<%
int a = 100;
System.out.println(a);
out.print(a);
%>
a
<%=a%>
翻译为.java:
out.write(“abcdefg”);
int a = 100;
System.out.println(a);
out.print(a);
out.write(“a”);
out.print(a);
查看jsp对应java文件：

java脚本
html

在这里插入图片描述
out.write()与out.print()无区别。

9.jsp注释

<%-- … --%>：当服务器把jsp编译成java文件时已经忽略了注释部分！
客户端看不到
<!–fdsafdsa–>：html注释
客户端看得到但是不显示，查看源代码可以看见

10.三大指令

JSP指令的格式：<%@指令名属性1=”” 属性2=”” %>，一般都会把JSP指令放到JSP文件的最上方，但这不是必须的。
JSP中有三大指令：page、include、taglib，最为常用，也最为复杂的就是page指令了。

1.page指令

page指令没有必须属性，都是可选属性。例如<%@page %>，没有给出任何属性也是可以的！
在JSP页面中，任何指令都可以重复出现！
<%@ page language=”java”%>
<%@ page import=”java.util.*”%>
<%@ page pageEncoding=”utf-8”%>
这也是可以的！

属性：

pageEncoding和contentType：
1. pageEncoding：它指定当前jsp页面的编码，只要和文件编码一致，就不会有乱码！在服务器要把jsp编译成.java时需要使用pageEncoding!
2. contentType：它表示添加一个响应头：Content-Type！等同与response.setContentType(“text/html;charset=utf-8”);
3. 如果两个属性只提供一个，那么另一个的默认值为设置的那一个。
  如果两个属性都没有设置，那么默认为iso，所以至少写一个
4. 几乎不会出现乱码，知道就行
import：导包！可以出现多次
errorPage和isErrorPage
1. errorPage：当前页面如果抛出异常，那么要转发到哪一个页面，由errorPage来指定
2. isErrorPage：它指定当前页面是否为处理错误的页面！当该属性为true时，这个页面会设置状态码为500(服务器异常)！而且这个页面可以使用9大内置对象中的exception!（只有设置了isErrorPage才可以使用）
web.xml中配置错误界面
当出现<error-code>中的异常时，转发到<location>中的文件中

 <error-page>
  	<error-code>404</error-code>
  	<location>/error/errorPage.jsp</location>
</error-page>
<error-page>
	<error-code>500</error-code>
	<location>/error/errorPage.jsp</location>
</error-page>
<error-page>
	<exception-type>java.lang.RuntimeException</exception-type>
	<location>/index.jsp</location>
</error-page>

500与java.lang.RuntimeException有重叠，所以当仅仅是500时，转发到/error/errorPage.jsp，既是500也是java.lang.RuntimeException时，转发到/index.jsp

autoFlush和buffer(没啥用)
1. autoFlush：指定jsp的输出流缓冲区满时，是否自动刷新！默认为true，如果为false，那么在缓冲区满时抛出异常！
2. buffer：指定缓冲区大小，默认为8kb，通常不需要修改！
isELIgnored：是否忽略el表达式，默认值为false，不忽略，即支持！
基本没用：
1. language：指定当前jsp编译后的语言类型，默认值为java。
2. info：信息！
3. isThreadSafe：当前的jsp是否支持并发访问！
4. session：当前页面是否支持session，如果为false，那么当前页面就没有session这个内置对象！
5. extends：让jsp生成的servlet去继承该属性指定的类！

2.include指令

与RequestDispatcher的include()方法的功能相似！
<%@include%> 它是在jsp编译成java文件时完成的！他们共同生成一个java(就是一个servlet)文件，然后再生成一个class！
RequestDispatcher的include()是一个方法，包含和被包含的是两个servlet，即两个.class！他们只是把响应的内容在运行时合并了！
作用：把页面分解了，使用包含的方式组合在一起，这样一个页面中不变的部分，就是一个独立jsp，而我们只需要处理变化的页面。

3.taglib指令

两个属性：
1. prefix：指定标签库在本页面中的前缀！由我们自己来起名称！
2. uri: 指定标签库的位置！

<%@taglib prefix=“s” uri="/struts-tags"%> 前缀的用法<s:text>

11.九大内置对象

out --> jsp的输出流，等同与response.getWriter()，用来向客户端响应
page --> 当前jsp对象(this)！它的引用类型是Object，即真身中有如下代码：Object page = this;
config --> 它对应真身中的ServletConfig对象！
pageContext --> 页面上下文对象，域对象。一个顶9个！
request --> HttpServletEequest
response --> HttpServletResponse
exception --> Throwable
session --> HttpSession
application --> ServletContext

在这9个对象中有很多是极少会被使用的，例如：config、page、exception基本不会使用。
在这9个对象中有两个对象不是每个JSP页面都可以使用的：exception、session。

1.pageContext

Servlet中有三大域，而JSP中有四大域，它就是最后一个域对象！
1. ServletContext：整个应用程序
2. session：整个会话(一个会话中只有一个用户)
3. request：一个请求链！
4. pageContext：一个jsp页面！这个域是在当前jsp页面和当前jsp页面中使用的标签之间共享数据！
(1).域对象
(2).代理其他域，向其他域中存东西：
pageContext.setAttribute(“xxx”, “XXX”, PageContext.SESSION_SCOPE);
PageContext.SESSION_SCOPE 表示向session域中存储name为xxx，value为XXX的属性
(3).全域查找：pageContext.findAttribute(“xxx”);从小到大，依赖查找！
(4).获取其他8个内置对象：

12.动作标签

这些jsp的动作标签，与html提供的标签有本质的区别。
1.动作标签是由tomcat(服务器)来解释执行！它与java代码一样，都是在服务器端执行的！
2. html由浏览器来执行！

重要标签：

<jsp:forward>：转发！它与RequestDispatcher的forward方法是一样的，一个是在Servlet中使用，一个是在jsp中使用！
<jsp:include>：包含！它与RequestDispatcher的include方法是一样的，一个是在Servlet中使用，一个是在jsp中使用！（动态包含）
<%@include>和<jsp:include>有什么不同？
<%@include>是合并，<jsp:include>是调用，只是把输出结果合并
<jsp:param>：它用来作为forward和include的子标签！用来给转发或包含的页面传递参数！