JavaWeb知识点

常见问题解决

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

public class MServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决请求时的乱码
        req.setCharacterEncoding("utf-8");
		//解决响应时的乱码
        resp.setContextType("text/html;charset=utf-8");
    }

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

2.解决tomcat控制台中文乱码

然后重启IDEA

3.解决tomcat控制台中输出中文时的乱码

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

//在servlet doGet方法中添加这两句话
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");

Maven

用于管理项目的工具。

如管理项目中所需的jar文件、打包项目等。

通过在Maven项目中加入某个jar文件所需的dependency(依赖)，让其自动从Maven仓库中下载对应jar文件。

Maven依赖官网

地址https://mvnrepository.com/，在这个网站中查询所需的jar文件的依赖

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">
    
	<!--设置下载的Jar文件的保存目录-->
	<localRepository>D:\MavenRepository\maven_jar</localRepository>

	
	<mirrors>
        <!--设置国内阿里云下载镜像-->
		<mirror>
			<id>aliyunmaven</id>
			<mirrorOf>*</mirrorOf>
			<name>aliyun</name>
			<url>https://maven.aliyun.com/repository/public</url>
		</mirror>
	</mirrors>

</settings>

使用

• 下载配置https://maven.apache.org/

• 使用IDEA自带

  在新建项目时选择Maven项目即可，在设置中更改IDEA自带的Maven配置

Tomcat

由Apecha、Sun公司及其他公司和个人共同开发的web服务器。

免费、开源、轻量级、在中小型系统中普遍使用。

是学习和开发web项目的首选服务器。

下载

tomcat官网https://tomcat.apache.org/

根据jdk和操作系统选择合适的版本

使用

下载成功后无需安装，解压到某个盘下即可。
解压后的目录

目录	说明
bin	保存tomcat中的可执行文件，如启动tomcat的startup.bat文件等
conf	保存tomcat的配置文件，如server.xml文件可以修改默认的8080端口
lib	保存tomcat运行时所需的jar文件
logs	保存tomcat运行时产生的日志文件
temp	保存tomcat运行时产生的临时
webapps	保存发布在tomcat上的应用程序
work	保存tomcat运行时产生的编译文件

启动tomcat

打开bin目录下的startup.bat文件，tomcat启动后的默认端口号为8080。
在浏览器中输入localhost:8080或127.0.0.1:8080，即可进入tomcat默认启动页面。
该页面位于ROOT目录下，名为index.jsp，localhost:8080表示进入ROOT目录下访问index文件。

部署项目到tomcat中

将项目整个目录，保存到webspps下，在bin目录中打开startup.bat文件，等待启动成功后，
在浏览器中输入"localhost:8080/自定义项目目录名"或"127.0.0.1:8080/自定义项目目录名"访问。
如果将项目放在ROOT目录下，在启动定义一个index页面，就能直接省略自定义项目名，直接通过localhost:8080访问

修改本地hosts文件，设置默认本机ip127.0.0.1的域名

新建hosts文件，不要后缀名，替换系统中默认的hosts文件，然后可以通过xxx.com代替127.0.0.1

easyexcel

使用easyexcel实现读写excel文件

新建项目

设置Maven配置

导入所需依赖

在Maven依赖官网搜索easyexcel
easyexcel使用文档https://easyexcel.opensource.alibaba.com/

选择版本

复制依赖

粘贴到项目的pom.xml文件的dependencies标签中
普通Maven项目没有dependencies标签，需要自己编辑

pom文件更新后，需要刷新Maven，让其自动下载所需依赖

要读取的excel文件

编写实体类

属性上使用**@ExcelProperty(“列名”)**注解设置要读取的excel文件表头

/*
* 员工表对应实体类
* 这里省略
* get/set
* toString()
* 全参构造
* 无参构造
* */
public class Employee {
    @ExcelProperty("编号")
    private int id;
    @ExcelProperty("姓名")
    private String name;
    @ExcelProperty("性别")
    private String sex;
    @ExcelProperty("身份证")
    private String idcard;
    @ExcelProperty("部门")
    private String dept;
    @ExcelProperty("入职时间")
    private String joinDate;
    @ExcelProperty("电话")
    private String phone;
}

读excel

//要读取的文件,必须存在
File file = new File("C:\\Users\\Administrator\\Desktop\\员工信息.xlsx");

// EasyExcel.read(要读取的文件,要读取的实体类.class,PageReadListener对象，参数为一个lambda表达式).sheet().doRead();
//PageReadListener对象需要设置泛型为要读取的实体类型，lambda表达式参数为读取到的数据集合
EasyExcel.read(file, Employee.class, new PageReadListener<Employee>((emps) -> {
    for (Employee emp : emps) {
        System.out.println(emp);
    }
})).sheet().doRead();

写excel

//要写入的文件，可以不存在
File target = new File("d:\\employee.xlsx");

// EasyExcel.write(要写入的目标文件,要写入的实体类.class).sheet("表名").doWrite(要写入的数据集合)
EasyExcel.write(target, Employee.class).sheet("员工信息").doWrite(数据集合);

如何在IDEA中创建基于Maven的Web项目

1.新建webapp模板

2.在src目录下新建文件夹，之后在此创建java文件

选择main\java

3.修改项目中web.xml版本为4.0

打开项目结构

移除默认2.3版本的web.xml文件，移除后一定要apply应用，重新添加web.xml文件，选择4.0版本

4.配置tomcat服务器

5.将项目部署在tomcat中

6.启动项目

启动tomcat

默认启动成功后会自动打开浏览器访问项目，也可以通过
"localhost:8080/项目名"访问。
这里看到的页面，是web项目中自带的index.jsp文件

web资源目录结构

webapp下如果有index文件，访问项目后会自动访问index文件，如果没有名为index的文件，就会出现404，表示index页面不存在

项目上下文路径

域名+端口+项目名 称为项目上下文路径
如localhost:8080/web01就是项目上下文路径，可以理解为项目根目录webapp目录直接通过项目上下文路径访问，无需显式写出

更新了项目中的内容后，根据需要选择重启还是重新部署

修改项目编译时的jdk版本

修改web模块的jdk版本

修改当前项目的jdk版本

Servlet

Servlet表示Server+Applet，意味运行在服务器上的程序。是一个被动运行程序，每次请求都要执行。
BS结构客户端访问服务器端的流程

编写Servlet的步骤

1.在项目中导入Servlet所需依赖

<!-- servlet所需依赖 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>

粘贴在pom.xml文件中的dependencies标签下

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

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/*
 * 编写Servlet的步骤
 * 1.导入依赖
 * 2.创建一个类，继承HttpServlet,重写doGet和doPost方法
 * 3.在web.xml中设置访问该类的url映射
 * */
public class FirstServlet extends HttpServlet {
    //普通的控制台项目，需要主动运行main方法执行程序
    //web项目中的java程序，需要被动运行，在用户通过浏览器访问某个程序的url映射时执行

    /*
     * 当浏览器发送的是get类型的请求，执行这个方法
     * */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println("get请求");
    }

    /*
     * 当浏览器发送的是post类型的请求，执行这个方法
     * */
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println("post请求");
    }
}

3.在web.xml文件下，配置Servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--xml是一个配置文件，属于一种标记语言，通过标签定义内容-->
    <!--声明Servlet-->
    <servlet>
        <!--servlet命名-->
        <servlet-name>firstServlet</servlet-name>
        <!--servlet类的全限定名(路径+文件名)-->
        <servlet-class>FirstServlet</servlet-class>
    </servlet>
    <!--定义Servlet的请求映射-->
    <servlet-mapping>
        <!--要映射的servlet名，与上方定义的servlet-name一致-->
        <servlet-name>firstServlet</servlet-name>
        <!--请求映射url，必须以/开头-->
        <!--之后通过项目上下文路径+该路径，就能访问FirstServlet类-->
        <url-pattern>/first</url-pattern>
    </servlet-mapping>
</web-app>

复制资源的相对路径

启动tomcat，访问"localhost:8080/项目路径/first"即可访问自定义servlet类中的doGet方法

JSP

Java Server Pages

使用Java开发，运行在服务器上的页面，称为JSP。

JSP页面的后缀名为.jsp

由于最初由Servlet编写页面，会在Servlet中出现大量的HTML代码，使用极不方便，

由SUN公司主导推出JSP，在HTML页面中嵌入Java代码，简化了页面的编写过程，页面也成为动态页面。

JSP实际是一个java类，具体为一个Servlet，第一次访问某个JSP页面，相当于编译运行Servlet，所以会慢一些。

访问JSP的流程：编译对应的Servlet–>运行Servlet。

JSP的生命周期同Servlet。

使用JSP时，可以导入该依赖，在JSP中方便提示

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

JSP的组成

1.HTML元素*

2.Java脚本*

<%
	java代码;
%>

3.表达式*

用于在页面中输出变量或字符串。

无需分号。

<%=变量%>

4.注释

jsp注释在访问jsp时不会在浏览器中看到

html注释在访问jsp时会再浏览器中看到

<%--注释--%>

5.指令

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

• page指令
  • 用于设置当前页面的属性
• include指令
  • 用于嵌入其他页面
• taglib指令
  • 用于导入其他标签库

6.声明

可以在这里定义方法、全局变量等

<%! 
    void fun(){}
%>

7.动作

使用标签定义一些功能。

<jsp:单词></jsp:单词> 
//包含另一张页面
<jsp:include page="路径"></jsp:include> 

路径问题

绝对路径

完整路径

相对路径

• /

  从项目根目录出发。即域名+端口号

• ./

  从当前位置出发

• …/

  退出当前目录后出发

如当前位于localhost:8080/shop/pages/index.html

在该页面中，如果使用

<img src='/xxx.jpg'>
表示访问localhost:8080/xxx.jpg

<img src='./xxx.jpg'>
表示访问localhost:8080/shop/pages/xxx.jpg

<img src='../xxx.jpg'>
表示访问localhost:8080/shop/xxx.jpg

跳转

HTML to HTML/JSP

<a href="另一个页面的路径">跳转</a>

<form action="另一个页面的路径">
    <input type="submit">
</form>

HTML to Servlet

<a href="某个servlet的URL映射">跳转</a>

<form action="某个servlet的URL映射">
    <input type="submit">
</form>

Servlet/JSP to Servlet/JSP/HTML

请求转发

request.getRequestDispatcher("目的路径").forward(request,response)

• 使用请求转发跳转到目的地后，浏览器的地址栏是最初访问的路径
• 可以在请求转发时，在request对象中保存数据，如request.getParameter()、request.setAttribute()
• 在执行查询时，通常将查询后的结果保存在request对象中后，使用请求转发跳转到页面中

重定向

response.sendRedirect("目的路径");

• 使用重定向跳转到目的地后，浏览器的地址栏是最终访问的目的地路径
• 如果在重定向时使用request对象保存数据，后续无法获取保存的内容
• 在执行增删改后使用重定向跳转到目的地，防止重复提交

跳转过程中传递参数

• 由页面发送数据到servlet或jsp，通常使用表单元素或在某个URL后使用"?参数=值"方式提交参数，获取时使用request.getParameter(“参数”)获取

  <a href="xxxx?id=11">删除</a>
  
  <form action="xxxx" >
      <input type="hidden" name="id" value="11">
  </form>
  
  
  //返回值为String
  String str=request.getParameter("id");
  

• 由servlet发送数据到页面，使用request.setAttribute(String str,Object obj)保存obj到请求对象中，命名为str，获取时使用request.getAttribute(String str)

  public class XXXServlet extends HttpServlet{
      protected void service(HttpServletRequest req,HttpServletResponse resp){
          List obj = new ArrayList();
          req.setAttribute("list",obj);
          req.getRequestDispatcher("xxx.jsp").forward(req,resp)
      }
  }
  

  <%
  	//返回值为Object类型
  	Object obj = request.getAttribute("obj");
  	List list = (List) obj;
  %>
  

Ajax

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。

任何的浏览器都支持ajax。通过原生的js使用ajax极不方便，这里使用jquery封装后的ajax使用。

使用

1.在页面中引入jquery文件

<script src="jquery文件路径"></script>

2.给某个节点绑定事件后使用ajax提交数据

<script>
	$("#btn").click(()=>{
        $.ajax({
            //访问的地址
            url:'URL地址',
            //提交的数据，以键值对的形式提交，也可以提交单个数据
            data:{
                id:123,
                op:"xxx"
            },
            //提交方式
            type:"post",
            //访问成功后的回调函数
            succuss:(res)=>{//res为访问URL地址后的返回值
                
            },
            //访问失败后的回调函数
            error:(res)=>{}
        });
    });
</script>

EL

Expression Language 表达式语言

是为了使JSP中的输出写起来更加简便，替换JSP中的<%=%>，即表达式。

主要输出保存在某个作用域中的数据。

特点

• 减少代码(获取对象、转换对象、获取对象属性)

  • 如果通过"某个作用域对象.setAttribute(String str,Object obj)"方法保存的对象，

    在JSP页面中，如果用表达式，写为<%=str>；如果使用EL，写为${str}。

    会依次从pageContext–>request–>session–>application中获取指定对象，如果一旦从某个作用域中获取到了对象，就不再判断后续作用域。

    也可以指定从某个作用域中获取对象，如${session.str}表示从session作用域中获取对象。

• 免去非空判断

  • 如果要使用的某个对象不存在，不会输出null，而是输出空字符串""

使用

1.获取保存在作用域中的对象

• 获取保存在某个作用域中的对象：${对象名}

• 从指定的作用于中获取对象

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

• 输出对象的属性

  ${对象名.属性名}   
  ${对象名["属性名"]}    
  
  要保证该属性有对应的get方法    
  

• 输出对象的方法返回值

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

举例

//在servlet中，将一个集合保存在请求对象request中
//Person有name、sex和age属性
Person p1 = new Person("a","男",20);
Person p2 = new Person("b","男",20);
Person p3 = new Person("c","女",20);
List list = new ArrayList();
list.add(p1);
list.add(p2);
list.add(p3);
req.setAttribute("list",list);

使用请求转发跳转到页面中

<!--传统JSP中的表达式-->
<%
List list = (List)request.getAttribute("list");
//需要获取、转换后才能遍历使用
%>
<table>
    <%
    for(Object obj in 集合){
        %>

    <td><%=obj.get属性()%></td>

    <%
    }
    %>
</table>


<!--使用EL和JSTL后-->
<table>
    <c:forEach items="${list}" var="p">
        <!--使用EL-->
        <td>${p.name}</td>>
        <td>${p.sex}</td>>
        <td>${p.age}</td>>
    </c:forEach>
</table>

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

如http://localhost:8080/book_shop是一个项目上下文路径。

在JSP中使用**${pageContext.request.contextPath}**获取项目上下文路径

<form action="${pageContext.request.contextPath}/book?op=xxx"></form>

<a href="${pageContext.request.contextPath}/book?op=xxx"></a>

<img src="${pageContext.request.contextPath}/pages/imgs/xxx.jpg">

<script>
	$.ajax({
        url:"${pageContext.request.contextPath}/book?op=xxx"
    });
</script>

3.在页面中获取请求中携带的参数

可以使用EL获取表单提交或地址中?后传递的数据

使用**${param.参数}**表示request.getParameter(“参数”)方法获取的数据

如

<form action="xxx.jsp">
    <input type="text" name="username">
    <input type="submit">
</form>

<a href="xxx.jsp?username=admin"></a>

在xxx.jsp中

${param.username}获取提交的数据

注意

• web.xml版本在4.0之后，在JSP中使用EL时，默认可以识别。

• 如果JSP中无法识别EL，原样输出${}符号时，在指令(<%@ %>)中加入 isELIgnored=“false” 表示不忽略EL

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

• 如果在使用EL的过程中，出现PropertyNotFoundException异常，表示未发现指定属性，原因有

  • 缺少指定属性
  • 指定属性没有对应的get方法

JSTL

Java Server Page Standarded Tag Library JSP标准标签库

可以使用JSTL中的特定标签，来替换JSP中常见的java代码，如循环判断等。减少JSP中的java代码，提高页面的可读性。

使用

• 导入jstl依赖

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

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

  <!--在当前页面中使用jstl,以c为标签前缀-->
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

这句话可以在使用循环时自动生成

• 具体使用

  • 定义变量或给变量赋值

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

  • if判断

    <c:if test="判断条件">
    	满足时执行
    </c:if>
    
    session.setAttribute("user",用户对象);
    
    <c:if test="${empty user}">
    	<span>请登录</span>
    </c:if>
    
    <c:if test="${!empty user}">
    	<span>${user.username}</span>
    </c:if>
    

  • 遍历List集合

    //如在servlet中，将查询到的集合保存在request对象中
    request.setAttribute("list",查询到的集合)
    <table>
        <!--<c:forEach items="要遍历的集合" var="遍历出的每个对象">-->
        <c:forEach items="${list}" var="obj"> 
            <tr>
                <td>${obj.属性}</td>
            </tr>
        </c:foreach>
    </table>
    

  • 遍历Map集合

    <%
        HashMap<String,String> hm = new HashMap();
        hm.put("yyds","永远单身");
        hm.put("awsl","阿伟死了");
        hm.put("u1s1","有一说一");
        application.setAttribute("hm",hm);
    %>
    <c:forEach items="${hm}" var="kv">
        <%--${键值对.key} 获取键   ${键值对.value} 获取值   --%>
        <h2>${kv.key}--${kv.value}</h2>
    </c:forEach>
    

使用JSTL和EL输出购物车中的信息

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="com.hqyj.book_shop.util.Cart" %>
<%@ page import="com.hqyj.book_shop.entity.BookInfo" %>
<%@ page import="java.util.HashMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <style>
            * {
                margin: 0;
                padding: 0;
            }

            body {
                background-color: #f5f5f5;
            }

            .main {
                width: 1240px;
                height: 628px;
                margin: 20px auto 20px;
                background-color: #fff;
            }

            table {
                float: left;
                width: 600px;
                margin-top: 50px;
                margin-left: 320px;
                border-collapse: collapse;
            }

            th, td {
                width: 120px;
                height: 20px;
                border: 1px solid skyblue;
            }
        </style>
    </head>
    <body>
        <jsp:include page="top.jsp"></jsp:include>
        <div class="main">
            <table>
                <tr>
                    <th>图书编号</th>
                    <th>图书名称</th>
                    <th>图书单价</th>
                    <th>购买数量</th>
                    <th>小计</th>
                    <th>操作</th>
                </tr>
                <c:if test="${empty cart.getCart()}">
                    <tr>
                        <td colspan="6">当前购物车中无商品</td>
                    </tr>
                </c:if>
                <c:if test="${!empty cart.getCart()}">
                    <%--定义变量表示总合--%>
                    <c:set var="sumPrice" value="0"></c:set>
                    <c:forEach items="${cart.getCart()}" var="kv">
                        <tr>
                            <td>${kv.key.bookId}</td>
                            <td>${kv.key.bookName}</td>
                            <td>${kv.key.bookPrice}</td>
                            <td>${kv.value}</td>
                            <%--el中可以使用算术运算--%>
                            <td>${kv.key.bookPrice*kv.value}</td>
                            <td>
                                <a href="${pageContext.request.contextPath}book?op=remove&bookId=${kv.key.bookId}">移除</a>
                            </td>
                            <%--每次循环将小计累加到总价中--%>
                            <c:set var="sumPrice" value="${sumPrice + kv.key.bookPrice * kv.value}"></c:set>
                        </tr>
                    </c:forEach>
                    <tr>
                        <td colspan="4">总计</td>
                        <td>${sumPrice}</td>
                        <td><a href="${pageContext.request.contextPath}/book?op=clear">清空购物车</a></td>
                    </tr>
                </c:if>
            </table>
        </div>
    </body>
</html>

JSP内置对象

在JSP中，可以不用定义，就能直接使用的对象，称为内置对象。

一共有9个内置对象

“rrppsoace”

• pageContext

  作用域对象，当前页面作用域。

• request

  作用域对象，请求作用域。

• session

  作用域对象，会话作用域。

• application

  作用域对象，项目作用域。

• response

  响应对象

• out

  输出对象，相当于Servlet中的response.getWriter()方法的返回值对象

• page

  表示当前页面自身对象，相当于servlet中的this

• config

  配置对象，获取servlet的配置信息

• exception

  异常对象，只能使用在有isErrorPage="true"声明的jsp页面中，用于获取异常对象

Session和Cookie

session

session称为会话，是一个作用域，使用session.setAttribute()保存数据，使用session.getAttribute()获取数据。

默认session会话有效期为30分钟，可以更改，超时或关闭浏览器，session失效。

保存在session中的数据，可以在同一个站点下的不同页面中共享。

session共享数据的原理

• 访问任意JSP页面时，默认都会创建一个JSESSIONID(可以取消自动创建)，是一段session编号，保存在一个cookie文件中

  <%--所有jsp页面中,默认开启了session--%>
  <%@ page session="true"%>
  
  <%--让页面默认不使用session--%>
  <%@ page session="false"%>
  

  自动生成的cookie文件信息，可以看出，随着浏览器关闭，session到期
  

• 再次访问该页面时，会查询JSESSIONID是否存在，如果存在，直接使用，如果不存在，重新创建新的JSESSIONID

• 保存该JSESSIONID的cookie文件，有效期为浏览会话结束。所以关闭浏览器，session失效

session对象常用方法

常用方法	说明
getAttribute(String str)	获取session中保存的数据，返回值为Object类型
setAttribute(String str,Object obj)	将obj保存在session中，命名为str
removeAttribute(String str)	移除保存在session中的对象str
invalidate()	销毁session
getId()	获取JSESSIONID
getMaxInactiveInterval()	获取session有效时长，单位为秒，默认为1800
setMaxInactiveInterval(int second)	设置session有效时长，单位为秒
getCreationTime()	获取session创建时间，返回值为时间毫秒
getLastAccessedTime()	获取最后一次访问session的时间，返回值为时间毫秒

设置项目全局session有效时长

在web.xml文件中设置，单位为分钟

<!--设置项目中所有session的有效时长，单位分钟-->
<session-config>
    <session-timeout>5</session-timeout>
</session-config>

cookie

cookie是一个用于保存数据的对象，实际是一个保存在客户本地的文件。关闭浏览器，cookie依然存在。手动清理或自动超时清理后，数据随之消失。

cookie通常用于更久地保存数据，即便关闭浏览器，也能一直存在。如登录信息、购物车信息等

cookie中保存的数据有上限(4kb)，

cookie在浏览器中保存的数量也有上限(30~300根据浏览器不同略有变化)。

创建cookie

//Cookie(String name,String value);
Cookie ck = new Cookie("str","hello");
//设置有效时长,单位为秒，如果不设置，关闭浏览器，cookie失效
ck.setMaxAge(7*24*3600);//7天

保存cookie

response.addCookie(ck);

遍历cookie

Cookie[] cks = request.getCookies();
for(Cookie ck : cks){
    ck.getName();//获取name
    ck.getValue();//获取value
}

session和cookie的对比

• session中保存的数据可以是任意类型，没有大小限制；cookie中保存的是键值对，单个值大小上限为4kb

• session中保存的数据存在服务器中，cookie中保存的数据存在浏览器中。

• session到期或随着浏览器关闭而失效，cookie如果设置了有效时长，即使关闭浏览器也会存在，在到期或手动清理时失效

过滤器Filter

是一个特殊的servlet

使用

1.新建一个类，继承HttpFilter

2.重写doFilter()方法，设置过滤条件

package com.hqyj.book_shop.filter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/*
 * 自定义过滤器
 * 1.创建一个类，继承HttpFilter
 * 2.重写受保护的doFilter方法
 * 3.配置过滤器
 * */
public class MyFilter extends HttpFilter {

    @Override
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        //获取当前访问的uri(地址)
        String uri = req.getRequestURI();
        System.out.println(uri + "访问过滤器");
        //如果登录成功后，session会保存customer。
        //过滤器中判断当前session中是否存在customer
        if (req.getSession().getAttribute("customer") != null) {
            chain.doFilter(req, res);
            return;
        }
        //如果session中没有customer，只能放行登录、注册页及其相关静态资源和customer模块
        if (uri.contains("html")  || uri.contains("jquery")|| uri.contains("customer")) {
            chain.doFilter(req, res);
        }else{
            //否则跳转登录页
            res.sendRedirect("http://localhost:8080/book_shop/pages/login.html");
        }
    }
}

3.配置过滤器，过滤一切请求

<!--声明一个过滤器-->
<filter>
    <!--过滤器名，无限制-->
    <filter-name>myFilter</filter-name>
    <!--过滤器类全限定名-->
    <filter-class>com.hqyj.book_shop.filter.MyFilter</filter-class>
</filter>
<!--配置过滤器映射-->
<filter-mapping>
    <!--过滤器名，与上方对应-->
    <filter-name>myFilter</filter-name>
    <!--过滤一切请求-->
    <url-pattern>/*</url-pattern>
</filter-mapping>