javaweb--过滤器（filter||监听器（listener）

Filter：

import javax.servlet.*;
implements Filter {}

@WebFilter(urlPatterns = {"/*"})

 

拦截路径

1. 精确拦截/user-servlet

2. 通配符/*表示拦截所有资源/user/*拦截/user这个路径下的所有资源

3. 通配符*.jsp表示拦截所有以.jsp结尾的资源

拦截响应

System.out.println("User拦截器--之前");
// 在chain.doFilter(request, response);上方的代码会在请求到达被访问资源前执行
// 一般会在该方法上方对request进行处理
// 对请求进行放行
chain.doFilter(request, response);
// 在chain.doFilter(request, response);下方的代码会在响应到达浏览器之前执行
// 一般会在该方法下方对response进行处理
System.out.println("User拦截器--之后");

过滤器设置编码：

package com.gton.curd.fileter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * @program: javaweb-demo
 * @description:过滤器
 * @author: GuoTong
 * @create: 2020-09-17 14:07
 **/
//所有的字符编码都需要统一，所以这里用全部
@WebFilter(value = "/*",initParams = {
        @WebInitParam(name="code",value = "UTF-8")
})
public class TestFilter implements Filter {

    /*
    * 拦截路径
    1. 精确拦截`/user-servlet`
    2. 通配符`/*`表示拦截所有资源`/user/*`拦截`/user`这个路径下的所有资源
    3. 通配符`*.jsp`表示拦截所有以`.jsp`结尾的资源*/

    private String code;   //保存字符编码的类型

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //读取web.xml||注解 中Filter配置的初始化參数
        code = filterConfig.getInitParameter("code");
    }

    /*实现过滤的方法：
    *servletRequest：请求
    * servletResponse：响应
    * filterChain： 根据条件放行*/
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 处理请求乱码
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletRequest myRequest = new MyRequest(httpServletRequest);

        // 处理响应乱码
        response.setContentType("text/html;charset=utf-8");

        chain.doFilter(myRequest, response);
    }



    @Override
    public void destroy() {

    }
}
// 自定义request对象
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    private boolean hasEncode;

    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }

    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }

        return super.getParameterMap();
    }

    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }

    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }

}

 

 

 

 XML配置：xml配置有先后顺序吗，mapping：从上之下

<filter>
    <description>Filter 示例</description>
    <display-name>TestFilter</display-name>
    <filter-name>TestFilter</filter-name>
    <filter-class>com.neuedu.filter.TestFilter</filter-class>
    <async-supported>false</async-supported>
    <init-param>
        <param-name>CharacterEncoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>TestFilter</filter-name>
    <url-pattern>*.jsp</url-pattern>
    <servlet-name>TestServlet</servlet-name>
    <dispatcher>REQUEST</dispatcher>
</filter-mapping>

 

 

监听器

JavaWeb中的监听器可以监听容器中发生的常见事件，如果实现了这些监听器，开发者就可以根据这些被监听的事件编写业务逻辑，这些用于处理事件监听的代码对系统原有的业务没有侵入性。

监听器可以在不修改原有代码的基础上扩展新功能

 监听机制

事件：发生某一件事情，通常是一些动作

事件源：事件发生的那个组件

事件注册：将事件发生时想要处理的业务逻辑和事件源进行绑定

监听器(回调函数)：当事件发生时去执行的业务逻辑

在进行监听器的编写时

1 明确监听的事件

2 明确该事件的事件源

3 根据以上两者选择需要实现的监听器接口

 

 

package com.gton.curd.listnener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 * @program: javaweb-demo
 * @description:
 * @author: GuoTong
 * @create: 2020-09-17 16:57
 **/
@WebListener
public class TestListener implements ServletContextListener {

    /**
     * 创建后的回调函数：contextInitialized
     * @param sce
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        //回调函数的参数是事件对象，通过该对象可以获取到被监听的对象。。
        //获取当前监听的对象：  sce.getXXXX()
        System.out.println("Servlet 容器已经初始化完毕");
    }

    /**
     * servlet容器销毁过后的回调函数：contextDestroyed
     * @param sce
     */

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("容器已经销毁。。。");
    }
    /*
    * 1.监听事件
    * 2.选择实现接口
    * 3.实现接口度方法
    * */
}