知识梳理：请求转发与重定向&JSP&EL表达式&JSTL&基于Servlet3.0 的文件上传和下载&XSS过滤&过滤器&监听器

目录：请求转发与重定向&JSP&EL表达式&JSTL&XSS过滤&基于Servlet3.0 的文件上传和下载&过滤器&监听器

请求转发与重定向

请求转发（forward）

请求转发是由HttpServletReqeust发起的跳转，跳转的同时可以将请求范围之内的信息传递到下一个Servlet中,请求转发是服务端跳转，请求转发对于客户端来说只发送了一次请求，并且地址栏只会显示第一次请求的地址。

request.setAttribute(key,value);
request.getRequestDispartcher("目标资源").forward(request,response);

注意：

对于请求转发来说，目标资源一般为servlet或jsp；不会使用静态页面

重定向（redirect）

​ 重定向是由HttpServletResponse发起的跳转，重定向属于客户端条跳转，因此存储在request范围之类数据无法传递到下一个servlet中，重定向发送了多次请求，并且请求均为客户端发起，地址栏中显示是最后一次请求的地址

response.sendRedirect("目标资源")

关于请求转发和重定向的使用场景：

如果跳转到下一个servlet时需要传递数据则优先考虑使用请求转发（forward），反之则使用重定向(redirect)

请求转发是服务端跳转，重定向是客户端跳转

java代码块

jsp中一段可执行的Java代码必须包含在一对<% 这个里面编写Java代码 %>

<%
    for (int i = 1; i < 10 ; i++) {
        for (int j = 1; j <= i ; j++) {
            System.out.print(j+"*"+i+"="+(i*j)+" ");
        }
        System.out.println();
    }
%>

输出

jsp中对于需要在输出到网页中的内容使用<%=输入的内容 %>

<%
	String s = "hello jsp";
%>
<%=s %>

输出的变量之后不需要添加“;”结尾

通过输出的内容为一个变量

JSP运行原理

1. 服务器启动后，当前请求第一次到达指定的jsp
2. 服务会使用jsp引擎对jsp进行编译操作，将jsp页面编译为一个Java类（Servlet）
3. 通过Java编译器对servlet编译
4. 然后运行编译之后的字节码文件，将需要传输到客户端的数据以流的形式输出到客户端

JSP运行的时候web容器会将其转换为一个Servlet，因此JSP本质就是一个Servlet;通过到web容器(服务器)的工作目录(work)中即可找到原理。

内置对象

内置对象，也称之为内建对象，即无需创建可直接使用的对象，在jsp中主要包含九大内置对象：

1. request 即 HttpServletRequest
2. response 即 HttpServletResponse
3. session 即 HttpSession
4. application 即 ServletContext
5. page 即 this
6. pageContext servlet中不存在该对象，仅仅在jsp才存在，就是PageContext对象
7. config 即 ServletConfig
8. out 即 PrintWriter
9. exception

四大作用域

servlet（jsp）中，缓存数据的对象主要包含以下4个，并且这四个对象对于数据的存储作用域存在区别：

1. PageContext pageContext

   存储在pageContext范围的数据只针对当前页面生效

2. HttpServletRequest request

   存储在request范围内的数据针对一次请求生效（请求转发）

3. HttpSession session

   存储在session范围内的数据针对整个会话生效(浏览器不关闭，session未到有效期)

4. ServletContext application

   存储在application范围的数据，针对所有访问的客户端都生效，只要服务器不关闭

以上四个对象都包含以下方法：

• setAttribute 向当前作用域存储数据，数据以键值对结构存储(类似Map)
• getAttribute 根据键名获取存储的值，值是Object类型

三大指令

jsp中包含三大基本指令

• <%@ page %>

  page指令用于声明当前页面是jsp页面，并且可以进行基础配置，比如编码，el表达式开启或关闭等

• <%@ include %>

  静态包含，可以将其他的jsp页面包含到当前页面中:

  <%@ include file="reg.jsp" %>
  

• <%@ taglib %>

  标签库指令，用于导入JSTL标签库相关的信息

  <%@ taglib prefix="c" url="" %>
  

EL表达式与JSTL

EL表达式

EL（Expression Language）表达式语言，允许在jsp页面中使用${}表达形式获取存储在各个作用域的数据信息，获取请求参数，执行一些运算操作；EL表达式支持以下相关的操作：

1. 基本的运算操作

   1. 算数运算
   2. 比较运算
   3. 布尔逻辑运算

2. 对象操作（调用对象中的属性）

3. 获取请求参数

4. 获取存储在作用域的数据

   使用EL表达式获取不同作用域中的数据时，按照范围从小到大依次获取：

   pageContext>request>session>application

默认按范围从小到大获取:${stu.sname}
获取session范围的数据：${sessionScope.stu}
获取request范围的数据：${requestScope.stu}
获取page范围的数据：${pageScope.stu}
获取application范围的数据：${applicationScope.stu}

提交数据到result.jsp中
EL基本运算
相加:${3 + 1}
相除：${5 div 3}-----${5/3}
取余：${10 mod 3}---${10 % 3}
大于：${10 > 5}---${10 gt 5}
great than
小于：${10 < 5}---${10 lt 5}
little than
大于等于：${10 >= 10} ----${10 ge 10}
 great equals
不等于：${5 != 10} ----  ${5 ne 10}
not equals
等于：${10 == 20}---${10 eq 20}
 equals

获取来自index的请求数据:
<%
    String name = request.getParameter("username");
    String pwd = request.getParameter("password");
    out.println(name+"---"+pwd);
%>

el表达式获取请求参数数据：
${param.username}/${param.password}

JSTL

JSTL(JavaServer Pages Standard Tag Library)，jsp的标准标签库，由一系列标签构成的用于便捷操作服务端数据的标签的写法，语法类似html，使用标签库可以彻底抛弃<% %>、<%= %>；jstl由以下标签构成:

• c标签
• fmt标签
• sql标签
• xml标签
• fn标签

JSTL使用方式

1. 使用jstl必须先引入两个核心的标签库文件:

   1. standard.jar
   2. jstl.jar

2. 到jsp中声明需要使用的标签库

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

C标签

c标签又称之为core（核心）标签，主要包含以下标签：

基于Servlet3.0 的文件上传和下载

前言

在Servlet2.5中，我们要实现文件上传功能时，一般都需要借助第三方开源组件，例如Apache的commons-fileupload组件，在Servlet3.0中提供了对文件上传的原生支持，我们不需要借助任何第三方上传组件，直接使用Servlet3.0提供的API就能够实现文件上传功能了。

文件域和表单的enctype属性

一、关于HTML 标签的 enctype 属性

application/x-www-form-urlencoded：在发送前编码所有字符（默认）

multipart/form-data： 不对字符编码，或在使用包含文件上传控件的表单时，必须使用该值。

text/plain：空格转换为 “+” 加号，但不对特殊字符编码。

二、enctype：规定了form表单在发送到服务器时候编码方式，有如下的三个值。

1、application/x-www-form-urlencoded。默认的编码方式。但是在用文本的传输和MP3等大型文件的时候，使用这种编码就显得 效率低下。

2、multipart/form-data 。 指定传输数据为二进制类型，比如图片、mp3、文件。

3、text/plain。纯文体的传输。空格转换为 “+” 加号，但不对特殊字符编码。

简单的说，在我们要进行文件上传时应该设置表单组件的enctype属性为multipart/form-data,已二进制的方式提交表单，从而可以提交上传各种类型的文件

    <fieldset>
      <legend>上传单个文件legend>
      <form action="upload" method="post" enctype="multipart/form-data">
        上传文件： <input type="file" name="myFile"><br>
        <input type="submit" value="上传">
      form>
    fieldset>
  <fieldset>
      <legend>上传多个文件legend>
    <form action="upload" method="post" enctype="multipart/form-data">
      上传文件： <input type="file" name="myFile"><br>
      上传文件： <input type="file" name="myFile"><br>
      <input type="submit" value="上传">
    form>
  fieldset>

@MultipartConfig注解和Part对象

Servlet3.0 提供了@MultipartConfig注解，让我们的servlet能够接受来自客户端提交的二进制数据，通过request对象的getPart/getParts方法即可从请求中提取上传的文件信息

@WebServlet("/upload")
@MultipartConfig
public class UploadServlet extends HttpServlet {
     
        @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     
        Collection<Part> partList = req.getParts(); //获取当前表单中提交的所有文件，返回一个集合
        Part part = req.getPart("name"); //根据文件域所对应的name提取单个文件
    }
}

当获取了part对象后，可以利用part提供的api进一步获取文件的相关信息

        	Part part = req.getPart("myFile");
            String header = part.getHeader("content-disposition");//获取mime头信息
            String fileName = part.getSubmittedFileName(); //获取文件名
            long size = part.getSize(); //获取文件大小
            String type = part.getContentType(); //获取文件类型
            System.out.println(fileName);
            System.out.println(size);
            System.out.println(type);

针对之前的HTML案例，我们可以编写一个用于接收一个或多个文件的上传的servlet

package com.softeem.upload;

import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Part;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.UUID;

@WebServlet("/upload")
@MultipartConfig
public class UploadServlet extends HttpServlet {
     
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     
        Collection<Part> partList = req.getParts();
        req.setCharacterEncoding("utf-8");
        if(partList.size()==1){
     
            Part part = req.getPart("myFile");
            String header = part.getHeader("content-disposition");
            String fileName = part.getSubmittedFileName(); //获取文件名
            long size = part.getSize(); //获取文件大小
            String type = part.getContentType(); //获取文件类型
            System.out.println(fileName);
            System.out.println(size);
            System.out.println(type);
            String path = req.getServletContext().getRealPath("/upload")+File.separator+UUID.randomUUID()+fileName;
            part.write(path);
        }else{
     
            for (Part part : partList) {
     
                String fileName = part.getSubmittedFileName();
                String path = req.getServletContext().getRealPath("/upload") + File.separator + UUID.randomUUID() + fileName;
                part.write(path);
                req.getRequestDispatcher("/getFiles").forward(req,resp);
            }
        }
    }
}

知识点：

request.getServletContext(): 获取当前上下文/容器对象

ServletContext.getRealPath(“path”): 返回上下文目录中某个文件/文件夹的完整路径

UUID.randomUUID(): 根据UUID获取一个32位随机字符

文件下载

要实现下载非常简单，只需要向浏览器声明content-disposition标明attachment即可，如果不标识这个信息，浏览器会直接打开该文件（如果浏览器可以打开，如图片，文档等），如果打不开也会激活下载

大致思路就是，我们通过一个输入流，读取想要让客户端下载的文件字节，然后通过输出流写到客户端即可，基本的IO操作

package com.softeem.upload;


import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

@WebServlet("/down")
public class DownLoadServlet extends HttpServlet {
     
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     
        req.setCharacterEncoding("utf-8");
//        String fileName = new String(req.getParameter("fileName").getBytes("iso-8859-1"),"utf-8");
        String fileName =req.getParameter("fileName");
        System.out.println(fileName);
        String path = req.getServletContext().getRealPath("/upload");
        File f= new File(path+File.separator+fileName);
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("Content-Disposition", "attachment;fileName=" + fileName);
        System.out.println(f);
        try{
     
            InputStream input = new FileInputStream(f);
            ServletOutputStream out = resp.getOutputStream();
            byte[] buffer = new byte[1024];
            int len =0;
            while((len=input.read(buffer))!=-1){
     
                out.write(buffer);
            }
            input.close();
            out.close();
        }catch (Exception ex){
     
            ex.printStackTrace();
        }
    }
}

BaseServlet响应处理

/**
 * 中央控制器：统一控制客户端的请求跳转目标
 * @Author mrchai 2020/8/27 8:58
 */
public class BaseServlet extends HttpServlet {
     

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     
        //获取需要执行的方法名称
        String methodName = req.getParameter("method");
        try {
     
            //根据方法名获取需要执行的方法对象
            Method method = this.getClass().getMethod(methodName,HttpServletRequest.class,HttpServletResponse.class);
            //执行servlet目标方法，并且获取方法的返回值
            Object obj = method.invoke(this,req,resp);
            //当返回值不为null时才处理跳转
            if(Objects.nonNull(obj)){
     
                //将返回值转换为String类型
                String target = obj.toString();
                if(target.startsWith("redirect:")){
     
                    //重定向
                    target = target.substring("redirect:".length());
                    resp.sendRedirect(target);
                }else{
     
                    //请求转发
                    req.getRequestDispatcher(target).forward(req,resp);
                }
            }
        } catch (NoSuchMethodException e) {
     
            e.printStackTrace();
        } catch (IllegalAccessException e) {
     
            e.printStackTrace();
        } catch (InvocationTargetException e) {
     
            e.printStackTrace();
        }
    }
}

具体使用:

@WebServlet("/user")
public class UserServlet extends BaseServlet{
     

    public String login(HttpServletRequest request, HttpServletResponse response){
     
        System.out.println("执行登录！");
        //重定向
        return "redirect:success.jsp";
    }

    public String reg(HttpServletRequest request, HttpServletResponse response){
     
        System.out.println("执行注册");
        //请求转发
//        return "redirect:user?method=userList";
        return userList(request, response);
    }

    public String userList(HttpServletRequest request,HttpServletResponse response){
     
        System.out.println("查询用户列表");
        return "redirect:list.jsp";
    }

    public void modifyPwd(HttpServletRequest request, HttpServletResponse response){
     

    }

    public void modifyStatus(HttpServletRequest request, HttpServletResponse response){
     

    }

}

Filter

filter,过滤器，顾名思义，即在执行相关请求时，通过过滤器可以将请求拦截，并作出处理，再对请求放行，从而达到对请求拦截能力；比如，客户端提交数据时的敏感词过滤，编码的统一过滤，登录过滤等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZsFoXhR-1598790718950)(D:\带班资料\2020\j2003\线下\part5-javaweb\20200827\笔记\assets\1598515027592.png)]

Filter创建与使用

1. 创建类实现Filter接口
2. 实现doFilter方法
3. 配置Filter
   1. 基于注解配置
   2. 通过web.xml配置

常见过滤器

编码过滤

public class EncodingFilter implements Filter {
     

    String encoding;

    @Override
    public void init(FilterConfig config) throws ServletException {
     
       //获取请求参数的编码
        encoding = config.getInitParameter("encoding");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
     
        //如果请求参数未传递编码则默认使用ut-8
        encoding = encoding == null ? "utf-8" : encoding;
        //设置请求响应编码
        req.setCharacterEncoding(encoding);
        resp.setCharacterEncoding(encoding);
        chain.doFilter(req,resp);
    }

}

配置web.xml

<filter>
    <filter-name>encodingFilterfilter-name>
    <filter-class>com.softeem.filter.EncodingFilterfilter-class>
    <init-param>
        <param-name>encodingparam-name>
        <param-value>utf-8param-value>
    init-param>
filter>
<filter-mapping>
    <filter-name>encodingFilterfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

非法访问过滤

/**
* 拦截所有对/amdin/*下的资源
*/
@WebFilter("/admin/*")
public class LoginFilter implements Filter {
     
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
     
        //将ServletRequest转换为HttpServletRequest
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //从session中获取用户信息
        Object obj = request.getSession().getAttribute("user");
        if(obj != null){
     
            //说明用户已登录，放行
            chain.doFilter(request,response);
        }else{
     
            //强行跳转到登录页面
            //            response.sendRedirect("/login.jsp");
            request.setAttribute("msg","亲，登录后再试!");
            request.getRequestDispatcher("/login.jsp").forward(request,response);
        }
    }
}

XSS过滤

XSS（Cross Site Scripting）,跨站脚本攻击，是一种常见的网络攻击方式，通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法(比如表单提交时输入脚本代码或者网页代码)注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript，但实际上也可以包括Java、 VBScript、ActiveX、 Flash 或者甚至是普通的HTML。攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和cookie等各种内容。

​ 为防止以上攻击方式的发生，通常可以通过过滤器对请求内容进行过滤并处理，具体操作如下:

编写request包装器(XssRequest.java)

/**
 * 请求包装器
 * @author mrchai
 */
public class XssRequest extends HttpServletRequestWrapper{
     

	public XssRequest(HttpServletRequest request) {
     
		super(request);
	}

	@Override
	public String getParameter(String name) {
     
		String value = super.getParameter(name);
		return handler(value);
	}

	@Override
	public String[] getParameterValues(String name) {
     
		//根据指定name属性获取所有的value值集合(未经处理的数据)
		String[] values = super.getParameterValues(name);
		if(Objects.isNull(values)){
     
			return null;
		}
		//创建新数组存储处理过之后的数据
		String[] newValues = new String[values.length];
		//循环遍历未经处理的数据并进行处理后存入新数组中
		for (int i = 0; i < values.length; i++) {
     
			newValues[i] = handler(values[i]);
		}
		return newValues;
	}
	
	/**核心转换方法，实现将特殊字符替换为安全的文本*/
	public String handler(String value){
     
		if(Objects.isNull(value)){
     
			return null;
		}
        
//		原理为替换原本请求内容中的特殊字符		
//		value = value.replaceAll(">", ">")
//				.replaceAll("<", "<");
		
		//通过工具类对字符串不解析html代码（需导入commons-lang和commons-text包）
		value = StringEscapeUtils.escapeHtml4(value);
		return value;
	}
}

编写过滤器类(XssFilter.java)

@WebFilter("/*")
public class XssFilter implements Filter{
     

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
        throws IOException, ServletException {
     
        System.out.println("xss过滤");
        //将ServletRequest强制转换为HttpServletRequest
        HttpServletRequest request = (HttpServletRequest)req;
        //执行过滤器链（放行请求到下一个过滤器）
        chain.doFilter(new XssRequest(request), resp); 
    }

}

过滤器常见面试题

1. 过滤的实现原理：过滤器基于回调机制实现
2. 过滤器（Filter）和拦截器（Interceptor）的区别
   1. 拦截器基于反射和代理(proxy)模式实现
   2. 过滤器只在请求到达目标之前过滤处理
   3. 拦截器会在请求到达之前，以及拦截之后环绕处理

Listener

​ Listener是Servlet中的一个重要组件，主要用于监听request,session,application三大作用域状态变化，比如session的产生，request中元素的新增，application的启动与销毁等。监听器不需要手动调用，只要有满足条件的事件产生，则自动执行。

servlet中的监听器主要分为以下三大类：

1. ServletRequest监听
   1. ServletRequestAttributeListener----->request中属性的产生，移除，替换
   2. ServletRequestListener—>监听request对象的产生与销毁
2. HttpSession监听
   1. HttpSessionAttributeListener----->session中属性的产生，移除，替换
   2. HttpSessionListener—>监听session的产生和销毁
3. ServletContext监听
   1. ServletContextAttributeListener----->application中属性的产生，移除，替换
   2. ServletContextListener---->监听整个应用的初始化与销毁

监听器创建语法

1. 创建普通类实现对应的监听器接口
2. 实现接口中的方法
3. 配置监听器
   1. 基于注解的配置
   2. 基于xml配置

@WebListener
public class OnlineListener implements HttpSessionListener {
     

    private static int counter;

    @Override
    public void sessionCreated(HttpSessionEvent se) {
     
        //session被创建时执行
        System.out.println("session创建-->"+se.getSession().getId());
        counter++;
        //获取Servlet上下文（application）
        ServletContext application = se.getSession().getServletContext();
        application.setAttribute("counter",counter);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
     
        //session被销毁时执行
        System.out.println("session销毁==>"+se.getSession().getId());
        counter--;
        ServletContext application = se.getSession().getServletContext();
        application.setAttribute("counter",counter);
    }
}

servlet3.0以下的监听器配置需要通过web.xml配置;

<listener>
    <listener-class>com.softeem.listener.DataListenerlistener-class>
listener>