JavaWeb之JSP

文章目录

- JSP的基本介绍
- JSP的本质
- JSP的三种语法
- - JSP头部的page指令
  - - language属性
    - contentType属性
    - image.png
    - pageEncoding属性
    - import属性
    - autoFlush属性 - 给out输出流使用
    - buffer属性 - 给out输出流使用
    - errorPage属性
    - isErrorPage属性
    - session属性
    - extends属性
  - JSP中的常用脚本
  - - 声明脚本（极少使用）
    - 表达式脚本（常用）
    - 代码脚本
  - JSP中的三种注释
  - - html注释
    - java注释
    - jsp注释
- JSP九大内置对象
- JSP四大域对象
- JSP中的out输出和response.getWriter输出的区别
- JSP的常用标签
- - JSP静态包含
  - JSP动态包含
  - JSP标签转发
- Listener监听器
- - ServletContextListener监听器

JSP的基本介绍

:::tips
JSP的全称是Java Server Pages，Java的服务器页面
JSP的主要作用就是代替Servlet程序回传html页面的数据
因为Servlet程序回传html页面数据是一件非常繁琐的事情。开发成本和维护成本都极高
:::

Servlet回传html页面数据

package com.zan.servlet;

import jakarta.servlet.Servlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class PringHtml extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //通过响应的输出流回传html页面数据
        resp.setContentType("text/html; charset=UTF-8");

        PrintWriter writer = resp.getWriter();

        writer.write("<!DOCTYPE html>\r\n");
        writer.write(" <html lang=\"en\">\r\n");
        writer.write(" <head>\r\n");
        writer.write("  <meta charset=\"UTF-8\">\r\n");
        writer.write("  <title>Title</title>\r\n");
        writer.write(" </head>\r\n");
        writer.write("<body>\r\n");
        writer.write("  这是html页面数据>\r\n");
        writer.write(" </body>\r\n");
        writer.write("</html>\r\n");
    }
}

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>Title</title>
  </head>
  <body>
    这是html页面数据
  </body>
</html>

JSP小结

创建JSP的页面

JSP的访问
:::tips
jsp页面和html是一样的，都是存放在web目录下，访问也跟访问html页面一样
比如：
web目录
a.html页面 ==> http://ip:port/工程路径/a.html
b.jsp页面 ==> http://ip:port/工程路径/b.jsp
:::

JSP的本质

JSP页面本质上是一个Servlet程序

当我们第一次访问jsp页面的时候哦。Tomcat服务器会帮我们把jsp页面翻译成为一个java源文件。并且对它进行编译成为.class字节码程序

当我们根据源代码发现，HttpJspBase类。它直接的继承了HttpServlet类，也就是说，jsp翻译出来的java类，间接的继承了HttpServlet类，即翻译出来的其实就是一个Servlet程序

总结：通过翻译的java源代码我们就可以得到结果：jsp就是Servlet程序

同样我们也可以去观察翻译出来的Servlet程序的源代码，不难发现，其底层实现，也是通过输出流，把html页面数据回传给客户端

JSP的三种语法

JSP头部的page指令

JSP的page指令可以修改JSP页面中一些重要的属性或者行为

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

language属性

表示JSP翻译后是什么语言文件，暂时只支持java

contentType属性

表示JSP返回的数据类型是什么，也是源码中response,setContentType()参数值，即网页的编译类型

pageEncoding属性

表示当前JSP页面文件本身的字符集，即本身的编译类型

import属性

跟Java源代码中一样，用于导包、导类

autoFlush属性 - 给out输出流使用

设置当out输出流缓冲区满了之后，是否自动刷新缓冲区。默认是true

buffer属性 - 给out输出流使用

设置缓冲区的大小，默认是8kb
:::tips
注意：以上两个属性一般是结合使用的。即如果说将缓冲区的大小改小，而且设置不会自动刷新缓冲区，那么就会报错
:::
缓冲区溢出错误

errorPage属性

设置当JSP页面运行时出错，自动跳转去的错误页面路径

isErrorPage属性

设置当前JSP页面是否是错误信息页面。默认是false，如果是true可以获取异常信息

session属性

设置访问当前JSP页面，是否会创建HttpSession对象，默认是true

extends属性

设置JSP翻译出来的java类默认继承谁

JSP中的常用脚本

声明脚本（极少使用）

:::tips
格式：<%! 声明java代码 %>
作用：可以给JSP翻译出来的java类定义属性和方法甚至是静态代码块、内部类等
:::

 <%!
        //声明Java代码，可以给jsp翻译出来的java类定义属性和方法甚至是静态代码块。内部类
        //1、声明类属性
        private Integer id;
        private String name;
        private static Map<String, Object> map;
    %>
    <%!
        //2、声明 static 静态代码块
        static {
            map = new HashMap<String, Object>();
            map.put("key1", "value1");
            map.put("key2", "value2");
            map.put("key3", "value3");
        }
    %>
    <%!
        //3、声明类方法
        public int abc() {
            return 12;
        }
    %>
    <%!
        //4、声明内部类
        public static class A {
            private Integer id = 12;
            private String abc = "abc";
        }
    %>

表达式脚本（常用）

:::tips
格式：<%=表达式%>
作用：在JSP页面上输出数据
:::
:::info
表达式脚本的特点：

所有的表达式脚本都会被翻译到_jspService()方法中
表达式脚本都会被翻译称为out.print()输出到页面上
由于表达式脚本翻译的内容都在_jspService()方法中，所以_jspService()方法中的对象都可以直接使用
表达式脚本中的表达式不能以分号结束

:::

1. 输出整型<br/>
<%=12 %><br/>
2. 输出浮点型<br/>
<%=12.12 %><br/>
3. 输出字符串<br/>
<%="我是字符串" %><br/>
4. 输出对象<br/>
<%=map%><br/>

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

代码脚本

:::tips
格式：<% java语句 %>
代码脚本的作用：可以在jsp页面中，编写我们自己需要的功能（写的是java语句）
:::
:::info
代码脚本的特点是：

代码脚本翻译之后都在_jspService方法中
代码脚本由于翻译到_jspService()方法中，所以在_jspService()方法中的现有对象（即内部对象）都可以直接使用
还可以由多个代码脚本块组合完成一个完整的java语句
代码脚本还可以和表达式脚本一起组合使用，在jsp页面上输出数据
:::

<%--    1. 代码脚本----if 语句--%>
    <%
        int i = 13;
        if (i == 12) {
            System.out.println("我好帅");
        } else {
            System.out.println("我又骗人了");
        }
    %>
<%--    2. 代码脚本----for 循环语句--%>
    <%
        for (int j = 0; j < 10; j++) {
    %>
        <%=j%> <br/>
    <%
            System.out.println(j);
        }
    %>
<%--    3. 翻译后 java 文件中_jspService 方法内的代码都可以写--%>
    <%
        String username = request.getParameter("username");
        System.out.println("用户名的请求参数是" + username);
    %>

JSP中的三种注释

html注释

<!--这是html注释-->

html注释会被翻译到java源代码中，在_jspService方法中，以out.writer输出到客户端

java注释

<%
    // 单行java注释
    /*
       多行java注释
     */
%>

java注释会被翻译到java源代码中

jsp注释

<%--这是jsp注释--%>

jsp注释可以注掉jsp页面中的所有代码

JSP九大内置对象

JSP中的内置对象，是指Tomcat在翻译jsp页面成为Servlet源代码后，内部提供的九大对象，叫内置对象

request	请求对象
response	响应对象
pageContext	jsp的上下文对象
session	会话对象
application	ServletContext对象
config	ServletConfig对象
out	jsp输出流对象
page	指向当前jsp的对象
exception	异常对象

JSP四大域对象

pageContext（PageContextImpl类）	当前jsp页面范围内有效
request（HttpServletRequest类）	一次请求内有效
session（HttpSession类）	一个会话范围内有效（打开浏览器访问服务器，直到关闭浏览器）
application（ServletContext类）	整个web工程范围内有效（只要web工程不停止，数据都在）

域对象是可以像Map一样存取数据的对象，四个域对象的功能一样，不同的是它们对数据的存取范围

虽然四个域对象都可以存取数据，但在使用上它们是有优先顺序的
:::tips
四个域在使用的时候，优先顺序从小到大的范围的顺序为：
pageContext —>>> request —>>> session —>>> application
:::

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2022-11-15
  Time: 18:06
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>scope.jsp页面</h1>
    <%
        pageContext.setAttribute("key", "pageContext");
        request.setAttribute("key", "request");
        session.setAttribute("key", "session");
        application.setAttribute("key", "application");
    %>
    pageContext域是否有值<%=pageContext.getAttribute("key")%><br/>
    request域是否有值<%=request.getAttribute("key")%><br/>
    session域是否有值<%=session.getAttribute("key")%><br/>
    application域是否有值<%=application.getAttribute("key")%><br/>
    <%
        request.getRequestDispatcher("/scope2.jsp").forward(request, response);
    %>
</body>
</html>

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2022-11-15
  Time: 18:06
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>scope2.jsp页面</h1>
    pageContext域是否有值<%=pageContext.getAttribute("key")%><br/>
    request域是否有值<%=request.getAttribute("key")%><br/>
    session域是否有值<%=session.getAttribute("key")%><br/>
    application域是否有值<%=application.getAttribute("key")%><br/>
</body>
</html>

刚开始的访问结果

切换页面，pageContext失效，它只能在自己的jsp页面范围内使用

刷新界面，即再次请求服务器，request失效，它只能在一次请求内使用

重新打开浏览器，即先关闭浏览器再重新打开，session失效，session在浏览器关闭后失效

重启web工程，application失效

JSP中的out输出和response.getWriter输出的区别

:::tips
response表示响应，我们经常用于设置返回给客户端的内容（输出）
out也是给用户做输出使用的
:::

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2022-11-15
  Time: 18:23
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
      out.write("out输出1<br/>");
      out.write("out输出2<br/>");
    	response.getWriter().write("response输出1<br/>");
     	response.getWriter().write("response输出2<br/>");
</body>
</html>

我们会发现，即使out和response交换位置，也是response先输出来

:::tips
因为当jsp页面中所有代码执行完成会做以下的两个操作：

执行out.flush()操作，会把out缓冲区中的数据追加写入到response缓冲区末尾
会执行response的刷新操作，把全部数据写给客户端
:::

由于jsp翻译之后，底层源代码都是使用out来进行输出，所以一般情况下，我们在jsp页面中统一使用out来进行输出。以免打乱页面输出内容的顺序
:::tips
out.write() 输出字符串没有问题
out.print() 输出任意数据都没有问题（都转换成为字符串后调用的write输出）
:::
print()底层 - 都是将其转换成字符串再调用write()方法

write()底层 - 将其强转成字符再传给cb缓冲区数组

结论：在jsp页面中，可以统一使用out.print()方法来进行输出

JSP的常用标签

JSP静态包含

<%@ include file="/include/footer.jsp">

:::tips
**<%@ include file=“”%> 就是静态包含 **
**file 属性指定你要包含的 jsp 页面的路径 **
**地址中第一个斜杠 / 表示为 http://ip:port/工程路径/ 映射到代码的 web 目录 **
**静态包含的特点： **
**1、静态包含不会翻译被包含的 jsp 页面。 **
2、静态包含其实是把被包含的 jsp 页面的代码拷贝到包含的位置执行输出。
:::

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2022-11-15
  Time: 19:00
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    头部信息<br/>
    主体内容<br/>
        <%@ include file=""%>这个就是静态包含
            file属性指定你要包含的jsp页面的路径

            地址中第一个斜杠表示为http://ip:port/工程路径/   映射到代码的web目录

            静态包含的特点：
                1. 静态包含不会翻译被包含的jsp页面
                2. 静态包含其实是把被包含的jsp页面的代码拷贝到包含的位置执行输出
 		<%@ include file="/include/footer.jsp"%>
</body>
</html>

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2022-11-15
  Time: 19:00
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    页脚信息<br/>
    改一下内容
    改一下内容
    <%=request.getParameter("username")%>
</body>
</html>

JSP动态包含

<jsp:include page="/include/footer.jsp">
    <jsp:param name="username" value="bbj"/>
    <jsp:param name="password" value="root"/>
</jsp:include>

:::tips
**<jsp:include page=“”></jsp:include> 这是动态包含 **
**page 属性是指定你要包含的 jsp 页面的路径 **
**动态包含也可以像静态包含一样。把被包含的内容执行输出到包含位置 **
**动态包含的特点： **
**1、动态包含会把包含的 jsp 页面也翻译成为 java 代码 **
**2、动态包含底层代码使用如下代码去调用被包含的 jsp 页面执行输出。 **
**JspRuntimeLibrary.include(request, response, “/include/footer.jsp”, out, false); **
3、动态包含，还可以传递参数
:::

动态包含的底层原理

JSP标签转发

<jsp:forward page="/scope2.jsp"></jsp:forward>

:::tips
**<jsp:forward page=“”></jsp:forward> 是请求转发标签，它的功能就是请求转发 **
page 属性设置请求转发的路径
:::

Listener监听器

:::tips

**Listener 监听器它是 JavaWeb 的三大组件之一。JavaWeb 的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。 **
**Listener 它是 JavaEE 的规范，就是接口 **
监听器的作用是，监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理
:::

极大多数的监听器都没用了，就ServletContextListener还有点用

ServletContextListener监听器

:::tips
**ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。 **
**ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。 **
监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈
:::

:::tips
使用ServletContextListener监听器监听ServletContext对象

编写一个类去实现ServletContextListener
实现其两个回调方法
到web,xml中去配置监听器
:::

package com.zan.listener;

import jakarta.servlet.ServletContextEvent;
import jakarta.servlet.ServletContextListener;

public class MyServletContextListenerImpl implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContext对象被创建了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext对象被销毁了");
    }
}