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

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

由 喜夏-厌秋 提交于 2020-10-01 13:52:31
目录：请求转发与重定向&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

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

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

获取来自index的请求数据:
<%
    String name = request.getParameter("username");
    String pwd = request.getParameter("password");
    out.println(name+"---"+pwd);
%>
<hr>
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（核心）标签，主要包含以下标签：

  • <c:out>
  • <c:set>
  • <c:forEach>
  • <c:if>
  • <c:choose>
  • <c:when>
  • <c:otherwise>
  • <c:forTokens>

基于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>encodingFilter</filter-name>
    <filter-class>com.softeem.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>

非法访问过滤

/**
* 拦截所有对/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(">", "&gt;")
//				.replaceAll("<", "&lt;");
		
		//通过工具类对字符串不解析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.DataListener</listener-class>
</listener>
标签
java
Java EE
jstl
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!