IDEA项目实践——会话跟踪、Web当中的jsp编程以及jsp开发模型和EL与JSTL以及过滤器介绍

最新推荐文章于 2024-05-01 19:17:00 发布

张小鱼༒

最新推荐文章于 2024-05-01 19:17:00 发布

阅读量289

点赞数 1

分类专栏： IDEA软件的使用与相关项目的操作文章标签： java intellij-idea 前端 IDEA JSP EL JSTL

本文链接：https://blog.csdn.net/m0_56006701/article/details/132235807

版权

IDEA软件的使用与相关项目的操作专栏收录该内容

16 篇文章 4 订阅

订阅专栏

系列文章目录

IDEA项目实践——创建Java项目以及创建Maven项目案例、使用数据库连接池创建项目简介

IDEWA项目实践——mybatis的一些基本原理以及案例

IDEA项目实践——动态SQL、关系映射、注解开发

IDEA项目实践——Spring框架简介，以及IOC注解

IDEA项目实践——Spring当中的切面AOP

IDEA项目实践——Spring集成mybatis、spring当中的事务

IDEA项目实践——JavaWeb简介以及Servlet编程实战

文章目录

Model2：JSP+JavaBean+Servlet

前言

本文主要介绍会话跟踪、Web当中的jsp编程以及jsp开发模型和EL与JSTL以及过滤器。

三、会话跟踪

3.1 Cookie

【案例1 记住密码】

实现效果 当勾选“记住密码”复选框时，下次访问登录页面，会自动记住账号，密码信息。

【案例2 上次访问时间】

实现效果 首次登录，显示“欢迎您，XXX” 下次登录，显示“欢迎您，XXX,您上次登录时间为 yyyy年MM月dd日 hh:mm:ss”

1. 概念： Cookie是客户端会话技术，将数据保存在客户端，以保留了各种跟踪信息。

2. 识别用户包括三个步骤：

（1）服务器脚本向浏览器发送一组 Cookie。例如：姓名、年龄或识别号码等。（2）浏览器将这些信息存储在本地计算机上，以备将来使用。（3）当下一次浏览器向 Web 服务器发送任何请求时，浏览器会把这些 Cookie 信息发送到服务器，服务器将使用这些信息来识别用户。

3. 通过 Servlet 设置 Cookie 包括三个步骤：

(1) 创建一个 Cookie 对象：您可以调用带有 cookie 名称和 cookie 值的 Cookie 构造函数，cookie 名称和 cookie 值都是字符串。

 Cookie cookie = new Cookie("key","value");

请记住，无论是名字还是值，都不应该包含空格或以下任何字符：

 [ ] ( ) = , " / ? @ : ;

(2) 设置最大生存周期：您可以使用 setMaxAge 方法来指定 cookie 能够保持有效的时间（以秒为单位）。下面将设置一个最长有效期为 24 小时的 cookie。

 cookie.setMaxAge(60*60*24);

setMaxAge的参数有如下三种情况：

正数：将Cookie数据写到硬盘的文件中。持久化存储。并指定cookie存活时间，时间到后，cookie文件自动失效
负数：默认值，当浏览器关闭后，Cookie数据被销毁
零：删除cookie信息

(3) 发送 Cookie 到 HTTP 响应头：您可以使用 response.addCookie 来添加 HTTP 响应头中的 Cookie，如下所示：

 response.addCookie(cookie);

4.通过 Servlet 读取 Cookie 要读取 Cookie，您需要通过调用 HttpServletRequest 的 getCookies( ) 方法创建一个 javax.servlet.http.Cookie 对象的数组。然后循环遍历数组，并使用 getName() 和 getValue() 方法来访问每个 cookie 和关联的值。

 Cookie[] cookies = request.getCookies();
 for (Cookie cookie : cookies) {
     if (cookie.getName().equals("username")){
         username = cookie.getValue();
     }
     if (cookie.getName().equals("password")){
         password = cookie.getValue();
     }
 }

5.通过 Servlet 删除 Cookie 删除 Cookie 是非常简单的。如果您想删除一个 cookie，那么您只需要按照以下三个步骤进行：

（1）读取一个现有的 cookie，并把它存储在 Cookie 对象中。

（2）使用 setMaxAge() 方法设置 cookie 的年龄为零，来删除现有的 cookie。

（3）把这个 cookie 添加到响应头。

//JSP Cookie 保存中文内容，需要对中文进行编码与解码，方法如下：
 String str = java.net.URLEncoder.encode("中文"，"UTF-8");            //编码
 String str = java.net.URLDecoder.decode("编码后的字符串","UTF-8");   // 解码

3.2 Session

【案例1 登录、退出系统案例】

实现效果 1.登录系统后可在各个页面可以显示登录用户名。 2.当退出系统后，访问非登录页面，显示“请登录”超链接。（创建/获取Session，删除Session会话数据）

【案例2 购物车案例】

实现效果 1. 2.

概念：Session是服务端会话技术，将数据保存在服务端，以保留了各种跟踪信息。提供了一种跨多个页面请求或访问网站时识别用户以及存储有关用户信息的方式。
使用步骤
常用方法（1）获取Session HttpSession session = request.getSession(); （2）设置属性 session.setAttribute("key",value); （3）获取属性 Object value = session.getAttribute("key");--根据情况，进行类型转换（4）删除属性 session.removeAttribute("key"); （5）销毁session session.invalidate();

3.3 隐藏的表单域

3.4 URL重写

指的是将Session的会话标识号以参数的形式附加在超链接的URL地址后面。

在HttpServletResponse接口中，定义了两个用于完成URL重写的方法：

<1>encodeURL(String url):用于对超链接和form的action中设置的url重写。

<2>encodeRedirectURL(String url): 用于对要传递给response.sendRedirect方法的url重写。

注意：在重写URL是，前面要通过getSession()方法获取Session对象。

四、JSP编程

4.1 JSP基本语法

JSP=HTML+Java

JSP的本质是Servlet

访问JSP的时候

（1）JSP转换成Servlet

（2）执行Servlet文件

(1)HTML模板数据

(2)JSP元素

I Java部分-脚本

（1）脚本段：<% 脚本 %>
（2）声明： <%! 声明 %>【声明方法、变量等等】
（3）表达式：<%= 表达式 %> 注意：表达式后不能加分号
（4）注释：<%-- JSP注释 --%>

案例演示

index.jsp文件：

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%!
        //1.声明 会成为 jsp转换的servlet的 成员变量或者成员方法
        //声明方法
        public void test(){
            System.out.println("jsp声明");
        }

        //声明变量
        int num = 10;
    %>
    <%

        //2.只是service方法中，要执行的一段代码
        System.out.println("脚本端");
        int score = 90;

        Date date = new Date();
    %>

    <%--3.表达式会在页面上输出--%>
    <%= 1+2 %>
    <%=score %>

    <%--JSP的注释--%>
    <!--  HTML的注释 -->

    <%
        int a = 1;
        System.out.println(a);

        request.getMethod();
        response.setContentType("text/html");
        config.getInitParameter("");
        session.getAttribute("");
        application.getRealPath("");
        page.toString();

        out.println();
        pageContext.getAttribute("");

        exception.getMessage();

    %>

    <%=score%>
    <%
        out.println(score);
    %>
</body>
</html>

jsp注释与HTML注释区别：

II Java部分-指令

（1）page指令

语法：<%@ page 属性1=值1 属性2=值2... %>

 <%@ page language=”java” import=”java.util.*” contentType="text/html; charset=utf-8" session="true/false" errorPage="url" isErrorPage="true/false" buffer="" %>

导包需要放在配置指令里面导入

注意：在一个JSP页面中可以使用多个<%@page %>指令，但其中的属性只能用一次，不过import属性例外，它可以多次出现，引入多个类和包，这和Java中的import语句差不多。

（2）include指令

语法：

<%@ include file="相对的URL" %>

作用：静态包含

注意：

被引入的文件必须遵循JSP语法。

被引入的文件可以使用任意的扩展名，但都会被JSP引擎按照JSP页面的处理方式去处理，为了见名知意，建议使用“.jspf”（JSP fragment，即JSP片段）作为静态引入文件的扩展名。

被引入的文件中不要包含<html></html>、<body></body>等标记，因为这样会影响引入文件中同样的标记。

引入和被引入文件中的指令不能冲突（page指令中的pageEncoding和import属性除外）。

此处做一演示，添加一个total.jsp的文件【这个是总的页面】

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ include file="header.jsp"%>
<style>
    div{
        margin: 0px auto;
        width: 1000px;
        height: 200px;
        background-color: blueviolet;
    }
</style>
<body>
    <div>
        <h1>页面主体内容</h1>
    </div>
</body>
<%@ include file="footer.jsp"%>

写一个header.jsp文件：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <style>
        div{
            margin: 0px auto;
            width: 1000px;
            height: 200px;
            background-color: aqua;
        }
    </style>
</head>
<body>
<div><h1>Header</h1></div>
</body>
</html>

编写一个footer.jsp文件：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <style>
        div{
            margin: 0px auto;
            width: 1000px;
            height: 200px;
            background-color: antiquewhite;
        }
    </style>
</head>
<body>
    <div>CopyRight:@......</div>
</body>
</html>

运行的效果如上图所示

（3）taglib指令【标签控制】

 <%@ taglib uri=”” prefix=”” %>

作用：是减少jsp页面中的java代码

IIIJava部分-动作（了解）

（1）<jsp:include>动作元素

语法：

 <jsp:include page="relativeURL" flush="true|false" />
     page属性用于指定被引入资源的相对路径
     flush属性用于指定是否将当前页面的输出内容刷新到客户端。

作用：把其他资源的输出内容插入到当前JSP页面的输出内容中。----动态包含

案例：

<%@--     include.jsp     --%>
 
 <%@ 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>include</title>
 </head>
 <body>
     <%Thread.sleep(5000);%>
     included.jsp内的中文<br />
 </body>
 </html>

 <%@--     dynamicInclude.jsp     --%>
 
 <%@ 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>dynamicInclude page</title>
 </head>
 <body>
     dynamicInclude.jsp内的中文
     <br>
     <jsp:include page="included.jsp" flush="true" />
     <%--对比：flush为true和false的区别。--%>
     <%--<jsp:include page="included.jsp" flush="false" />--%>
 
     dynamicInclude.jsp内的中文2
 </body>
 </html>

include指令和<jsp:include>标签有很大的区别：

<jsp:include>标签要引入的资源和当前JSP页面是两个彼此独立的执行实体，即被动态引入的资源必须能够被Web容器独立执行。而include指令只能引入遵循JSP格式的文件，被引入文件与当前JSP文件需要共同合并才能翻译成一个Servlet源文件。
<jsp:include>标签要引入的资源是在运行时才包含的。而include指令引入的资源是在编译时期包含的，包含的是源代码。
<jsp:include>标签运行原理与RequestDispatcher.include()方法类似，即被包含的页面不能改变响应状态码或者设置响应头，而include指令没有这方面的限制。

（2）<jsp:forward>动作元素

语法：

 <jsp:forward page="relativeURL" />

类似：请求转发

4.2 JSP内置对象

(1)九个内置对象

jsp的内置对象：JSP内置对象是不需要声明和创建就可以在JSP页面脚本中使用的成员变量。

九个内置对象：

1.out对象

在JSP页面中，经常需要向客户端发送文本内容，这时，可以使用out对象来实现。out对象是javax.servlet.jsp.JspWriter类的实例对象，它的作用与ServletResponse.getWriter()方法返回的PrintWriter对象非常相似，都是用来向客户端发送文本形式的实体内容。不同的是，out对象的类型为JspWriter，它相当于一种带缓存功能的PrintWriter。接下来，通过一张图来描述JSP页面的out对象与Servlet引擎提供的缓冲区之间的工作关系，具体如图所示。

从图可以看出，在JSP页面中，通过out隐式对象写入数据相当于将数据插入到JspWriter对象的缓冲区中，只有调用了ServletResponse.getWriter()方法，缓冲区中的数据才能真正写入到Servlet引擎所提供的缓冲区中。

通过一个案例演示out对象的使用：

 <%@ page language="java" contentType="text/html; charset=UTF-8" %>
 <html>
 <head>
 <title>Insert title here</title>
 </head>
 <body>
     <%
         out.println("first line<br />"); //写入JspWriter对象的缓冲区
         response.getWriter().println("second line<br />");//写入servlet引擎提供的缓冲区，即Response缓冲区
     %>
 </body>
 </html>

注意：内容的输出顺序。

多学一招：使用page指令设置out对象的缓冲区大小

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

2.pageContext对象

pageContext对象是javax.servlet.jsp.PageContext类的实例对象，它代表当前JSP页面的运行环境。

（1）pageContext对象获取隐式对象的方法：

（2）pageContext对象不仅提供了获取隐式对象的方法，还提供了存储数据的功能。pageContext对象存储数据是通过操作属性来实现的，下表列举了pageContext操作属性的一系列方法，具体如下：

上表列举了pageContext对象操作属性的相关方法，其中，参数name指定的是属性名称，参数scope指定的是属性的作用范围。pageContext对象的作用范围有4个值，具体如下：

pageContext.PAGE_SCOPE：表示页面范围
pageContext.REQUEST_SCOPE：表示请求范围
pageContext.SESSION_SCOPE：表示会话范围
pageContext.APPLICATION_SCOPE：表示Web应用程序范围

需要注意的是，当使用findAttribute()方法查找名称为name的属性时，会按照page、request、session和application的顺序依次进行查找，如果找到，则返回属性的名称，否则返回null。

3.exception对象

在JSP页面中，经常需要处理一些异常信息，这时，可以通过exception对象来实现。exception对象是java.lang.Exception类的实例对象，它用于封装JSP中抛出的异常信息。需要注意的是，exception对象只有在错误处理页面才可以使用，即page指令中指定了属性<%@ page isErrorPage=”true”%>的页面。

(2)四个作用域

作用：共享数据

(1)pageContext ：数据只能在当前页面使用

(2)request

(3)session

(4)application

附录：

1.使用IntelliJ IDEA编译jsp文档后servlet的存储路径

路径：

C:\Users\Administrator.IntelliJIdea2017.2\system\tomcat\Unnamed_MovieSystem\work\Catalina\localhost\

2.如何修改这个路径参照此文：Idea 临时文件路径修改 - 简书

五、JSP开发模型

MVC

1.JSP演化历史

1. 早期只有servlet，只能使用response输出标签数据，非常麻烦

2. 后来有了jsp，简化了Servlet的开发，如果过度使用jsp，在jsp中即写大量的java代码，有写html表，造成难于维护，难于分工协作

3. 再后来，java的web开发，借鉴mvc开发模式，使得程序的设计更加合理性

2.MVC详解

1. M：Model模型（JavaBean）

* 完成具体的业务操作，如：查询数据库，封装对象

2. V：View视图（JSP）

* 展示数据

3. C：Controller控制器（Servlet）

* 获取用户的输入

* 调用模型

* 将数据交给视图进行展示

3.优缺点：

1. 优点：

1. 耦合性低，方便维护，可以利于分工协作

2. 重用性高

2. 缺点：

1. 使得项目架构变得复杂，对开发人员要求高

Model1：JSP+JavaBean

Model2：JSP+JavaBean+Servlet

六、EL与JSTL

1.EL

(1).JSP脚本的缺点

使用JSP脚本可以实现页面输出显示，那为什么还需要使用EL简化输出呢？这是因为单纯使用JSP脚本与HTML标签混合，实现输出显示的方式存在一些弊端，归纳如下：

代码结构混乱，可读性差。
脚本与HTML标签混合，容易导致错误。
代码不易维护。

核心作用：

减少jsp中的java代码 [注意：el只能用在jsp中]

(2).EL表达式

（1）EL表达式

EL是Expression Language的缩写，它定义了一系列的隐含对象和操作符，使开发人员能够很方便地访问页面内容，以及不同作用域内的对象，而无须在JSP中嵌入Java代码，从而使得页面结构更加清晰，代码可读性更高，也更加便于维护。

（2）EL表达式的语法

语法：${EL表达式}

语法结构中包含"$"符号和”{}“括号，二者缺一不可。

使用EL表达式也非常简单，如${username}就可以实现访问变量username的值。

注意：使用EL表达式获取变量前，必须将操作的对象保存到作用域中。

此外，使用EL表达式还可以访问对象的属性，这就需要使用“.”操作符和“[ ]”操作符来完成。

“.”操作符

EL表达式通常由对象和属性两部分组成。因此采用与Java代码一样的方式，用“.”操作符来访问对象的属性。

例如：${news.title}可以访问news对象的title属性。

“[ ]”操作符

“[ ]”操作符的使用方法与“.”操作符类似，不仅可以用来访问对象的属性，还可以用于访问数组和集合。例如：

①访问对象的属性：${news["title"]}可以访问news对象的title属性。

②访问数组：${newsList[0]}可以访问newsList数组中的第一个元素。

示例代码：

<%@ page import="java.util.ArrayList" %>
 <%@ page import="java.util.Date" %>
 <%@ page contentType="text/html;charset=UTF-8" language="java"%>
 <html>
 <head>
     <title>EL表达式</title>
 </head>
 <body>
 <h1>EL表达式</h1>
 <%
     String username = "tom";
     //将变量添加到作用域中
     request.setAttribute("username",username);
     request.setAttribute("student.name","张三");
     ArrayList list = new ArrayList();
     list.add("新冠疫情");
     list.add("俄乌战争");
     //将集合添加到作用域中
     request.setAttribute("list",list);
     //将日期对象添加到作用域中
     Date date = new Date();
     request.setAttribute("date",date);
 %>
     //访问变量 <br>
     ${username}<br>
     //含有特殊字符的变量 <br>
     ${requestScope["student.name"]}<br>
     //访问集合 <br>
     ${list[1]}<br>
     //访问对象 <br>
     ${date.date}<br>
     //读取参数 (需要从地址栏传参数，例如：http://localhost:8088/ELDemo.jsp?num=1)<br>
     ${param.num}<br>
     //读取参数 (需要从地址栏传参数，例如：http://localhost:8088/ELDemo.jsp?num=1&hobby=a&hobby=b&hobby=c)<br>
     ${paramValues.hobby[2]}<br>
 </body>
 </html>

运行效果：

提示：

①使用“[ ]”操作符访问数据时，必须在属性名两侧使用双引号。

②EL表达式区分大小写。

③在使用EL表达式获取变量前，必须先将对象保存到作用域中。

表达式分类：

（1） 普通表达式

（2）读取单值（基本数据类型）

（3）读取多值（对象）

EL的隐含对象：

序号	隐含对象	描述
1	pageScope	page 作用域
2	requestScope	request 作用域
3	sessionScope	session 作用域
4	applicationScope	application 作用域
5	param	Request 对象的参数，字符串
6	paramValues	Request对象的参数，字符串集合
7	header	HTTP 信息头，字符串
8	headerValues	HTTP 信息头，字符串集合
9	initParam	上下文初始化参数
10	cookie	Cookie值
11	pageContext	当前页面的pageContext，通过pageContext可以访问ServletContext,Request,Response,Session等

前四个是作用域【使用较多】，第五第六获取参数。

(3).EL运算符

EL表达式支持多种运算符，这些运算符的使用方法与Java运算符非常类似。另外，在EL表达式中，为了避免一些运算符在使用时与HTML页面标签发生冲突，会采用其他符号进行替代。

操作符	描述
.	访问一个Bean属性或者一个映射条目
[]	访问一个数组或者链表的元素
( )	组织一个子表达式以改变优先级
+	加
-	减或负
*	乘
/ or div	除
% or mod	取模
== or eq	测试是否相等
!= or ne	测试是否不等
< or lt	测试是否小于
> or gt	测试是否大于
<= or le	测试是否小于等于
>= or ge	测试是否大于等于
&& or and	测试逻辑与
\|\| or or	测试逻辑或
! or not	测试取反
empty	测试是否空值

EL的运算符： （1）算术运算符（2）关系运算符（3）逻辑运算符（4） Empty运算符（5）条件运算符例子：${2 > 1 ? "yes" : "no" }

(4).EL的功能

对于EL的特点和作用，归纳总结如下：

可用于获取JavaBean的属性。
能够读取集合类型对象中的元素。
可使用运算符进行数据处理。
可屏蔽一些常见异常。
可自动实现类型转换。

(5).EL表达式的作用域访问对象

JSP提供了4种作用域，分别是page、request、session和application。为了能够访问这4个作用域内的数据，EL表达式也分别提供了4种作用域访问对象来实现数据的读取。这4个作用域访问对象的比较如下：

名称	说明
pageScope	与页面作用域（page）中的属性相关联的Map类，主要用于获取页面范围内的属性值
requestScope	与请求作用域（request）中的属性相关联的Map类，主要用于获取请求范围内的属性值
sessionScope	与会话作用域（session）中的属性相关联的Map类，主要用于获取会话范围内的属性值
applicationScope	与应用程序作用域（application）中的属性相关联的Map类，主要用于获取应用程序范围内的属性值

当使用EL表达式访问某个属性值时，应当指定查找的范围。如果程序中未指定查找的范围，那么系统会自动按照page → request → session → application的顺序进行查找。

使用作用域访问对象读取属性值非常简单，只需要使用“作用域名称 .”方式即可实现。

总结：

EL从作用域/参数/信息头/初始化参数/cookie中获取数据，显示到JSP页面。

2.JSTL

使用EL表达式已经实现了页面输出显示的优化，为什么还需要使用JSTL呢？这是因为使用EL表达式无法实现逻辑处理，如循环、条件判断等，因此还需要与Java代码混合使用，而JSTL则可以实现逻辑控制，从而进一步优化代码。

（1）.JSTL简介

概念：JSTL（Java Server Pages Strandard Tag Library，JSP标准标签库）包含了在开发JSP时经常用到的一系列标准标签。这些标签提供了一种不用嵌套Java代码就可以实现复杂JSP开发的途径。

主要功能：实现JSP页面中的逻辑控制

分类：JSTL按照不同的用途又可以划分为多个分类：

标签库名称	资源标示符（uri）	前缀（prefix）
核心标签库	http://java.sun.com/jsp/jstl/core	c
国际化/格式化标签库	http://java.sun.com/jsp/jstl/fmt	fmt
XML标签库	http://java.sun.com/jsp/jstl/xml	x
数据库标签库	http://java.sun.com/jsp/jstl/sql	sql
函数标签库	http://java.sun.com/jsp/jstl/functions	fn

JSTL使用步骤：

1.下载jstl.jar和standard.jar包

Index of /dist/jakarta/taglibs/standard/binaries

2.将这两个包复制到WEB-INF\lib目录，并添加到项目中。

3.在JSP页面中添加指令

 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

标签总结：

标签名称	作用
<c:out />	输出文本内容到out对象，常用于显示特殊字符，显示默认值
c:set/	在作用域中设置变量或对象属性的值
c:remove/	在作用域中移除变量的值
c:if/	实现条件判断结构
c:forEach/	实现循环结构
c:url/	构造url地址
c:param/	在url后附加参数
c:import/	在页面中嵌入另一个资源内容
fmt:formatDate/	格式化时间
fmt:formatNumber/	格式化数字

七、过滤器

概念

过滤器，顾名思义，就是在源数据和目的数据之间起过滤作用的中间组件。

过滤器可以动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息。

filter是对客户端访问资源的过滤，符合条件放行，不符合条件不放行，并且可以对目标资源访问前后进行逻辑处理。

过滤器可以实现以下目的：

在客户端的请求访问后端资源之前，拦截这些请求。
在服务器的响应发送回客户端之前，处理这些响应。

过滤器要实现的接口是Filter（javax.servlet包中） 过滤器的三个重要方法： （1） Init(FilterConfig config) （2） doFilter(ServletRequest request,ServletResponse response,FilterChain chain) chain.doFilter(request,response);//将请求传给下一个过滤器或目标资源。（3） destory()销毁

过滤器的配置：

(1)xml配置

   <filter>
     <filter-name>EncodingFilter</filter-name>
     <filter-class>com.ambow.filter.EncodingFilter</filter-class>
     <init-param>
             <param-name>encoding</param-name>
             <param-value>utf-8</param-value>
     </init-param>
   </filter>
   <filter-mapping>
     <filter-name>EncodingFilter</filter-name>
     <url-pattern>/*</url-pattern>
   </filter-mapping>

Servlet和过滤器不同的在URL里面，过滤器一般写的是*,指的拦截大多数的url

（2）注解配置在Servlet3.0之后，可以使用注解进行配置

 @WebFilter( filterName = "LoginFilter",urlPatterns = { "/jsps/cart/*", "/jsps/order/*" }, servletNames = { "CartItemServlet", "OrderServlet" })
 public class LoginFilter implements Filter {
                ...
 }

注解配置参考：https://www.cnblogs.com/ooo0/p/10360952.html

重点应用：

统一字符编码

统一权限验证

过滤放行之前，每次都要被先执行

过滤链filterchain去调用请求

总结

以上就是今天的内容~

欢迎大家点赞👍，收藏⭐，转发🚀，
如有问题、建议，请您在评论区留言💬哦。

最后：转载请注明出处！！！

张小鱼༒

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
IDEA项目实践——会话跟踪、Web当中的jsp编程以及jsp开发模型和EL与JSTL以及过滤器介绍

本文主要介绍会话跟踪、Web当中的jsp编程以及jsp开发模型和EL与JSTL以及过滤器。以上就是今天的内容~如有问题、建议，请您在评论区留言💬哦。最后：转载请注明出处！！！
复制链接

扫一扫