华清远见-重庆中心-Javaweb后端知识总结

JavaWeb

使用Java开发Web服务的技术，统称为JavaWeb。

B/S与C/S模式

B/S：Browser/Server 浏览器/服务器模式
用户只需要一个浏览器即可访问服务器
C/S：Clint/Server 客户端/服务器模式
用户需要下载客户端才能访问服务器
网站
用户通过浏览器访问某个域名或IP地址时，浏览到的综合性页面
实际就是发布在服务器上的一个应用程序，用户通过浏览器访问该程序。

网页

网站中的一个页面
静态页面：所有人看到的数据都一致
动态页面：不同的人看到的页面中的数据不一致
JavaWeb就是B/S模式下的软件开发，开发综合性的服务网站。

网络服务器

部署Web项目的平台。

Tomcat

由Apache、Sun和其他公司及个人共同开发的web服务器。
免费、开源、轻量级，在中小型系统中普遍被使用。
是开发和调试Web项目的首选。

Maven

用于结构化管理jar文件的工具。
通过在Maven项目中加入某个jar文件的依赖，让其自动从Maven云仓库中下载对应的jar文件。

使用IDEA创建基于Maven的Web项目

1.新建webapp模板

2.设置项目名称和路径

3.设置Maven配置文件

Maven默认的配置文件会从官网下载jar文件，速度较慢，并且下载的jar文件默认会保存在c盘。
这里在D盘的根目录下新建了一个MavenRepository的本地仓库，用于保存下载的jar文件，并且设置国内的镜像下载。
配置文件

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!--这个根路径可以更改-->
<localRepository>D:\MavenRepository\maven_jar</localRepository>
<mirrors>
   <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>*</mirrorOf>
      <name>阿里云公共仓库</name>
     <url>https://maven.aliyun.com/repository/public</url>
   </mirror>
    </mirrors>
    <profiles>
  </profiles>
</settings>

如果IDEA版本没有这个选项，暂时跳过，等待项目创建成功后进入主界面进行设置。

4.从Maven云仓库中搜索所需的jar文件

选择合适的版本
复制Maven依赖代码

5.粘贴到项目中的pom.xml文件中的dependencies标签 中

如果下载失败，修改版本再次刷新尝试，如果一直不成功，删除groupId对应的本地目录后刷新尝试。

6.在src目录下新建编写类的java目录

7.修改项目的web.xml版本为4.0

8.配置tomcat服务器

9.部署创建好的项目到Tomcat服务器中

解决Tomcat控制台乱码

-Dfile.encoding=utf-8

HTTP状态码

常见状态码	含义
200	成功
404	资源未找到
500	服务器内部错误
405	方法不允许

Servlet

Server+Applet 运行在服务器上的程序

编写Servlet的步骤

1.在项目中导入Servlet相关依赖

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>  <version>4.0.1</version>
  <scope>provided</scope>
</dependency>

2.在项目的java目录下，创建一个类，继承HttpServlet，重写doGet和doPost方法

通常用户无论发送的是get还是post请求，实际都会执行同一件事情。
为了不将代码重复写两遍，可以在doPost方法中调用doGet方法或在doGet方法中调用doPost方法

/*
* Servlet是运行在服务器上的应用程序
* 编写一个Servlet的步骤
* 1.创建一个类型，继承HttpServlet
* 2.重写doGet和doPost方法
* 3.在web.xml中设置请求该Servlet的URL地址
* */
public class FirstServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
//只需编写一遍代码
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
//为了不重复编写代码，在这get中调用post或在post中调用get
doPost(req, resp);
}
}

3.在web.xml中设置Servlet的请求映射

<!--声明一个Servlet-->
<servlet>
<!--自定义Servlet的名称-->
<servlet-name>firstServlet</servlet-name>
<!--Servlet类所在完整路径(全限定名)-->
<servlet-class>com.hqyj.servlet.FirstServlet</servlet-class>
</servlet>
<!--设置某个Servlet的请求映射-->
<servlet-mapping>
<!--指定要设置映射的Servlet-->
<servlet-name>firstServlet</servlet-name>
<!--设置请求映射，以/开头-->
<url-pattern>/first</url-pattern>
</servlet-mapping>

4.访问Servlet

至此，重启tomcat，访问"项目上下文地址/first"，就表示访问FirstServlet类。
如果是通过浏览器地址栏访问，相当于get请求，执行servlet中的doGet方法

三层架构

在软件开发中，并不是将所有功能都交给一个类去实现，而是要将其进行分层，从而达到**"高内聚、低耦合**"的目的。
低耦合是指降低各个模块之间的关联程度，这样便于开发和维护，每个模块各司其职。
高内聚是指每个模块内的功能不可再分。
比如要用积木拼出来一辆车，不要把所有积木放在一起拼，这样其中一部分出现问题，就会影响到其他
地方。
最好的做法是先将车的各个组件拼接完成(解耦)，每个组件都是完整的不可再分的整体(高内聚)，最终再
把各个组件拼接到一起。
这样便于发现问题解决问题，不影响其他模块。
通常所说的三层架构中的三层，是指“数据访问层、业务逻辑层和视图表现层”

• 数据访问层，用于连接数据库，对数据做增删改查的操作
• 业务逻辑层，用于处理业务逻辑，在适当的情况下调用数据访问层中的方法
• 视图表现层，用于展示数据和提供用户输入数据的渠道，在适当的情况下调用业务逻辑层中的方法.

访问服务器的某个URL

• 在浏览器的地址栏中输入对应的URL，属于GET提交
• 使用a标签，在href中输入对应的URL，属于GET提交
• 使用form表单，在action中输入对应的URL，通过method修改提交方式为GET或POST

页面向服务端提交数据的方式

• 使用form表单的name属性显示提交

<form action="http://localhost:8080/day1/hero" method="get">
<input type="text" name="username">
<input type="submit">
</form>

提交的数据会暴露在浏览器的地址栏中

• 使用form表单的name属性隐式提交

<form action="http://localhost:8080/day1/hero" method="post">
<input type="text" name="username">
<input type="submit">
</form>

提交的数据不会暴露在浏览器的地址栏中

• 通过"?参数名=值"方式提交
  • 在地址栏中输入URL的时候，末尾加入这部分

https://www.baidu.com/s?wd=hello

• 在a标签的href属性中加入这部分

<a href="https://www.baidu.com/s?wd=hello">访问</a>

服务器端获取页面传递的数据

以上任何方式提交到服务器的数据，都可以使用以下方式获取。
String str=request.getParameter(“name名或?后的参数名”);

class TestServlet extends HttpServlet{
doGet(HttpServletRequest req,HttpServletResponse resp){
//获取表单提交的数据req.getParameter("表单中某个表单元素的name值");
String username = req.getParameter("username");
}
doPost(HttpServletRequest req,HttpServletResponse resp){
doGet();
}
}

解决请求和响应的中文乱码

//在servlet的doGet或doPost所有代码之前中加入
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");

表单提交数据注意事项

• 表单通过action提交设置的路径，如果要在路径中传递参数，只能使用post方式提交

<form action="xxxxx?参数=值" method="post">
</form>

• 使用get方式提交，无法识别action路径中的参数，如果要传递参数，使用隐藏域

<form action="xxxxx" method="get">
<input type="hidden" name="参数名" value="参数值">
</form>

Servlet的生命周期

构造方法–>init()–>service()/doGet()/doPost()–>destory()
在访问某servlet时
1.执行构造方法一次
2.初始化一次，调用init()方法
3.调用service()方法，之后每次访问都会调用该方法。有该方法时，doGet和doPost失效。
如果没有该方法，会根据请求方式试图调用doGet或doPost，如果没有相应的方法，会出现405状态
码，表示请求方式不允许
4.在当前servlet所在项目从tomcat中停止时，销毁一次，调用destory()方法

使用注解开发Servlet

/*
* 使用注解开发Servlet
* 注解：@特定单词 如@Override
*
* 定义且配置Servlet的注解:@WebServlet("/请求映射")
* */
@WebServlet("/sysAdmin")
public class SysAdminServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) {
//访问该Servlet时要执行的内容
}
}
//@WebServlet("/sysAdmin")相当于在web.xml中进行配置servlet映射

JSP

Java serverpage
使用java开发、运行在服务器上的页面。
jsp文件的后缀名为".jsp"。
由于最初由Servlet渲染页面，在Java代码中加入大量html的内容，使用极不方便。所以sun公司推出了jsp,可以在页面中加入Java代码，让页面称为动态页面。
JSP页面的本质是一个Java文件（servlet）。
所以在访问某个JSP页面时，会让该页面重新编译为.Java文件----->.class文件，所以第一次访问时会慢一些。

JSP的组成

1、HTML元素

2、脚本（Java代码）

<%java代码;%>

3、表达式

用于在页面中嵌入变量的值

<%=变量%>

4、指令

<%@指令名  属性=值%>

page指令 用于设置当前页面的属性

include指令 用于引入其他页面

taglib之林 用于引入其他标签库

5、注释

<%--jsp注释--%>//无法在浏览器中查看jsp注释
<!--html注释--!>//可以在浏览器中查看html注释

6、声明

<%! 定义方法 %>//不建议使用，

7、动作

jsp

<jsp:动作名></jsp:动作名>

跳转

1、页面与页面之间跳转

<a href="另一个页面的地址">超链接</a>
<form action=”另一个页面的地址“>
  <input type="submit">
</form>


<button id="btn">跳转</button>
<script>
    $("#btn").click(function(){
    location.href="地址"；
});
</script>

页面跳转至servlet

<a href="servlet映射名">超链接</a>
<form action="servlet映射名">
<input type="submit">
</form>

servlet跳转到页面或另一个servlet

请求转发（内部跳转）

request.getRequestDispatcher("跳转的地址").forward(request,response)

重定向（外部跳转）

response.sendRedirect("跳转的页面")

• 跳转到目的地时，浏览器的地址栏中的内容是访问时的地址

• 如果在某个Servlet做完增删改的操作后，不要使用请求转发。因为当重新刷新页面时，会重复提交
• 如果在request中保存了数据，只能通过请求转发才能读取request中保存的数据

重定向(外部跳转)

response.sendRedirect("跳转的地址");

• 跳转到目的地时，浏览器的地址栏中的内容是最终的目的路径
• 在做完增删改的操作后，使用重定向，可以保证最终页面与之前页面无关，刷新时不会重新提交
• 如果在request中保存了数据，使用重定向，保存的数据就会丢失

跳转时传递数据

保存

作用域对象.setSttribute(String str,Object obj);
//将一个名为str的对象obj保存到某个作用域中，request就是一个作用域
list<泛型>集合=dao.查询();
//将查询到的集合保存到请求中，命名为list
request.setSttribute("list",集合)

获取

Object obj = 作用域对象.getAttribute(String str);
//获取到的数据是Object类型，通常需要转型
List<泛型> list =(List<泛型>) request.getAttribute("list");

绝对路径

<a href="localhost:8080/system/pages/hello.html">跳转</a>

相对路径问题

• /
  表示从根目录(域名+ip)出发
• ./
  表示从当前位置出发
• …/
  表示跳向上一层

如有index页面所在路径为
localhost:8080/system/pages/index.html
<a href="/hello.html">跳转</a>
这种方式，从根目录(localhost:8080)出发，会跳转到localhost:8080/hello.html
<a href="./hello.html">跳转</a>
这种方式，从当前位置(localhost:8080/system/pages)出发，会跳转到
localhost:8080/system/pages/hello.html
<a href="../hello.html">跳转</a>
这种方式，从当前位置跳向上一层，会跳转到localhost:8080/system/hello.html

• 在jsp页面中，可以使用${pageContex.request.contextPath}表示页面上下文路径。
  如项目默认上下文访问路径为localhost:8080/system

<a href="${pageContex.request.contextPath}/pages/hello.html">跳转</a>

以上路径相当于/system/pages/hello.html，即从根目录出发localhost:8080/system/pages/hello.html
如果在jsp页面中无法识别${}，在<%@ page%>中加入isELIgnored=“false”

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

四大作用域对象

作用域：共享数据的区域

pageContext

当前页面对象。共享数据区域范围为当前页面。
如果不在同一个页面，数据无法读取。

request

请求对象。共享数据区域范围为一次请求。
如果跳转中途使用了重定向，数据无法读取。

session

会话对象。会话是用户访问服务器时的某个时间段。
共享数据区域范围在这个时间段内，默认30分钟。
如果在指定时间内没有操作或销毁会话时，数据无法读取。

application

项目对象。共享数据区域范围为整个项目。

作用域范围

application > session > request > pageContext

以上四个作用域对象，都有这几个方法

//将某个对象obj保存到作用域中，命名为str
作用域对象.setAttribute(String str,Object obj);
//从某个作用域中获取保存的某个对象
Object obj = 作用域对象.getAttribute(String str);
//从某个作用域中移除某个保存的对象
作用域对象.removeAttribute(String str);

作用域对象的使用

在JSP页面中

作用域对象也称为内置对象，直接通过对应的单词使用
P1.JSP

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
//在jsp中使用pageContext页面上下文对象，跳转到p2时不能使用
pageContext.setAttribute("str","保存在pageContext作用域中的字符串");
//在jsp中使用request请求对象，请求转发到p2时可以使用，重定向到p2时不能使用
request.setAttribute("str","保存在request中的字符串");
//在jsp中使用session会话对象，在默认的30分钟内，没有销毁，哪种跳转都能在p2中使用
session.setAttribute("str","保存在session中的字符串");
//在jsp中使用application应用程序对象，整个项目中任何页面都能使用
application.setAttribute("str","保存在application中的字符串");
//以上四个作用域对象，也是jsp中的内置对象，无需定义
//销毁会话
//session.invalidate();
//使用请求转发跳转到p2.jsp
//request.getRequestDispatcher("p2.jsp").forward(request,response);
//使用重定向跳转到p2.jsp
response.sendRedirect("p2.jsp");
%>
<h1><%=pageContext.getAttribute("str")%></h1>
</body>
</html>

p2.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3><%=pageContext.getAttribute("str")%></h3>
<h3><%=request.getAttribute("str")%></h3>
<h3><%=session.getAttribute("str")%></h3>
<h3><%=application.getAttribute("str")%></h3>
</body>
</html>

在servlet中使用

• pageContext
  servlet本身就是一个java类，在类中定义成员变量，就能在当前类中使用。
  所以在servlet中不会使用pageContext对象
• request
  使用doGet/doPost/service方法中的HttpServletRequest参数req
• session

//在servlet中使用session，需要通过请求对象request调用getSession()方法
HttpSession session= req.getSession();

• application

//通过getServletContext()方法获取的ServletContext类型对象，就是当前项目对象
ServletContext application = getServletContext();

总结

• 在jsp页面中使用pageContext保存的数据，只能共享于当前页面
• 通常在servlet中查询后的数据保存在request中，使用请求转发跳转到其他页面，在对应的页面中
  数据数据
• 通常在登录后，将登录的用户保存在session中，无论用哪种方式跳转，都能从session中获取当时登录的用户。
• 在application中保存一些共享于整个项目中的数据

EL

Expression Language 表达式语言
是为了使JSP写起来更加简便，替换JSP中的<%=%>，简化了JSP页面中输出数据的操作。
主要输出保存在某个作用域中的数据。

特点

如果通过"某个作用域对象.setAttribute(“cus”,customer)"方法保存的对象，
在JSP页面中如果用表达式，使用<%=cus%>，如果用EL，使用${cus}输出。
会依次从pageContext–>reqeust–>session–>application中获取指定对象，
如果一旦从某个作用域中获取到了指定对象，就不再判断后续作用域。也可以输出指定作用域中的对象。

• 只能输出保存在作用域中的对象
• 减少代码(省去了获取对象、转换的过程)
• 免去非空判断
  • 如果某个要输出的对象不存在，不会输出null，而是输出空字符串""。

使用

在页面中输出保存在作用域中的对象

• 从作用域中依次查询并输出对象

${对象名}

• 从指定作用域中输出对象

作用域	对应作用域	代码
pageScope	当前页pageContex	${pageScope.对象}
requestScope	请求request	${requestScope.对象}
sessionScope	会话session	${sessionScope.对象}
applicationScope	项目application	${applicationScope.对象}

• 输出对象的属性

${对象名.属性名}
${对象名["属性名"]}

• 输出对象的方法返回值

${对象名.方法名()}

跳转到某个页面

<a href="另一个页面的地址">超链接</a>
<form action=”另一个页面的地址“>
  <input type="submit">
</form>


<button id="btn">跳转</button>
<script>
    $("#btn").click(function(){
    location.href="地址"；
});
</script>

在页面中获取请求中的参数

用于获取表单提交的数据或超链接?后传递的数据。
使用${param.参数名}替换request.getParameter(“参数”)。
如有表单或超链接

<form action="page.jsp">
<input type="text" name="username">
<input type="submit">
</form>
<a href="page.jsp?username=admin">跳转</a>

在page.jsp中获取

<html>
<head></head>
<body>
<%-- 传统写法--%>
<% String username = request.getParameter("username");%>
<h3>
<%=username%>;
</h3>
<%--如果使用EL--%>
<h3>
${param.username}
</h3>
</body>
</html>

用于获取当前项目上下文(根目录+项目名)路径

如http://localhost:8080/Web03/就是一个项目上下文路径，
在JSP中使用**${pageContext.request.contextPath}**获取项目上下文路径

<form action="${pageContext.request.contextPath}/servlet映射">
</form>
<a href="${pageContext.request.contextPath}/页面路径">超链接</a>

注意

• web.xml版本在4.0之后，在JSP中使用EL时，默认可以识别。
• 如果JSP无法识别EL，在指令(<%@ %>)中加入 isELIgnored="false"表示不忽略EL。

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

JSTL

Java Server Page Standarded Tag Library JSP标准标签库
可以使用JSTL中的特定标签，来替换JSP中常见的Java代码。如循环判断等，减少Java代码，提高页面的
可读性。

使用

1、导入JST对应的依赖

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>

2、在JSP页面中，加入标签库指令

<%--在当前页面中使用jstl，加入以下指令--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

3、具体用法

• 定义变量或给变量赋值

<c:set var="变量名" value="值"></c:set>

• if判断

<c:if test="判断条件">
满足条件时的内容
</c:if>

• 遍历List集合

<c:forEach items="要遍历的集合" var="遍历出的对象名"></c:forEach>

• 遍历Map集合

<c:forEach items="要遍历的集合名" var="遍历出的键值对的名称">
${键值对名.key.属性}
${键值对名.value.属性}
</c:forEach>

Ajax

Asynchronous Javascript And XML
异步JavaScript和XML
一种数据交互方式，请求和响应是异步的。
使用ajax能实现在整个页面不重新加载的情况下，更新局部内容。

使用

浏览器都是支持异步提交，原生的JavaScript就能实现ajax，但使用极不方便，所以都是使用jquery封装
后的$.ajax()或 $.get() $.post()等函数。

1.在页面中导入jquery文件

<!--使用Ajax,需要导入jquery-->
<scriptsrc="jquery文件路径"></script>

2.在script标签中写ajax

<script>
某个节点.事件(function(){
//使用ajax异步提交数据
$.ajax({
//访问的URL地址
url:"servlet映射或具体url"，
//提交的数据
data:{
//键:值
"形参":值,
"形参":值
},
//提交方式
type:"get/post/put/delete",
//成功访问URL后的回调函数
success:function(res){//res表示访问URL后返回的数据
},
//访问URL失败时的回调函数
error:function(){
}
});
});
</script>

JSP内置对象

在jsp页面中有一些对象是已经定义好了可以直接使用的，称为内置对象。
一共有9个内置对象。
“rrppsoace”

• request
  • 请求作用域对象
• response
  • 响应对象
• pageContext
  • 当前页作用域对象
• session
  • 会话作用域对象
• page
  • 当前jsp页面对象
• out
  • 输出对象
• application
  • 项目作用域对象
• config
  • 配置对象
• exception
  • 异常对象

Session和Cookie

这两个都是用于保存数据的对象。
session是一个作用域对象，在servlet中通过request.getSession()获取，在JSP中直接使用内置对象
session获取。
cookie是一个对象，也是一个文件，保存在本地。

Cookie

cookie通常用于更长时间地保存一些信息，即便关闭浏览器，也能保存。

cookie的创建

//创建cookie
Cookie cookie = new Cookie("username", "保存在cookie中的用户名");
//设置有效时长,单位为秒，这里表示7天有效
cookie.setMaxAge(60*60*24*7);
//通过响应对象response保存cookie对象到本地
response.addCookie(cookie);

cookie的获取

//读取cookie时是获取当前站点的所有cookie数组
Cookie[] cks = request.getCookies();
//遍历
for(Cookie ck :cks){
System.out.println( ck.getName()+"--"+ck.getValue());
}

Session

session是一个作用域对象，在访问任意jsp页面时，默认就会创建一个session对象(可以通过设置取消自
动创建)。
通常使用session保存一些信息，用于在同一站点的各个页面之间共享数据。
原理：

• 1.当访问的jsp页面或servlet中使用了session，会创建一个JSESSIONID(session编号)，这是一个字符串，保存在一个cookie中。
  • 默认访问某个jsp页面时，该页面中没有使用session，也会自动创建session，因为

<%--默认每个jsp页面都有这句话，表示访问该页面时，自动使用session--%>
<%@ page session="true"%>

  如果将其设置为false，访问该jsp时则不会自动创建session。

• 2.再次访问该页面时，会查询该JSESSIONID是否存在，如果存在，直接使用，如果不存在，创建新的JSESSIONID
• 3.保存该JSESSIONID的cookie会随着浏览器的关闭自动销毁，所以关闭浏览器，session就会失效。

session对象的常用方法

常用方法	作用
session.setAttribute(String str,Object obj)	将obj对象保存在session中，命名为str
session.getAttribute(String str)	获取保存在session中的对象
session.removeAttribute(String str)	移除保存在session中的对象
session.invalidate()	销毁session
session.getCreationTime()	获取session创建时间对应的毫秒数
session.getId()	获取JSESSIONID
session.getMaxInactiveInterval()	获取session有效时长(默认1800秒)
session.setMaxInactiveInterval(int seconds)	设置session有效时长，参数为秒
ServletContext app = session.getServletContext();	获取当前application对象

设置全局session有效时长

在指定时间内，打开浏览器但对session无操作，就会自动销毁session。

• 通过session.setMaxInactiveInterval(int seconds)设置有效秒数
• 在web.xml中配置

<!--设置全局session配置-->
<session-config>
<!--session有效时长，单位为分钟-->
<session-timeout>15</session-timeout>
</session-config>

Session和Cookie对比

• session中保存的是对象Object，cookie中保存的是字符串String，都以键值对的形式保存
• session保存在浏览器和服务器端，cookie保存在浏览器
• session保存的数据没有大小限制，cookie保存的数据有大小限制，不超过3KB
• session在30分钟内没有访问或随着浏览器的关闭而销毁，cookie可以设置销毁时间

监听器Listener

常用的三个监听器接口

ServletContextListener application监听器
HttpSessionListener session监听器
ServletRequestListener request监听器

实现一个监听器

1.创建一个类，实现某个监听器接口
2.重写某个监听器接口中方法

• 初始化的方法
• 销毁的方法
  3.在web.xml中配置监听器或通过注解配置
• 如果在web.xml中配置

!--配置监听器-->
<listener>
<!--设置监听器的全限定名-->
<listener-class>com.hqyj.bookShop.listener.MyListener</listener-class>
</listener>

• 如果通过注解配置，在自定义的监听器类上，加入@Web

过滤器Filter

使用

1.创建一个类，继承HttpFilter
2.重写其中受保护的doFilter的方法
3.在web.xml中配置过滤器或使用注解配置

• 在web.xml中配置的话

<!--声明过滤器-->
<filter>
<filter-name>myFilter</filter-name>
<filter-class>com.hqyj.filter.MyFilter</filter-class>
</filter>
<!--设置什么请求要经过该过滤器，通常过滤所有请求-->
<filter-mapping>
<filter-name>myFilter</filter-name>
<!--/*表示过滤所有请求-->
<url-pattern>/*</url-pattern>
</filter-mapping>

• 使用@WebFilter(“/*”)注解配置的话

package com.hqyj.filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/*
* 自定义一个过滤器
* 1.继承HttpFilter
* 2.重写受保护的doFilter方法
* 3.web.xml中配置该过滤器
* */
//@WebFilter("/*")
public class MyFilter extends HttpFilter {
@Override
protected void doFilter(HttpServletRequest req, HttpServletResponse res,
FilterChain chain) throws IOException, ServletException {
//由于设置了过滤所有请求，所以在这里设置请求的编码格式
req.setCharacterEncoding("utf-8");
//获取请求的地址后，决定是否放行
String uri = req.getRequestURI();
System.out.println(uri+"试图访问");
//判断地址中是否包含登录页或登录页相关的servlet映射或资源路径
if (uri.contains("login")||
uri.contains("customer")||uri.contains("jquery")) {
//允许放行
chain.doFilter(req,res);
return;
}
//如果登录成功，会在session中保存customer，所以在这里判断session中是否存在
customer，如果存在，放行一切请求
if(req.getSession().getAttribute("customer")==null){
res.sendRedirect("http://localhost:8080/Web03/pages/login.html");
}else{
//允许放行
chain.doFilter(req,res);
}
}}