SpringBoot中请求处理组件全面对比与选型指南

import jakarta.servlet.*;
import jakarta.servlet.http.httpservletrequest;
import jakarta.servlet.http.httpservletresponse;
import org.springframework.core.annotation.order;
import org.springframework.stereotype.component;

import java.io.ioexception;

/**
 * 请求日志过滤器
 */
@component
@order(1)
public class requestlogfilter implements filter {

    @override
    public void dofilter(servletrequest request, servletresponse response,
                         filterchain chain) throws ioexception, servletexception {
        httpservletrequest req = (httpservletrequest) request;
        httpservletresponse resp = (httpservletresponse) response;

        long start = system.currenttimemillis();
        system.out.println("[filter] 请求进入: " + req.getmethod() + " " + req.getrequesturi());

        // 放行到下一个 filter 或 dispatcherservlet
        chain.dofilter(request, response);

        long cost = system.currenttimemillis() - start;
        system.out.println("[filter] 请求完成: " + req.getrequesturi() + " 耗时 " + cost + "ms 状态码 " + resp.getstatus());
    }
}

import org.springframework.boot.web.servlet.filterregistrationbean;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

@configuration
public class filterconfig {

    @bean
    public filterregistrationbean<requestlogfilter> requestlogfilter() {
        filterregistrationbean<requestlogfilter> bean = new filterregistrationbean<>();
        bean.setfilter(new requestlogfilter());
        bean.addurlpatterns("/*");
        bean.setorder(1);
        bean.setname("requestlogfilter");
        return bean;
    }
}

import jakarta.servlet.http.httpservletrequest;
import jakarta.servlet.http.httpservletresponse;
import org.springframework.stereotype.component;
import org.springframework.web.servlet.handlerinterceptor;

/**
 * 登录校验拦截器
 */
@component
public class logininterceptor implements handlerinterceptor {

    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response,
                             object handler) throws exception {
        string token = request.getheader("authorization");
        if (token == null || token.isempty()) {
            response.setstatus(401);
            response.getwriter().write("未登录");
            return false; // 中断请求
        }
        system.out.println("[interceptor] prehandle: token=" + token);
        return true; // 放行
    }

    @override
    public void posthandle(httpservletrequest request, httpservletresponse response,
                           object handler, modelandview modelandview) throws exception {
        system.out.println("[interceptor] posthandle: controller 执行完毕");
    }

    @override
    public void aftercompletion(httpservletrequest request, httpservletresponse response,
                                object handler, exception ex) throws exception {
        system.out.println("[interceptor] aftercompletion: 请求结束, ex=" + ex);
    }
}

import org.springframework.context.annotation.configuration;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

@configuration
public class webmvcconfig implements webmvcconfigurer {

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(new logininterceptor())
                .addpathpatterns("/api/**")       // 拦截路径
                .excludepathpatterns("/api/login"); // 排除路径
    }
}

import lombok.extern.slf4j.slf4j;
import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.component;

/**
 * 接口耗时统计切面
 */
@slf4j
@aspect
@component
public class timelogaspect {

    /**
     * 定义切入点：controller 包下所有 public 方法
     */
    @pointcut("execution(public * com.example.demo.controller.*.*(..))")
    public void controllerpointcut() {
    }

    /**
     * 环绕通知：统计方法执行耗时
     */
    @around("controllerpointcut()")
    public object around(proceedingjoinpoint pjp) throws throwable {
        long start = system.currenttimemillis();
        string methodname = pjp.getsignature().toshortstring();

        log.info("[aop] 方法开始: {}", methodname);

        try {
            object result = pjp.proceed(); // 执行目标方法
            long cost = system.currenttimemillis() - start;
            log.info("[aop] 方法结束: {}, 耗时 {}ms", methodname, cost);
            return result;
        } catch (throwable e) {
            long cost = system.currenttimemillis() - start;
            log.error("[aop] 方法异常: {}, 耗时 {}ms", methodname, cost, e);
            throw e;
        }
    }

    /**
     * 前置通知
     */
    @before("controllerpointcut()")
    public void before() {
        // 在 @around 的 proceed() 之前执行
    }
}

import jakarta.servlet.servletrequestevent;
import jakarta.servlet.servletrequestlistener;
import jakarta.servlet.annotation.weblistener;
import org.springframework.stereotype.component;

/**
 * servlet 请求监听器
 */
@component
public class requestlistener implements servletrequestlistener {

    @override
    public void requestinitialized(servletrequestevent sre) {
        system.out.println("[listener] 请求创建: " + sre.getservletrequest());
    }

    @override
    public void requestdestroyed(servletrequestevent sre) {
        system.out.println("[listener] 请求销毁");
    }
}

import org.springframework.context.event.eventlistener;
import org.springframework.stereotype.component;

/**
 * spring 事件监听器
 */
@component
public class springeventlistener {

    /**
     * 监听应用启动完成事件
     */
    @eventlistener
    public void onapplicationready(applicationreadyevent event) {
        system.out.println("[listener] 应用启动完成");
    }

    /**
     * 监听自定义事件
     */
    @eventlistener
    public void onordercreated(ordercreatedevent event) {
        system.out.println("[listener] 收到订单创建事件: " + event.getorderid());
    }
}

import lombok.getter;
import org.springframework.context.applicationevent;

/**
 * 订单创建事件
 */
@getter
public class ordercreatedevent extends applicationevent {

    private final string orderid;

    public ordercreatedevent(object source, string orderid) {
        super(source);
        this.orderid = orderid;
    }
}

import org.springframework.context.applicationeventpublisher;
import org.springframework.stereotype.service;

@service
public class orderservice {

    private final applicationeventpublisher eventpublisher;

    public orderservice(applicationeventpublisher eventpublisher) {
        this.eventpublisher = eventpublisher;
    }

    public void createorder(string orderid) {
        // 业务逻辑...
        system.out.println("订单创建: " + orderid);

        // 发布事件
        eventpublisher.publishevent(new ordercreatedevent(this, orderid));
    }
}

import lombok.extern.slf4j.slf4j;
import org.springframework.http.httpstatus;
import org.springframework.web.bind.annotation.*;

import java.util.hashmap;
import java.util.map;

/**
 * 全局异常处理器
 */
@slf4j
@restcontrolleradvice
public class globalexceptionhandler {

    /**
     * 处理业务异常
     */
    @exceptionhandler(businessexception.class)
    @responsestatus(httpstatus.ok)
    public map<string, object> handlebusiness(businessexception e) {
        log.warn("业务异常: {}", e.getmessage());
        map<string, object> result = new hashmap<>();
        result.put("code", e.getcode());
        result.put("message", e.getmessage());
        return result;
    }

    /**
     * 处理参数校验异常
     */
    @exceptionhandler(illegalargumentexception.class)
    @responsestatus(httpstatus.bad_request)
    public map<string, object> handleillegalarg(illegalargumentexception e) {
        log.warn("参数异常: {}", e.getmessage());
        map<string, object> result = new hashmap<>();
        result.put("code", "400");
        result.put("message", e.getmessage());
        return result;
    }

    /**
     * 兜底：处理所有未捕获异常
     */
    @exceptionhandler(exception.class)
    @responsestatus(httpstatus.internal_server_error)
    public map<string, object> handleexception(exception e) {
        log.error("系统异常", e);
        map<string, object> result = new hashmap<>();
        result.put("code", "500");
        result.put("message", "系统繁忙");
        return result;
    }
}

@restcontrolleradvice
public class globaldatabinder {

    @initbinder
    public void initbinder(webdatabinder binder) {
        // 注册自定义编辑器
        binder.registercustomeditor(string.class, new stringtrimmereditor(true));
    }
}

@restcontrolleradvice
public class globalrequestbodyadvice {

    @modelattribute
    public void addcommonattributes(model model) {
        model.addattribute("servertime", system.currenttimemillis());
    }
}

import org.springframework.core.methodparameter;
import org.springframework.stereotype.component;
import org.springframework.web.bind.support.webdatabinderfactory;
import org.springframework.web.context.request.nativewebrequest;
import org.springframework.web.method.support.handlermethodargumentresolver;
import org.springframework.web.method.support.modelandviewcontainer;

import jakarta.servlet.http.httpservletrequest;

/**
 * 自定义参数处理器：解析 @currentuser 注解
 */
@component
public class currentuserargumentresolver implements handlermethodargumentresolver {

    @override
    public boolean supportsparameter(methodparameter parameter) {
        return parameter.hasparameterannotation(currentuser.class)
                && parameter.getparametertype().equals(userinfo.class);
    }

    @override
    public object resolveargument(methodparameter parameter,
                                  modelandviewcontainer mavcontainer,
                                  nativewebrequest webrequest,
                                  webdatabinderfactory binderfactory) throws exception {
        httpservletrequest request = webrequest.getnativerequest(httpservletrequest.class);
        string token = request.getheader("authorization");

        // 从 token 解析用户信息（实际项目中通常从 jwt 或缓存中获取）
        userinfo user = parsetoken(token);
        return user;
    }

    private userinfo parsetoken(string token) {
        userinfo user = new userinfo();
        user.setid(1001l);
        user.setname("张三");
        return user;
    }
}

import java.lang.annotation.*;

@target(elementtype.parameter)
@retention(retentionpolicy.runtime)
@documented
public @interface currentuser {
}

import lombok.data;

@data
public class userinfo {
    private long id;
    private string name;
}

import org.springframework.context.annotation.configuration;
import org.springframework.web.method.support.handlermethodargumentresolver;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

import java.util.list;

@configuration
public class webmvcconfig implements webmvcconfigurer {

    private final currentuserargumentresolver currentuserresolver;

    public webmvcconfig(currentuserargumentresolver currentuserresolver) {
        this.currentuserresolver = currentuserresolver;
    }

    @override
    public void addargumentresolvers(list<handlermethodargumentresolver> resolvers) {
        resolvers.add(currentuserresolver);
    }
}

@restcontroller
@requestmapping("/api/user")
public class usercontroller {

    @getmapping("/profile")
    public map<string, object> getprofile(@currentuser userinfo user) {
        map<string, object> result = new hashmap<>();
        result.put("id", user.getid());
        result.put("name", user.getname());
        return result;
    }
}

import org.springframework.core.methodparameter;
import org.springframework.http.mediatype;
import org.springframework.http.converter.httpmessageconverter;
import org.springframework.http.server.serverhttprequest;
import org.springframework.http.server.serverhttpresponse;
import org.springframework.web.bind.annotation.restcontrolleradvice;
import org.springframework.web.servlet.mvc.method.annotation.responsebodyadvice;

import java.util.hashmap;
import java.util.map;

/**
 * 统一返回值包装
 * <p>
 * 通过 responsebodyadvice 实现，它本质上是返回值处理器的增强钩子。
 */
@restcontrolleradvice
public class globalresponsehandler implements responsebodyadvice<object> {

    @override
    public boolean supports(methodparameter returntype,
                            class<? extends httpmessageconverter<?>> convertertype) {
        // 如果已经是 result 类型，则不再包装
        return !returntype.getparametertype().equals(result.class);
    }

    @override
    public object beforebodywrite(object body,
                                  methodparameter returntype,
                                  mediatype selectedcontenttype,
                                  class<? extends httpmessageconverter<?>> selectedconvertertype,
                                  serverhttprequest request,
                                  serverhttpresponse response) {
        map<string, object> result = new hashmap<>();
        result.put("code", 0);
        result.put("message", "success");
        result.put("data", body);
        return result;
    }
}

import lombok.data;

@data
public class result<t> {
    private int code;
    private string message;
    private t data;

    public static <t> result<t> success(t data) {
        result<t> r = new result<>();
        r.setcode(0);
        r.setmessage("success");
        r.setdata(data);
        return r;
    }

    public static <t> result<t> fail(string message) {
        result<t> r = new result<>();
        r.setcode(500);
        r.setmessage(message);
        return r;
    }
}

import org.springframework.context.annotation.configuration;
import org.springframework.web.method.support.handlermethodargumentresolver;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

import java.util.list;

/**
 * web mvc 统一配置
 */
@configuration
public class webmvcconfig implements webmvcconfigurer {

    private final logininterceptor logininterceptor;
    private final currentuserargumentresolver currentuserresolver;

    public webmvcconfig(logininterceptor logininterceptor,
                        currentuserargumentresolver currentuserresolver) {
        this.logininterceptor = logininterceptor;
        this.currentuserresolver = currentuserresolver;
    }

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(logininterceptor)
                .addpathpatterns("/api/**")
                .excludepathpatterns("/api/login", "/api/register");
    }

    @override
    public void addargumentresolvers(list<handlermethodargumentresolver> resolvers) {
        resolvers.add(currentuserresolver);
    }
}

@restcontroller
@requestmapping("/api/order")
public class ordercontroller {

    private final orderservice orderservice;

    public ordercontroller(orderservice orderservice) {
        this.orderservice = orderservice;
    }

    @postmapping("/create")
    public ordervo createorder(@currentuser userinfo user,
                               @requestbody @valid ordercreaterequest request) {
        return orderservice.createorder(user.getid(), request);
    }
}