Day32——Java web学习笔记part3

Java web学习笔记

文章目录

• Java web学习笔记
• 8、Cookie、Session
• 1、会话
• 2、保存会话的两种技术
• 3、Cookie
• 4、session（重）
• 9、Java Server Page
• 1、什么是JSP
• 2、JSP原理
• 3、JSP基础语法
• 4、JSP指令
• 5、9大内置对象
• 6、JSP标签、JSTL标签、EL表达式
• JSP标签
• JSTL表达式
• 7、JavaBean
• JavaBeans属性
• 访问JavaBeans
• 10、MVC三层架构
• 11、过滤器Filter（重）
• 12、监听器
• 过滤器与监听器常见应用

8、Cookie、Session

1、会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可称为会话。

有状态会话：（一个同学来过教室，下次再来教室，大家会知道这个同学曾经来过，称之有状态会话）

一个网站，怎么证明你访问过？

客户端——————服务端

1、服务端给客户端一个信件，客户端下次访问服务端带上信件就可；（cookie）

2、服务器登记客户端访问过，下次访问时来匹配就可；（session）

2、保存会话的两种技术

cookie

• 客户端技术（响应，请求）

session

• 服务器技术，利用这个技术，可以保存用户的会话信息，可以把信息或者数据放在Session中

常见场景：网站登录（如B站），第一次登录，第二次访问就直接登录

3、Cookie

简单地说，cookie 就是浏览器储存在用户电脑上的一小段文本文件。cookie 是纯文本格式，不包含任何可执行的代码。一个 Web 页面或服务器告知浏览器按照一定规范来储存这些信息，并在随后的请求中将这些信息发送至服务器，Web 服务器就可以使用这些信息来识别不同的用户。

1、从请求中拿到Cookie信息

2、服务器响应给客户端Cookie

Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName()//获得Cookie中的key
cookie.getValue()//获得Cookie中的value
new Cookie("lastLoginTime", System.currentTimeMillis()+"")//新建一个Cookie
cookie.setMaxAge(24*60*60);//设置Cookie的有效期
resp.addCookie(cookie);//响应给客户端一个cookie

cookie：一般会保存在本地的用户目录下appdata

细节问题：

一个网站cookie是否存在上限

• 一个cookie只能保存一个信息
• 一个web站点可以给浏览器发送多个cookie，最多存在20个cookie
• cookie大小有限制4kb
• 浏览器上限300个cookie

删除cookie方式：

• 不设置有效期，关闭浏览器就自动失效
• 设置有效期时间为0

测试：查看访问时间

编写Servlet类：

public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //服务器，告诉你，你来的时间，将这个时间封装成一个信件，你下次带来，我就知道你来了

        //解决中文乱码
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        PrintWriter out = resp.getWriter();

        //cookie,服务器端从客户端获取
        Cookie[] cookies = req.getCookies(); //返回值为数组，说明会返回多个

        //判断cookie是否存在
        if(cookies!=null){
            //如果存在（遍历）
            out.write("您第一次访问：");

            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                //获取cookie的名字
                if(cookie.getName().equals("lastLoginTime")){
                    //获取cookie中的值

                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());
                }
            }
        }else {
            out.write("这是您第一次访问本站");
        }

        //服务器给客户端发送(响应)一个cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");

        //cookie有效期为1天
        cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);
    }

在web.xml注册后运行：

---

测试2：将Cookie立刻过期:

       //创建一个Cookie，名字必须和要删除的名字一致
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");
        //将cookie有效期设置为0，立刻过期
        cookie.setMaxAge(0);

---

测试3：将cookie中放入中文

 @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        Cookie[] cookies = req.getCookies();

        PrintWriter out = resp.getWriter();

        //判断cookie是否存在
        if(cookies!=null){
            out.write("您第一次访问：");

            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                //获取cookie的名字
                if(cookie.getName().equals("name")){
                    //System.out.println(cookie.getValue());
                    //URLDecoder.decode(cookie.getValue(),"utf-8");//解码，以防在工作中遇到乱码
                    //out.write(cookie.getValue());
                    out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));
                }
            }
        }else {
            out.write("这是您第一次访问本站");
        }

        Cookie cookie = new Cookie("name", URLEncoder.encode("风在吼","utf-8"));//编码
        resp.addCookie(cookie);
    }

4、session（重）

什么是session？

• 服务器会给每一个用户（浏览器）创建一个session对象
• 一个session独占一个浏览器（只要浏览器没关闭，这个session就存在）
• 涉及场景（用户登录之后，整个网站都可以访问）—>保存用户的信息

Session和Cookie的区别：

• Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
• Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
• Session对象由服务器端创建

使Session失效的两种方法：

• session.invalidate();//注销之后会出现新的Session

• 在web.xml中

  <!--设置Session默认的失效时间-->
  <session-config>
      <!--15分钟后，Session自动失效（单位：分钟）-->
      <session-timeout>15</session-timeout>
  </session-config>

---

测试：读取Session的ID，并向Session中存放数据：

//得到Session
        HttpSession session = req.getSession();
 //获取Session的ID
        String sessionid = session.getId();
//判断Session是不是新创建的
        if (session.isNew()){
            resp.getWriter().write("Session创建成功，ID为"+sessionid);
        }else{
            resp.getWriter().write("Session已经在服务器中，ID为"+sessionid);
        }

在web.xml中注册后，运行：

Session存取数据：

新建一个person类

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
        @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在session中放入数据

//得到Session
HttpSession session = req.getSession();

//给Session中存放数据
session.setAttribute("name",new Person("黄河",5464));

将数据取出

 //Session中获取数据
        Person person = (Person) session.getAttribute("name");

        System.out.println(person.toString());

将session手动注销：

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        //手动注销Session
        session.invalidate();//注销之后会出现新的Session
    }
}

1、先取为null

2、先存入，在取

3、还可以取对象

使用场景：

• 保存一个登录用户的信息
• 购物车信息
• 在整个网站中经常用的数据，也将保存在Session中

9、Java Server Page

1、什么是JSP

JSP全称Java Server Pages，是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。标签通常以<%开头以%>结束。

JSP是一种Java servlet，主要用于实现Java web应用程序的用户界面部分。网页开发者们通过结合HTML代码、XHTML代码、XML元素以及嵌入JSP操作和命令来编写JSP。

JSP通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。

JSP标签有多种功能，比如访问数据库、记录用户选择信息、访问JavaBeans组件等，还可以在不同的网页中传递控制信息和共享信息。

最大的特点：

• 写JSP就像写HTML

JSP和HTML区别：

• Html只给用户提供静态数据
• JSP页面中可以嵌入Java代码，为用户提供动态数据

2、JSP原理

学习思路：JSP到底是怎么执行？

JSP处理

以下步骤表明了Web服务器是如何使用JSP来创建网页的：

• 就像其他普通的网页一样，您的浏览器发送一个HTTP请求给服务器。
• Web服务器识别出这是一个对JSP网页的请求，并且将该请求传递给JSP引擎。通过使用URL或者.jsp文件来完成。
• JSP引擎从磁盘中载入JSP文件，然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句，并且将所有的JSP元素转化成Java代码。
• JSP引擎将servlet编译成可执行类，并且将原始请求传递给servlet引擎。
• Web服务器的某组件将会调用servlet引擎，然后载入并执行servlet类。在执行过程中，servlet产生HTML格式的输出并将其内嵌于HTTP response中上交给Web服务器。
• Web服务器以静态HTML网页的形式将HTTP response返回到您的浏览器中。
• 最终，Web浏览器处理HTTP response中动态产生的HTML网页，就好像在处理静态网页一样。

本机上所体现为：

• 代码层面没有任何问题（所生成target文件夹中jsp文件内容与所之前所写一致）
• 在服务器内部工作
  • tomcat中有一个work目录：
  • IDEA中使用Tomcat，会在IDEA的tomcat中生成一个work目录
  • IDEA的tomcat的工作空间路径：C:\Users\fc.IntelliJIdea2018.1\system\tomcat
  • 本电脑：C:\Users\fc.IntelliJIdea2018.1\system\tomcat\Unnamed_javaweb-seesion-cookie\work\Catalina\localhost\s1\org\apache\jsp，此路径下发现页面转变成了Java程序
• 浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！

JSP最终也会被转换成为一个Java类

JSP 本质上就是一个Servlet

//初始化
  public void _jspInit() {
      
  }
//销毁
  public void _jspDestroy() {
  }
//JSPService
  public void _jspService(.HttpServletRequest request,HttpServletResponse response)
      

源码中所做一些功能：

1、判断请求

 if (!javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      final java.lang.String _jspx_method = request.getMethod();
      if ("OPTIONS".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        return;
      }
      if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");
        return;
      }
    }

2、内置一些对象

final javax.servlet.jsp.PageContext pageContext;  //页面上下文
javax.servlet.http.HttpSession session = null;    //session
final javax.servlet.ServletContext application;   //applicationContext
final javax.servlet.ServletConfig config;         //config
javax.servlet.jsp.JspWriter out = null;           //out
final java.lang.Object page = this;               //page：当前页
//外部两个对象
HttpServletRequest request                        //请求
HttpServletResponse response                      //响应

3、输出页面前增加的代码

response.setContentType("text/html");       //设置响应的页面类型
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;

4、以上的这些个对象我们可以在JSP页面中直接使用！

例如上面所示的out对象：

因为jsp源码中（如3所示的那些对象）已经存在，我们拿来就可用

用户访问服务器中.jsp页面流程：

用户——使用客户端访问——》服务器(服务器中存在web容器)——》JSP页面——转换（将.JSP页面转换为Java文件）——》xxx_jsp.java文件——编译——》xxx_jsp.class文件——再返回给服务器——》客户端（用户真正拿到的，就是服务器处理完毕的class对象，就是Servlet）

在JSP页面中；

只要是 JAVA代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("<html>\r\n");

以这样的格式输出到前端

3、JSP基础语法

JSP表达式

<%--JSP表达式
    作用：用来将程序的输出，输出到客户端
    <%= 变量或者表达式%>
    --%>
<%= new java.util.Date()%>

测试：

JSP脚本片段

<%--jsp脚本片段--%>

<%
    int sum = 0;
for (int i = 1; i <=100 ; i++) {
    sum+=i;
}
out.println("<h1>Sum="+sum+"</h1>");
%>

脚本片段的再实现

 <%
    int x = 10;
    out.println(x);
  %>
  <p>这是一个JSP文档</p>
  <%
    int y = 2;
    out.println(y);
  %>

  <hr>  <%--换行--%>

  <%--在代码嵌入HTML元素--%>
  <%
    for (int i = 0; i < 5; i++) {
  %>
    <h1>Hello,World  <%=i%> </h1>
  <%
    }
  %>

JSP声明

<%!
    static {
      System.out.println("Loading Servlet!");
    }

    private int globalVar = 0;

    public void high(){
      System.out.println("进入了方法high！");
    }
  %>

JSP声明：会被编译到JSP生成Java的类中！其他的，就会被生成到_jspService方法中！

在JSP，嵌入Java代码即可！

<%%>  片段
<%=%> 表达式输出一个值
<%!%> 定义全局

<%--EL表达式：${}--%>

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

JSP的注释，不会在客户端显示，HTML就会！

4、JSP指令

JSP指令用来设置整个JSP页面相关的属性，如网页的编码方式和脚本语言。

JSP中的三种指令标签：

指令	描述
<%@ page … %>	定义网页依赖属性，比如脚本语言、error页面、缓存需求等等
<%@ include … %>	包含其他文件
<%@ taglib … %>	引入标签库的定义

<%@ page … %>测试程序：

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

<%--定制错误页面--%>
<%@page errorPage="error/500.jsp" %>

<%--显示的声明这是一个错误页面--%>
<%@ page isErrorPage="true" %>

<head>
    <title>Title</title>
</head>
<body>
<%
    int i=1/0;
%>
</body>
</html>

<%--错误页面放入一个图片--%>
<body>
<img src="../img/500error.jpg" alt="">
</body>

<%@ include … %>进行测试：

<body>

<%--@include 会将两个页面合二为一--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>

<hr>
<%--JSP标签
jsp:include ：拼接页面，本质还是三个
--%>
<jsp:include page="/common/header.jsp"/>    <%--要把路径写对--%>
<h1>网页主体</h1>
<jsp:include page="/common/footer.jsp"/>

</body>

下面是源码：

jsp标签所放的东西，会在jspService方法外声明

@include file=“common/header.jsp”，会直接out.write()输出

5、9大内置对象

• PageContext 存东西
• Request 存东西
• Response
• Session 存东西
• Application 【SerlvetContext】 存东西
• config 【SerlvetConfig】
• out
• page ，不用了解
• exception

<%--内置对象--%>
<%
    pageContext.setAttribute("type1","风1");//保存的数据只在一个页面中有效
    request.setAttribute("type2","风2");  //保存的数据只在一次请求中有效，请求转发会携带这个数据
    session.setAttribute("type3","风3");  //保存的数据只在一次会话中有效(打开浏览器到关闭浏览器)
    application.setAttribute("type4","风4");//保存的数据在服务器中有效(打开服务器到关闭)
%>

测试：

<%--通过pageContext取出保存的值--%>
<%--注意：脚本片段中的代码，会被原封不动的生成到.jsp.java
所以要求：这里面的代码必须保证Java语法的正确性
--%>
<%
    //通过寻找方式来
    //从底层到高层(作用域)：page->request->session->application
    String type1 = (String) pageContext.findAttribute("type1");
    String type2 = (String) pageContext.findAttribute("type2");
    String type3 = (String) pageContext.findAttribute("type3");
    String type4 = (String) pageContext.findAttribute("type4");
    String type5 = (String) pageContext.findAttribute("type5");//不存在

%>

<%--使用EL表达式输出 ${}--%>

<h1>取出的值为：</h1>
<h3>${type1}</h3>
<h3>${type2}</h3>
<h3>${type3}</h3>
<h3>${type4}</h3>
<h3>${type5}</h3>
<%--EL表达式与普通查找语句对比--%>
<h3><%=type5%></h3>    <%--null--%>

从另一个页面测试取出上述的值：（取值代码与前面一致）

6、JSP标签、JSTL标签、EL表达式

所需导的依赖:

<!-- JSTL表达式的依赖 -->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<!-- standard标签库 -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式： ${ }

• 获取数据
• 执行运算
• 获取web开发的常用对象
• 调用Java方法（不常用）

JSP标签

测试：

<%--
在转发的时候携带参数：http://localhost:8080/jsptag.jsp?name=xiaohong&age=11
--%>
<jsp:forward page="/jsptag2.jsp">
    <jsp:param name="name" value="xiaohong"></jsp:param>
    <jsp:param name="age" value="11"></jsp:param>
</jsp:forward>

尝试取出参数：

<%=request.getParameter("name")%><br>
<%=request.getParameter("age")%>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！

根据JSTL标签所提供的功能，可以将其分为5个类别：

格式化标签

SQL标签

XML 标签

核心标签 （掌握部分）

JSTL 函数

---

JSTL标签库使用步骤

• 引入对应的 taglib
• 使用其中的方法
• 在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

解决报错方法：

将jstl和standard的jar包，从maven环境中放入tomcat服务器的lib中

栗子：if测试

<h4>if测试</h4>
<hr>
<form action="coreif.jsp"method="get">
    <%--EL表达式获取表单中的数据
     ${param.参数名 }
     --%>
    <input type="text"name="username" value="${param.username}">
        <input type="submit" value="登录">
</form>

<%--判断如果提交的用户名是admin，则登录成功--%>

<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="管理员欢迎你"/>
</c:if>
<c:out value="${isAdmin}"/>

when测试栗子：

<%--定义一个变量score，值为70--%>
<c:set var="score" value="70"/>

<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when>
    <c:when test="${score>=80}">
        你的成绩为一般
    </c:when>
    <c:when test="${score>=70}">
        你的成绩为良好
    </c:when>
    <c:when test="${score<=60}">
        你的成绩为不及格
    </c:when>
</c:choose>

测试foreach循环：

<%
    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    people.add(4,"田六");
    request.setAttribute("list",people);
%>

<%--
var , 每一次遍历出来的变量
items, 要遍历的对象
begin,   哪里开始
end,     到哪里
step,   步长
--%>

<c:forEach var="people" items="${list}">
    <c:out value="${people}"/> <br>
</c:forEach>
<hr>
<h4>设置begin end step后</h4>
<c:forEach var="people" items="${list}" begin="1" end="3" step="2" >
    <c:out value="${people}"/> <br>
</c:forEach>

7、JavaBean

通常称之为：实体类

JavaBean有特定的写法：

• 必须要有一个无参构造
• 属性必须私有化
• 必须有对应的get/set方法；

一般用来和数据库的字段做映射 ORM；

ORM ：对象关系映射

• (数据库)表—>(java实体类)类
• 字段–>属性
• 行记录---->对象

JavaBeans属性

一个JavaBean对象的属性应该是可访问的。这个属性可以是任意合法的Java数据类型，包括自定义Java类。

一个JavaBean对象的属性可以是可读写，或只读，或只写。 getPropertyName() 和 setPropertyName() 两个方法

进行测试：

先写一个Student.java文件

public class Student {
    private String name=null;
    private int age = 0;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

访问JavaBeans

<jsp:useBean >标签可以在JSP中声明一个JavaBean，然后使用。

<body>

<jsp:useBean id="student" class="com.feng.javabean.Student">
<jsp:setProperty name="student" property="name" value="xiaohong"/>
<jsp:setProperty name="student" property="age" value="22"/>
</jsp:useBean>

<p>Student Name:
    <jsp:getProperty name="student" property="name"/>
</p>
<p>Student Age:
    <jsp:getProperty name="student" property="age"/>
</p>

</body>

得到结果：

10、MVC三层架构

MVC概念：Model view Controller 模型、视图、控制器

早些年，架构为：二层

用户直接访问控制层，控制层就可以直接操作数据库；

servlet--CRUD-->数据库
//将增删改茶的代码要放入Servlet里
//弊端：程序十分臃肿，不利于维护  
//于是:
//Servlet的代码中会有：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

Model

• 业务处理 ：业务逻辑（Service）
• 数据持久层：CRUD （Dao）

View

• 展示数据
• 提供链接发起Servlet请求 （a，form，img…）

Controller （Servlet）

• 接收用户的请求 ：（req：请求参数、Session信息….）
• 交给业务层处理对应的代码
• 控制视图的跳转

在JSP/Servlet开发的软件系统中，这三个部分的描述如下所示：

1、Web浏览器发送HTTP请求到服务端，然后被Controller(Servlet)获取并进行处理（例如参数解析、请求转发）

2、Controller(Servlet)调用核心业务逻辑——Model部分，获得结果

3、Controller(Servlet)将逻辑处理结果交给View（JSP），动态输出HTML内容

4、动态生成的HTML内容返回到浏览器显示

MVC模式在Web开发中有很大的优势，它完美规避了JSP与Servlet各自的缺点，让Servlet只负责业务逻辑部分，而不会生成HTML代码；同时JSP中也不会充斥着大量的业务代码，这样能大提高了代码的可读性和可维护性。

11、过滤器Filter（重）

Filter：过滤器 ，用来过滤网站的数据；

• 处理中文乱码
• 登录验证….

Filter开发步骤：

1、导包：在pom.xml添加依赖

2、编写过滤器

• 实现Filter接口，Filter所在的包为javax.servlet

• 重写对应的方法

  public class CharacterEncodingFilter implements Filter {
      //初始化:web服务器启动，就已经初始化了，随实等待过滤对象出现
      public void init(FilterConfig filterConfig) throws ServletException {
          System.out.println("CharacterEncodingFilter初始化");
      }
  
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
          request.setCharacterEncoding("utf-8");
          response.setCharacterEncoding("utf-8");
          response.setContentType("text/html;charset=UTF-8");
  
          System.out.println("CharacterEncodingFilter执行前");
          chain.doFilter(request,response);//让请求执行，如果不写，程序到这里就停止
          System.out.println("CharacterEncodingFilter执行后");
      }
      //销毁：服务器关闭的时候才会销毁
      public void destroy() {
          System.out.println("CharacterEncodingFilter销毁");
      }
  }

• 编写一个显示类

public class ShowServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("开心");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

• 在web.xml中进行配置

    <servlet>
        <servlet-name>ShowServlet</servlet-name>
        <servlet-class>com.XX.servlet.ShowServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ShowServlet</servlet-name>
        <url-pattern>/servlet/show</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.XX.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <!--只要是 /servlet的任何请求，会经过这个过滤器-->
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>

没有配置Filter 的时候，ShowServlet页面上的字为乱码

配置之后：

进入几次这个页面就会在IDEA控制台会输出几次：

当关闭服务器时，Filter才会注销

12、监听器

实现一个监听器的接口；

对监听器进行使用，测试：统计当前网上在线人数：

1、实现监听接口

2、进行代码实现（主要思想是统计session个数）

public class OnlineCountListener implements HttpSessionListener {
    //创建session监听
    //一旦创建Session就会触发一次这个
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

        System.out.println(se.getSession().getId());
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount=new Integer(1);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);//count+1为count++
        }
        ctx.setAttribute("OnlineCount",onlineCount);
    }
//销毁session监听
    public void sessionDestroyed(HttpSessionEvent se) {

        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount=new Integer(0);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);//count+1为count++
        }
        ctx.setAttribute("OnlineCount",onlineCount);

    }
}

在首页index.jsp上编写显示程序

<body>
  <h1>当前有<span><%=this.getServletConfig().getServletContext().getAttribute("OnlineCount")%></span> 人在线</h1>
  </body>

在web.xml中进行注册

<!--注册监听器-->
    <listener>
        <listener-class>com.feng.listener.OnlineCountListener</listener-class>
    </listener>

点击运行

会出现页面上所显示人数与实际不一致，由于服务器原因，例如我这里出现3个SessionId：

只有最后一个才是浏览器中的。

再点击运行按钮，进行重新部署redeploy

控制台上就出现一个sessionid

浏览器处：

过滤器与监听器常见应用

测试：用户登录之后才能进入主页，用户注销之后就不能进入主页

1、编写一个登录页面(Login.jsp)，错误页面(error.jsp)，登陆成功后的页面(success.jsp)

2、提交按钮转到LoginServlet类中做判断，用户名是否和程序中所写一致，进入主页，否则进入编写的错误页面

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取前端请求的参数
        String username = req.getParameter("username");
        if (username.equals("admin")){
            req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
            resp.sendRedirect("/sys/success.jsp");
        }else{//登录失败
            resp.sendRedirect("/error.jsp");
        }
    }

3、此时在未登录成功的情况下，就能直接访问/Sys/success.jsp这个主页，需要解决，

方法一：比较low不推荐：在需要登录之后才能访问的页面上进行限制。

<%
    Object userSession = request.getSession().getAttribute("USER_SESSION");
    if (userSession==null){
        response.sendRedirect("/Login.jsp");
    }
%>

推荐解决方法二：使用过滤器!编写SysFilter类，这样做到”各司其职“。

public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        //解决方法二：用过滤器，这样各自职责分明
        //ServletRequest  HttpServletRequest 父子关系,进行强转
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;

        Object userSession = request.getSession().getAttribute("USER_SESSION");
        if (userSession==null){
            response.sendRedirect("/error.jsp");
        }
        chain.doFilter(request,response);
    }

此时，不登陆的前提下直接访问/sys/success.jsp页面就会转发至error页面

来源：CSDN

作者：fc2430

链接：https://blog.csdn.net/u013583756/article/details/104233460