1

http://localhost:8080/login

1
2
3
4
5
6
7
8
9

浏览器 --> HTTP 请求 --> Tomcat (Connector)
                 ↓
            Servlet 容器 (Container)
                 ↓
         找到对应的 Servlet 实例
                 ↓
        调用 service() → doGet() / doPost()
                 ↓
            生成 Http 响应返回给浏览器

1

“创建→初始化→处理请求→销毁→回收”

1
2
3
4
5

Tomcat启动 → 解析web.xml/注解 → 加载Servlet类 → new Servlet实例 → init(config) → 等待请求
                                                                 ↓
每接收1个请求 → 分配线程 → 调用service(req, resp) → 处理并响应
                                                                 ↓
Tomcat关闭/应用卸载 → 调用destroy() → 释放资源 → JVM GC回收实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

@WebServlet(urlPatterns = "/hello", loadOnStartup = 1) // 启动时加载
public class HelloServlet extends HttpServlet {
    // 1. 初始化：仅执行1次
    @Override
    public void init() throws ServletException {
        System.out.println("1. HelloServlet 初始化完成（加载配置、创建资源）");
    }

    // 2. 请求处理：每次请求执行1次（由service()分发到doGet()，此处简化）
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        System.out.println("2. 处理 /hello 请求");
        resp.getWriter().println("Hello, Servlet!");
    }

    // 3. 销毁：仅执行1次
    @Override
    public void destroy() {
        System.out.println("3. HelloServlet 销毁（释放资源）");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Tomcat启动时（触发init()）
1. HelloServlet 初始化完成（加载配置、创建资源）

# 浏览器第1次访问 http://localhost:8080/hello（触发doGet()）
2. 处理 /hello 请求

# 浏览器第2次访问 http://localhost:8080/hello（再次触发doGet()）
2. 处理 /hello 请求

# Tomcat关闭时（触发destroy()）
3. HelloServlet 销毁（释放资源）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class UnsafeLoginServlet extends HttpServlet {
    // 错误：共享可变成员变量
    private int loginCounter = 0;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // 非原子操作（读→改→写），并发时数据不一致
        loginCounter++; 
        resp.getWriter().println("登录次数：" + loginCounter);
    }
}

1
2
3
4
5
6
7
8

private AtomicInteger loginCounter = new AtomicInteger(0);

@Override
protected void doPost(...) {
    // 原子操作，线程安全
    int count = loginCounter.incrementAndGet();
    resp.getWriter().println("登录次数：" + count);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

private int loginCounter = 0;

@Override
protected void doPost(...) {
    // 锁定Servlet实例，避免并发修改
    synchronized (this) {
        loginCounter++;
    }
    resp.getWriter().println("登录次数：" + loginCounter);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 每个线程初始值为0
private ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 0);

@Override
protected void doPost(...) {
    int count = threadLocalCounter.get();
    count++;
    threadLocalCounter.set(count);
    resp.getWriter().println("当前线程登录次数：" + count);
    // 必须移除，避免线程池复用导致内存泄漏
    threadLocalCounter.remove();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

import javax.servlet.*;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;

// 配置：访问路径、启动时加载、局部参数
@WebServlet(
        urlPatterns = "/login",
        loadOnStartup = 2, // 依赖DBInitServlet（loadOnStartup=1），后加载
        initParams = {
                @WebInitParam(name = "encoding", value = "UTF-8"), // 局部参数：编码
                @WebInitParam(name = "maxTry", value = "3") // 局部参数：最大登录尝试次数
        }
)
public class LoginServlet extends HttpServlet {
    // 1. 初始化资源：数据库配置（从ServletContext获取全局配置）
    private Properties dbConfig;
    // 2. 线程安全计数器：记录总登录次数（原子类）
    private AtomicInteger totalLoginCount = new AtomicInteger(0);
    // 3. 局部参数：最大登录尝试次数（从ServletConfig获取）
    private int maxTry;

    /**
     * 初始化：加载资源，仅执行1次
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        try {
            // （1）获取ServletContext（全局配置），加载数据库配置文件
            ServletContext context = getServletContext();
            dbConfig = new Properties();
            // 读取WEB-INF/classes下的db.properties（应用级资源）
            dbConfig.load(context.getResourceAsStream("/WEB-INF/classes/db.properties"));

            // （2）获取ServletConfig（局部配置），初始化最大尝试次数
            maxTry = Integer.parseInt(config.getInitParameter("maxTry"));

            System.out.println("LoginServlet初始化完成：dbUrl=" + dbConfig.getProperty("db.url") + ", maxTry=" + maxTry);
        } catch (IOException e) {
            throw new ServletException("初始化失败：加载配置文件出错", e);
        }
    }

    /**
     * 处理登录请求：每次请求执行1次
     */
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // （1）设置编码（使用局部参数）
        String encoding = getServletConfig().getInitParameter("encoding");
        req.setCharacterEncoding(encoding);
        resp.setContentType("text/html;charset=" + encoding);
        PrintWriter out = resp.getWriter();

        // （2）获取请求参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        // （3）模拟数据库验证（从全局配置获取管理员账号）
        String adminUser = dbConfig.getProperty("admin.username");
        String adminPwd = dbConfig.getProperty("admin.password");
        boolean loginSuccess = adminUser.equals(username) && adminPwd.equals(password);

        // （4）线程安全计数：总登录次数+1
        int currentTotal = totalLoginCount.incrementAndGet();

        // （5）响应结果
        out.println("<h1>" + (loginSuccess ? "登录成功！" : "用户名/密码错误（最多尝试" + maxTry + "次）") + "</h1>");
        out.println("<p>当前系统总登录尝试次数：" + currentTotal + "</p>");
        out.close();
    }

    /**
     * 销毁：释放资源，仅执行1次
     */
    @Override
    public void destroy() {
        // 清空配置资源，避免内存泄漏
        dbConfig.clear();
        System.out.println("LoginServlet销毁：释放数据库配置资源，总登录尝试次数=" + totalLoginCount.get());
        super.destroy();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public interface HttpServletRequest extends ServletRequest {
    // 1. 请求行信息
    String getMethod(); // 获取请求方法（GET/POST等）
    String getRequestURI(); // 获取请求路径（如/context/login）
    String getProtocol(); // 获取协议版本（如HTTP/1.1）
    
    // 2. 请求头信息
    String getHeader(String name); // 获取指定头字段（如User-Agent）
    Enumeration<String> getHeaders(String name); // 获取多值头字段
    
    // 3. 请求参数（QueryString或Form表单数据）
    String getParameter(String name); // 获取参数值
    Map<String, String[]> getParameterMap(); // 获取所有参数的键值对
    
    // 4. 请求体（原始字节流）
    ServletInputStream getInputStream() throws IOException;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 源Servlet（ForwardServlet）
@WebServlet("/forward")
public class ForwardServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置共享属性
        req.setAttribute("user", "admin");
        // 转发到目标Servlet
        RequestDispatcher dispatcher = req.getRequestDispatcher("/target");
        dispatcher.forward(req, resp); // 共享同一个request
    }
}

// 目标Servlet（TargetServlet）
@WebServlet("/target")
public class TargetServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // 获取共享属性
        String user = (String) req.getAttribute("user"); // 输出"admin"
        resp.getWriter().println("User: " + user);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@WebFilter("/*")
public class GzipFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 包装响应对象，使用Gzip压缩
        GzipResponseWrapper gzipResponse = new GzipResponseWrapper((HttpServletResponse) response);
        chain.doFilter(request, gzipResponse);
        gzipResponse.finish(); // 完成压缩并输出
    }

    // 自定义响应包装类
    static class GzipResponseWrapper extends HttpServletResponseWrapper {
        private GZIPOutputStream gzipOut;
        private ServletOutputStream out;

        public GzipResponseWrapper(HttpServletResponse response) throws IOException {
            super(response);
            // 设置压缩响应头
            response.setHeader("Content-Encoding", "gzip");
            gzipOut = new GZIPOutputStream(response.getOutputStream());
            out = new ServletOutputStream() {
                @Override
                public void write(int b) throws IOException {
                    gzipOut.write(b);
                }
                @Override
                public boolean isReady() { return true; }
                @Override
                public void setWriteListener(WriteListener listener) {}
            };
        }

        @Override
        public ServletOutputStream getOutputStream() {
            return out;
        }

        public void finish() throws IOException {
            gzipOut.finish(); // 完成压缩
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class RepeatableRequestWrapper extends HttpServletRequestWrapper {
    private byte[] body; // 缓存请求体

    public RepeatableRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        // 读取原始流并缓存
        body = IOUtils.toByteArray(request.getInputStream());
    }

    // 重写getInputStream()，返回缓存的字节流
    @Override
    public ServletInputStream getInputStream() {
        return new ServletInputStream() {
            private final ByteArrayInputStream bais = new ByteArrayInputStream(body);

            @Override
            public int read() {
                return bais.read();
            }

            @Override
            public boolean isReady() { return true; }

            @Override
            public void setWriteListener(WriteListener listener) {}
        };
    }

    // 重写getReader()，基于缓存的字节流构建
    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
}

// 在Filter中使用
@WebFilter("/*")
public class RequestLogFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 包装请求，使其可重复读取
        RepeatableRequestWrapper wrapper = new RepeatableRequestWrapper((HttpServletRequest) request);
        // 第一次读取请求体（日志记录）
        String body = IOUtils.toString(wrapper.getInputStream(), wrapper.getCharacterEncoding());
        System.out.println("Request Body: " + body);
        // 放行，后续组件可再次读取
        chain.doFilter(wrapper, response);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@WebFilter("/*")
public class RequestLoggerFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        long startTime = System.currentTimeMillis();

        // 记录请求方法、URL
        String log = String.format("Method: %s, URL: %s", req.getMethod(), req.getRequestURI());

        // 记录请求参数（GET/POST表单）
        if (!req.getMethod().equals("GET")) {
            // 使用前面的RepeatableRequestWrapper读取Body
            RepeatableRequestWrapper wrapper = new RepeatableRequestWrapper(req);
            String body = IOUtils.toString(wrapper.getInputStream(), wrapper.getCharacterEncoding());
            log += ", Body: " + body;
            request = wrapper; // 替换为包装类
        }

        // 执行后续处理
        chain.doFilter(request, response);

        // 记录耗时
        long endTime = System.currentTimeMillis();
        log += ", Time: " + (endTime - startTime) + "ms";
        System.out.println(log);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public class ResponseWrapper extends HttpServletResponseWrapper {
    private ByteArrayOutputStream buffer; // 缓存响应数据
    private ServletOutputStream out;

    public ResponseWrapper(HttpServletResponse response) {
        super(response);
        buffer = new ByteArrayOutputStream();
        out = new ServletOutputStream() {
            @Override
            public void write(int b) {
                buffer.write(b);
            }
            @Override
            public boolean isReady() { return true; }
            @Override
            public void setWriteListener(WriteListener listener) {}
        };
    }

    @Override
    public ServletOutputStream getOutputStream() {
        return out;
    }

    @Override
    public PrintWriter getWriter() {
        return new PrintWriter(new OutputStreamWriter(buffer, getCharacterEncoding()));
    }

    // 重写响应内容（如添加统一响应头）
    public byte[] getResponseData() throws IOException {
        out.flush();
        // 示例：在响应体末尾添加版权信息
        String original = buffer.toString(getCharacterEncoding());
        String modified = original + "\n© 2024 MyApp";
        return modified.getBytes(getCharacterEncoding());
    }
}

// 在Filter中使用
@WebFilter("/*")
public class ResponseModifyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        ResponseWrapper wrapper = new ResponseWrapper((HttpServletResponse) response);
        chain.doFilter(request, wrapper);
        // 输出修改后的响应
        byte[] data = wrapper.getResponseData();
        response.getOutputStream().write(data);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

@WebFilter("/*")
public class CorsFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletResponse resp = (HttpServletResponse) response;
        // 允许所有源（生产环境需指定具体域名）
        resp.setHeader("Access-Control-Allow-Origin", "*");
        // 允许的请求方法
        resp.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
        // 允许的请求头
        resp.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization");
        // 预检请求有效期（秒）
        resp.setHeader("Access-Control-Max-Age", "3600");
        chain.doFilter(request, response);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 解密请求Filter
@WebFilter("/*")
public class DecryptFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        RepeatableRequestWrapper wrapper = new RepeatableRequestWrapper(req);
        // 读取加密的请求体并解密（示例：AES解密）
        String encryptedBody = IOUtils.toString(wrapper.getInputStream(), "UTF-8");
        String decryptedBody = AESUtils.decrypt(encryptedBody, "secretKey");
        // 替换为解密后的字节流
        wrapper = new RepeatableRequestWrapper(req, decryptedBody.getBytes("UTF-8"));
        chain.doFilter(wrapper, response);
    }
}

// 加密响应Filter（类似实现，对ResponseWrapper的输出进行加密）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 自定义 LogFilter（记录请求耗时）
@WebFilter(urlPatterns = "/*", order = 1)
public class LogFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Filter 初始化：仅执行1次（Filter 实例创建时）
        System.out.println("LogFilter 初始化");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 1. 处理请求（前置处理：记录开始时间）
        long startTime = System.currentTimeMillis();
        HttpServletRequest req = (HttpServletRequest) request;
        System.out.println("请求URL：" + req.getRequestURI() + "，开始时间：" + startTime);

        // 2. 传递请求给下一个 Filter 或 Servlet
        chain.doFilter(request, response); // 关键：触发链的下一个节点

        // 3. 处理响应（后置处理：计算耗时）
        long endTime = System.currentTimeMillis();
        System.out.println("请求" + req.getRequestURI() + "耗时：" + (endTime - startTime) + "ms");
    }

    @Override
    public void destroy() {
        // Filter 销毁：仅执行1次（容器关闭时）
        System.out.println("LogFilter 销毁");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

@WebListener
public class ContextAttrListener implements ServletContextAttributeListener {
    // 属性添加时触发（如 context.setAttribute("key", "value")）
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {
        String key = scae.getName();
        Object value = scae.getValue();
        System.out.println("全局属性添加：" + key + "=" + value);
    }

    // 属性移除时触发（如 context.removeAttribute("key")）
    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {
        System.out.println("全局属性移除：" + scae.getName());
    }

    // 属性替换时触发（如再次调用 context.setAttribute("key", "newValue")）
    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {
        String key = scae.getName();
        Object oldValue = scae.getValue(); // 旧值
        Object newValue = scae.getServletContext().getAttribute(key); // 新值
        System.out.println("全局属性替换：" + key + "，旧值：" + oldValue + "，新值：" + newValue);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

@WebListener
public class AppListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 初始化全局监控容器：存储所有请求的耗时（线程安全的列表）
        List<Long> requestCostList = Collections.synchronizedList(new ArrayList<>());
        sce.getServletContext().setAttribute("requestCostList", requestCostList);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用关闭：输出平均耗时
        List<Long> costList = (List<Long>) sce.getServletContext().getAttribute("requestCostList");
        if (!costList.isEmpty()) {
            long avgCost = costList.stream().mapToLong(Long::longValue).average().getAsDouble();
            System.out.println("应用关闭，平均请求耗时：" + avgCost + "ms");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

@WebListener
public class OnlineUserListener implements HttpSessionListener {
    private AtomicInteger onlineCount = new AtomicInteger(0); // 原子类保证线程安全

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // 会话创建：在线人数+1
        int count = onlineCount.incrementAndGet();
        se.getSession().getServletContext().setAttribute("onlineCount", count);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // 会话销毁：在线人数-1
        int count = onlineCount.decrementAndGet();
        se.getSession().getServletContext().setAttribute("onlineCount", count);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

@WebFilter(urlPatterns = "/*", order = 1)
public class PerformanceFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 1. 前置：记录请求开始时间和当前在线人数
        long startTime = System.currentTimeMillis();
        ServletContext context = request.getServletContext();
        int onlineCount = (int) context.getAttribute("onlineCount");
        System.out.println("当前在线人数：" + onlineCount + "，请求开始处理");

        // 2. 放行请求
        chain.doFilter(request, response);

        // 3. 后置：计算耗时并加入全局监控
        long cost = System.currentTimeMillis() - startTime;
        List<Long> costList = (List<Long>) context.getAttribute("requestCostList");
        costList.add(cost);
        System.out.println("请求耗时：" + cost + "ms，累计请求数：" + costList.size());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@WebFilter(urlPatterns = "/user/*", order = 2)
public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;

        // 1. 排除登录页（避免死循环）
        String url = req.getRequestURI();
        if (url.contains("/login")) {
            chain.doFilter(request, response);
            return;
        }

        // 2. 检查会话中的用户信息
        HttpSession session = req.getSession(false); // 无会话则返回null，不创建新会话
        if (session == null || session.getAttribute("loginUser") == null) {
            // 未登录：重定向到登录页
            resp.sendRedirect("/login?redirect=" + url); // 携带原请求URL，登录后跳转
            return;
        }

        // 3. 已登录：放行
        chain.doFilter(request, response);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@WebListener
public class OnlineUserListener implements HttpSessionListener {
    // 原子类：保证多线程下在线人数计数安全
    private final AtomicInteger onlineCount = new AtomicInteger(0);

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // 会话创建：在线人数+1，存入全局上下文
        int count = onlineCount.incrementAndGet();
        ServletContext context = se.getSession().getServletContext();
        context.setAttribute("onlineCount", count);
        System.out.println("用户上线，当前在线：" + count);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // 会话销毁：在线人数-1，更新全局上下文
        int count = onlineCount.decrementAndGet();
        ServletContext context = se.getSession().getServletContext();
        context.setAttribute("onlineCount", Math.max(count, 0)); // 避免负数
        System.out.println("用户下线，当前在线：" + count);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@WebListener
public class PerformanceListener implements ServletRequestListener {
    // 全局监控：存储所有请求耗时（线程安全）
    private final List<Long> totalCostList = Collections.synchronizedList(new ArrayList<>());

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // 请求创建：记录开始时间，存入请求属性
        long startTime = System.currentTimeMillis();
        sre.getServletRequest().setAttribute("startTime", startTime);
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        // 请求销毁：计算耗时，更新全局统计
        ServletRequest req = sre.getServletRequest();
        long startTime = (long) req.getAttribute("startTime");
        long cost = System.currentTimeMillis() - startTime;

        // 加入全局列表
        totalCostList.add(cost);

        // 计算并输出平均耗时
        double avgCost = totalCostList.stream().mapToLong(Long::longValue).average().orElse(0);
        System.out.println("请求" + ((HttpServletRequest) req).getRequestURI() + "耗时：" + cost + "ms，平均耗时：" + String.format("%.2f", avgCost) + "ms");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 封装 Filter 的核心配置参数
public class FilterConfig {
    private Filter filter; // Filter 实例
    private String[] urlPatterns; // 拦截的 URL 模式
    private int order; // 执行顺序
    private boolean enabled; // 是否启用

    // 构造器、getter、setter
    public FilterConfig(Filter filter, String[] urlPatterns, int order, boolean enabled) {
        this.filter = filter;
        this.urlPatterns = urlPatterns;
        this.order = order;
        this.enabled = enabled;
    }

    // getter 和 setter 省略
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// 管理 Filter 配置，动态注册到 Servlet 容器
public class FilterRegistry implements ServletContextListener {
    // 存储所有 Filter 配置（线程安全）
    private final List<FilterConfig> filterConfigs = Collections.synchronizedList(new ArrayList<>());

    // 添加 Filter 配置
    public void addFilterConfig(FilterConfig config) {
        if (config != null && config.isEnabled()) {
            filterConfigs.add(config);
        }
    }

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();

        // 1. 按 order 排序 Filter 配置
        filterConfigs.sort(Comparator.comparingInt(FilterConfig::getOrder));

        // 2. 遍历配置，动态注册 Filter 到容器
        for (FilterConfig config : filterConfigs) {
            Filter filter = config.getFilter();
            String filterName = filter.getClass().getSimpleName();

            // 2.1 注册 Filter 实例
            context.addFilter(filterName, filter);

            // 2.2 配置拦截的 URL 模式
            FilterRegistration.Dynamic dynamic = context.getFilterRegistration(filterName);
            dynamic.addMappingForUrlPatterns(
                    EnumSet.of(DispatcherType.REQUEST), // 仅拦截请求
                    false, // 是否匹配 servletContext 的路径
                    config.getUrlPatterns() // URL 模式
            );

            System.out.println("动态注册 Filter：" + filterName + "，URL模式：" + Arrays.toString(config.getUrlPatterns()) + "，order：" + config.getOrder());
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 销毁时清理配置
        filterConfigs.clear();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 应用启动类（模拟 Spring Boot 的启动逻辑）
public class AppStarter {
    public static void main(String[] args) {
        // 1. 创建 Filter 实例
        LogFilter logFilter = new LogFilter();
        AuthFilter authFilter = new AuthFilter();

        // 2. 创建 Filter 注册器
        FilterRegistry registry = new FilterRegistry();

        // 3. 添加 Filter 配置（可从配置文件读取参数，实现动态配置）
        registry.addFilterConfig(new FilterConfig(logFilter, new String[]{"/*"}, 1, true)); // 启用 LogFilter
        registry.addFilterConfig(new FilterConfig(authFilter, new String[]{"user/*"}, 2, false)); // 禁用 AuthFilter（后续可动态启用）

        // 4. 将注册器注册为 ServletContextListener（应用启动时触发注册）
        // 实际 Web 应用中，可通过 web.xml 或注解注册 registry
    }
}