JSP是Servlet？监听器又是什么？

最新推荐文章于 2022-05-02 21:11:40 发布

destiny- freedom

最新推荐文章于 2022-05-02 21:11:40 发布

阅读量341

点赞数 4

分类专栏： JavaWeb 文章标签： web jsp

本文链接：https://blog.csdn.net/qq_42282074/article/details/105490910

版权

JavaWeb 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

文章目录

什么是jsp，它有什么用?

jsp的全称是java server pages。Java的服务器页面。
jsp的主要作用是代替Servlet程序回传html页面的数据。
因为Servlet程序回传html页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。
Servlet回传html页面数据的代码：

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");
        writer.write("\r\n");
    }
}

jsp回传一个简单html页面的代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    这是html页面数据
</body>
</html>

jsp的小结：
1. 如何创建jsp的页面?
在这里插入图片描述
2、jsp如何访问：
jsp页面和html页面一样，都是存放在web目录下。访问也跟访问html页面一样。
比如：
在web目录下有如下的文件：
web目录
a.html页面访问地址是 =======>>>>>> http://ip:port/工程路径/a.html
b.jsp页面访问地址是 =======>>>>>> http://ip:port/工程路径/b.jsp

jsp的本质是什么。

jsp页面本质上是一个Servlet程序。
当我们第一次访问jsp页面的时候。Tomcat服务器会帮我们把jsp页面翻译成为一个java源文件。并且对它进行编译成为.class字节码程序。我们打开java源文件不难发现其里面的内容是：
在这里插入图片描述
我们跟踪原代码发现，HttpJspBase类。它直接地继承了HttpServlet类。也就是说。jsp翻译出来的java类，它间接了继承了HttpServlet类。也就是说，翻译出来的是一个Servlet程序

总结：通过翻译的java源代码我们就可以得到结果：jsp就是Servlet程序。
大家也可以去观察翻译出来的Servlet程序的源代码，不难发现。其底层实现，也是通过输出流。把html页面数据回传给客户端。

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("\r\n");
        out.write("<html>\r\n");
        out.write("<head>\r\n");
        out.write("    <title>Title</title>\r\n");
        out.write("</head>\r\n");
        out.write("<body>\r\n");
        out.write("    a.jsp页面\r\n");
        out.write("</body>\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);
    }
}

jsp的三种语法

jsp头部的page指令
jsp的page指令可以修改jsp页面中一些重要的属性，或者行为。

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

i. language属性表示jsp翻译后是什么语言文件。暂时只支持java。
ii. contentType属性表示jsp返回的数据类型是什么。也是源码中response.setContentType()参数值
iii. pageEncoding属性表示当前jsp页面文件本身的字符集。
iv. import属性跟java源代码中一样。用于导包，导类。

两个属性是给out输出流使用
v. autoFlush属性设置当out输出流缓冲区满了之后，是否自动刷新冲级区。默认值是true。
vi. buffer属性设置out缓冲区的大小。默认是8kb

缓冲区溢出错误：
在这里插入图片描述
vii. errorPage属性设置当jsp页面运行时出错，自动跳转去的错误页面路径。

<!--
errorPage表示错误后自动跳转去的路径　<br/>
这个路径一般都是以斜杠打头，它表示请求地址为http://ip:port/工程路径/
映射到代码的Web目录
-->

viii. isErrorPage属性设置当前jsp页面是否是错误信息页面。默认是false。如果是true可以获取异常信息。

ix. session 属性设置访问当前jsp页面，是否会创建HttpSession对象。默认是true。
x. extends 属性设置jsp翻译出来的java类默认继承谁。

jsp中的常用脚本

声明脚本(极少使用)
声明脚本的格式是： <%! 声明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";
        }
    %>

声明脚本代码翻译对照：
在这里插入图片描述
2. 表达式脚本（常用）
表达式脚本的格式是：<%=表达式%>
表达式脚本的作用是：的jsp页面上输出数据。

表达式脚本的特点：
1、所有的表达式脚本都会被翻译到_jspService() 方法中
2、表达式脚本都会被翻译成为out.print()输出到页面上
3、由于表达式脚本翻译的内容都在_jspService() 方法中,所以_jspService()方法中的对象都可以直接使用。
4、表达式脚本中的表达式不能以分号结束。

<%=12 %> <br>
<%=12.12 %> <br>
<%="我是字符串" %> <br>
<%=map%> <br>
<%=request.getParameter("username")%>

翻译对照：
在这里插入图片描述

iii. 代码脚本
代码脚本的格式是：

		<%
   			java 语句
		%>

代码脚本的作用是：可以在jsp页面中，编写我们自己需要的功能（写的是java语句）。

代码脚本的特点是：
1、代码脚本翻译之后都在_jspService方法中
2、代码脚本由于翻译到_jspService()方法中，所以在_jspService()方法中的现有对象都可以直接使用。
3、还可以由多个代码脚本块组合完成一个完整的java语句。
4、代码脚本还可以和表达式脚本一起组合使用，在jsp页面上输出数据

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

翻译之后的对比：
在这里插入图片描述

jsp中的三种注释

i. html注释

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

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

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

java注释会被翻译到java源代码中。
iii. jsp注释

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

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

jsp九大内置对象

jsp中的内置对象，是指Tomcat在翻译jsp页面成为Servlet源代码后，内部提供的九大对象，叫内置对象。
在这里插入图片描述

jsp四大域对象

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

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

虽然四个域对象都可以存取数据。在使用上它们是有优先顺序的。

四个域在使用的时候，优先顺序分别是，他们从小到大的范围的顺序。

pageContext ====>>> request ====>>> session ====>>> application

<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>

<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>

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

response中表示响应，我们经常用于设置返回给客户端的内容（输出）
out也是给用户做输出使用的。
在这里插入图片描述
由于jsp翻译之后，底层源代码都是使用out来进行输出，所以一般情况下。我们在jsp页面中统一使用out来进行输出。避免打乱页面输出内容的顺序。

out.write() 输出字符串没有问题

out.print() 输出任意数据都没有问题（都转换成为字符串后调用的write输出）

深入源码，浅出结论：在jsp页面中，可以统一使用out.print()来进行输出

jsp的常用标签

jsp静态包含

<%--
    <%@ include file=""%> 就是静态包含
        file 属性指定你要包含的jsp页面的路径
        地址中第一个斜杠 / 表示为http://ip:port/工程路径/  映射到代码的web目录

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

jsp动态包含
<%–
<jsp:include page=""></jsp:include> 这是动态包含
page 属性是指定你要包含的jsp页面的路径
动态包含也可以像静态包含一样。把被包含的内容执行输出到包含位置

动态包含的特点：
1、动态包含会把包含的jsp页面也翻译成为java代码
2、动态包含底层代码使用如下代码去调用被包含的jsp页面执行输出。
JspRuntimeLibrary.include(request, response, “/include/footer.jsp”, out, false);
3、动态包含，还可以传递参数
–%>
<jsp:include page="/include/footer.jsp">
<jsp:param name=“username” value=“bbj”/>
<jsp:param name=“password” value=“root”/>
</jsp:include>
动态包含的底层原理：
jsp标签-转发

<%--
    <jsp:forward page=""></jsp:forward> 是请求转发标签，它的功能就是请求转发
        page 属性设置请求转发的路径
--%>
<jsp:forward page="/scope2.jsp"></jsp:forward>

练习一：在jsp页面中输出九九乘法口诀表

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <style type="text/css">

        table{
            width: 650px;
        }

    </style>
</head>
<body>
    <%-- 练习一：在jsp页面中输出九九乘法口诀表 --%>
    <h1 align="center">九九乘法口诀表</h1>
    <table align="center">
<%-- 外层循环遍历行 --%>
    <% for (int i = 1; i <= 9; i++) { %>
        <tr>
	<%-- 内层循环遍历单元格 --%>
        <% for (int j = 1; j <= i ; j++) { %>
            <td><%=j + "x" + i + "=" + (i*j)%></td>
        <% } %>
        </tr>
    <% } %>
    </table>
</body>
</html>

练习二：jsp输出一个表格，里面有10个学生信息。
在这里插入图片描述 Student类：

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String phone;

SearchStudentServlet程序：

public class SearchStudentServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求的参数
        // 发sql语句查询学生的信息
        // 使用for循环生成查询到的数据做模拟
        List<Student> studentList = new ArrayList<Student>();
        for (int i = 0; i < 10; i++) {
            int t = i + 1;
            studentList.add(new Student(t,"name"+t, 18+t,"phone"+t));
        }
        // 保存查询到的结果（学生信息）到request域中
        req.setAttribute("stuList", studentList);
        // 请求转发到showStudent.jsp页面
        req.getRequestDispatcher("/test/showStudent.jsp").forward(req,resp);
    }
}

showStudent.jsp页面

<%@ page import="java.util.List" %>
<%@ page import="com.atguigu.pojo.Student" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <style>
        table{
            border: 1px blue solid;
            width: 600px;
            border-collapse: collapse;
        }
        td,th{
            border: 1px blue solid;
        }
    </style>
</head>
<body>
<%--练习二：jsp输出一个表格，里面有10个学生信息。--%>
    <%
        List<Student> studentList = (List<Student>) request.getAttribute("stuList");
    %>
    <table>
        <tr>
            <td>编号</td>
            <td>姓名</td>
            <td>年龄</td>
            <td>电话</td>
            <td>操作</td>
        </tr>
    <% for (Student student : studentList) { %>
        <tr>
            <td><%=student.getId()%></td>
            <td><%=student.getName()%></td>
            <td><%=student.getAge()%></td>
            <td><%=student.getPhone()%></td>
            <td>删除、修改</td>
        </tr>
    <% } %>
    </table>

</body>
</html>

什么是Listener监听器？

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

ServletContextListener监听器

ServletContextListener它可以监听ServletContext对象的创建和销毁。

ServletContext对象在web工程启动的时候创建，在web工程停止的时候销毁。

监听到创建和销毁之后都会分别调用ServletContextListener监听器的方法反馈。
两个方法分别是：

public interface ServletContextListener extends EventListener {
    /**
     * 在ServletContext对象创建之后马上调用，做初始化
     */
    public void contextInitialized(ServletContextEvent sce);
    /**
     * 在ServletContext对象销毁之后调用
     */
    public void contextDestroyed(ServletContextEvent sce);
}

如何使用ServletContextListener监听器监听ServletContext对象。
使用步骤如下：
1、编写一个类去实现ServletContextListener
2、实现其两个回调方法
3、到web.xml中去配置监听器

监听器实现类：

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对象被销毁了");
    }
}

web.xml中的配置：

<!--配置监听器-->
<listener>
    <listener-class>com.atguigu.listener.MyServletContextListenerImpl</listener-class>
</listener>

JavaEE3.0规范。使用注解配置Listener监听器

在这里插入图片描述

destiny- freedom

关注

4
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录