Spring Boot 404错误全面解析与解决方案

@controller
public class usercontroller {

    @requestmapping("/user")
    public string getuserpage() {
        return "userprofile"; // 对应 templates/userprofile.html
    }
}

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
@controller
@responsebody
public @interface restcontroller {
}

@restcontroller
public class apiusercontroller {

    @getmapping("/api/users")
    public list<user> getusers() {
        return userservice.findall();
    }
}

graph td
    a[新建控制器类] --> b{是否主要用于返回json/xml?}
    b -- 是 --> c[使用@restcontroller]
    b -- 否 --> d{是否需要返回html页面?}
    d -- 是 --> e[使用@controller + 模板引擎]
    d -- 否 --> f[考虑是否需@responsebody混合使用]
    f --> g[使用@controller并在方法上加@responsebody]

@restcontroller
@requestmapping("/users")
public class userresource {

    private final userservice userservice;

    public userresource(userservice userservice) {
        this.userservice = userservice;
    }

    @getmapping
    public responseentity<list<user>> getallusers() {
        list<user> users = userservice.findall();
        return responseentity.ok(users);
    }

    @getmapping("/{id}")
    public responseentity<user> getuserbyid(@pathvariable long id) {
        return userservice.findbyid(id)
                .map(responseentity::ok)
                .orelse(responseentity.notfound().build());
    }

    @postmapping
    public responseentity<user> createuser(@valid @requestbody user user) {
        user saved = userservice.save(user);
        return responseentity.status(httpstatus.created).body(saved);
    }

    @putmapping("/{id}")
    public responseentity<user> updateuser(@pathvariable long id, @valid @requestbody user user) {
        if (!userservice.exists(id)) {
            return responseentity.notfound().build();
        }
        user.setid(id);
        user updated = userservice.update(user);
        return responseentity.ok(updated);
    }

    @deletemapping("/{id}")
    public responseentity<void> deleteuser(@pathvariable long id) {
        if (!userservice.exists(id)) {
            return responseentity.notfound().build();
        }
        userservice.delete(id);
        return responseentity.nocontent().build();
    }
}

@requestmapping(value = "/data", method = requestmethod.get)
// 等价于
@requestmapping(path = "/data", method = requestmethod.get)

@requestmapping(path = {"/users", "/members"}, method = requestmethod.get)
public list<user> getallentities() {
    return service.findall();
}

@restcontroller
@requestmapping("/api")
public class productcontroller {

    @requestmapping("/products")  // 实际路径：/api/products
    public list<product> getproducts() {
        return productservice.list();
    }
}

@requestmapping(path = "/login", method = requestmethod.post)
public string login(@requestbody loginrequest req) {
    authservice.authenticate(req);
    return "success";
}

@postmapping("/login") // 等价于 @requestmapping(..., method = post)

@requestmapping(
    path = "/data",
    method = requestmethod.post,
    consumes = mediatype.application_json_value,
    produces = mediatype.application_xml_value
)
public @responsebody userdata processdata(@requestbody userdata input) {
    return transform(input);
}

@getmapping("/users/new")           // 优先级最高
public string newuserform() { ... }

@getmapping("/users/{id}")          // 中等优先级
public user getuser(@pathvariable string id) { ... }

@getmapping("/users/*")             // 最低优先级
public string matchwildcard() { ... }

graph lr
    a[收到请求: /users/new] --> b{是否存在精确匹配?}
    b -- 是 --> c[执行精确路径方法]
    b -- 否 --> d{是否存在uri变量匹配?}
    d -- 是 --> e[执行模板方法]
    d -- 否 --> f{是否存在通配符匹配?}
    f -- 是 --> g[执行通配符方法]
    f -- 否 --> h[返回404]

@restcontroller
@requestmapping(produces = "application/json")
public class ordercontroller {

    @requestmapping(path = "/orders", method = requestmethod.get)
    public list<order> listorders() { ... }
}

@restcontroller
@requestmapping("/books")
public class bookcontroller {

    private final map<long, book> bookstore = new concurrenthashmap<>();
    private long nextid = 1;

    @getmapping
    public responseentity<list<book>> getallbooks() {
        return responseentity.ok(new arraylist<>(bookstore.values()));
    }

    @postmapping
    public responseentity<book> createbook(@valid @requestbody book book) {
        book.setid(nextid++);
        bookstore.put(book.getid(), book);
        return responseentity.status(httpstatus.created).body(book);
    }
}

public class book {
    private long id;
    private string title;
    private string author;

    // getters and setters...
}

{
  "title": "spring in action",
  "author": "craig walls"
}

{
  "id": 1,
  "title": "spring in action",
  "author": "craig walls"
}

@target(elementtype.method)
@retention(retentionpolicy.runtime)
@documented
@requestmapping(method = requestmethod.get)
public @interface getmapping {
    @aliasfor(annotation = requestmapping.class, attribute = "value")
    string[] value() default {};

    @aliasfor(annotation = requestmapping.class, attribute = "path")
    string[] path() default {};
}

graph td
    a[启动spring应用] --> b{扫描@component类}
    b --> c[发现@controller或@restcontroller]
    c --> d[遍历其中的所有public方法]
    d --> e{方法是否标注映射注解?}
    e -- 是 --> f[解析@getmapping/@postmapping等]
    f --> g[通过反射获取元注解@requestmapping]
    g --> h[提取value/path + method组合]
    h --> i[生成requestcondition实例]
    i --> j[注册至handlermapping映射表]
    j --> k[等待dispatcherservlet调用]
    e -- 否 --> l[跳过该方法]

@getmapping(path = "/users", produces = mediatype.application_json_value)
@responsebody
public list<user> getallusers() {
    return userservice.findall();
}

@getmapping("/users/{id}")
public responseentity<user> getuserbyid(@pathvariable long id) {
    user user = userservice.findbyid(id);
    return user != null ? 
        responseentity.ok(user) : 
        responseentity.notfound().build();
}

@getmapping("/orders/{orderid}/items/{itemid}")
public item getitem(
    @pathvariable("orderid") long orderid,
    @pathvariable("itemid") long itemid) {
    // ...
}

@getmapping("/products/{category:[a-z]+}/{productid:\\d+}")
public product getproduct(
    @pathvariable string category,
    @pathvariable long productid) {
    return productservice.findbycategoryandid(category, productid);
}

@restcontroller
public class usercontroller {

    @getmapping("/users")
    public string listusers() {
        return "user list";
    }
}

@getmapping("/api/users")  // 注意大写
public string apiusers() { ... }

@configuration
public class webconfig implements webmvcconfigurer {
    @override
    public void configurepathmatch(pathmatchconfigurer configurer) {
        configurer.setcasesensitive(false); // 关闭大小写敏感
    }
}

错误：get /search?keyword=测试
正确：get /search?keyword=%e6%b5%8b%e8%af%95

@restcontroller
@requestmapping("/api/v1")
public class userapicontroller {

    private final userservice userservice;

    public userapicontroller(userservice userservice) {
        this.userservice = userservice;
    }

    @getmapping("/users")
    public responseentity<list<user>> getallusers(
            @requestparam(defaultvalue = "0") int page,
            @requestparam(defaultvalue = "10") int size) {
        list<user> users = userservice.paginate(page, size);
        return responseentity.ok(users);
    }

    @postmapping("/users")
    public responseentity<user> createuser(@requestbody @valid usercreationdto dto) {
        user saved = userservice.create(dto);
        return responseentity.status(httpstatus.created).body(saved);
    }

    @getmapping("/users/{id}")
    public responseentity<user> getuserbyid(@pathvariable("id") @min(1) long id) {
        return userservice.findbyid(id)
                .map(responseentity::ok)
                .orelse(responseentity.notfound().build());
    }

    @putmapping("/users/{id}")
    public responseentity<user> updateuser(
            @pathvariable long id,
            @requestbody @valid userupdatedto dto) {
        if (!userservice.exists(id)) {
            return responseentity.notfound().build();
        }
        user updated = userservice.update(id, dto);
        return responseentity.ok(updated);
    }

    @deletemapping("/users/{id}")
    public responseentity<void> deleteuser(@pathvariable long id) {
        if (!userservice.deletebyid(id)) {
            return responseentity.notfound().build();
        }
        return responseentity.nocontent().build(); // 204
    }
}

mapped "{[/api/v1/users],methods=[get]}" onto public ...
mapped "{[/api/v1/users],methods=[post]}" onto public ...
mapped "{[/api/v1/users/{id}],methods=[get]}" onto public ...

registry.addresourcehandler("/**")
        .addresourcelocations("classpath:/meta-inf/resources/",
                              "classpath:/resources/",
                              "classpath:/static/",
                              "classpath:/public/");

src/
 └── main/
     └── resources/
         ├── static/
         │   └── css/
         │       └── style.css
         ├── public/
         │   └── js/
         │       └── app.js
         ├── resources/
         │   └── images/
         │       └── logo.png
         └── meta-inf/
             └── resources/
                 └── favicon.ico

flowchart td
    a[http request received] --> b{has matching @requestmapping?}
    b -- yes --> c[invoke controller method]
    b -- no --> d[trigger resourcehttprequesthandler]
    d --> e[loop through resource locations]
    e --> f{file exists in location?}
    f -- no --> g[next location]
    f -- yes --> h[check if modified since last request]
    h --> i{resource unchanged?}
    i -- yes --> j[return 304 not modified]
    i -- no --> k[read file stream]
    k --> l[set content-type & headers]
    l --> m[write response body]
    g --> n{all locations checked?}
    n -- no --> e
    n -- yes --> o[return 404 not found]

@configuration
@enablewebmvc
public class webconfig implements webmvcconfigurer {

    @override
    public void addresourcehandlers(resourcehandlerregistry registry) {
        registry.addresourcehandler("/**")
                .addresourcelocations(
                    "classpath:/meta-inf/resources/",
                    "classpath:/resources/",
                    "classpath:/static/",
                    "classpath:/public/"
                )
                .setcacheperiod(3600) // 缓存1小时
                .resourcechain(true); // 启用资源链（如gzip压缩）
    }
}

spring:
  resources:
    static-locations: 
      - classpath:/custom-static/
      - file:/var/www/html/
      - classpath:/meta-inf/resources/webjars/

mapped url path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.resourcehttprequesthandler]
mapped url path [/**] onto handler of type [class org.springframework.web.servlet.resource.resourcehttprequesthandler]

spring:
  resources:
    static-locations:
      - classpath:/fallback/
      - classpath:/primary/

@configuration
@conditionalonproperty(prefix = "spring.resources", name = "static-locations")
public class customstaticresourceconfig implements webmvcconfigurer {

    @value("#{'${spring.resources.static-locations}'.split(',')}")
    private list<string> staticlocations;

    @override
    public void addresourcehandlers(resourcehandlerregistry registry) {
        string[] locations = staticlocations.stream()
                .map(string::trim)
                .toarray(string[]::new);

        registry.addresourcehandler("/**")
                .addresourcelocations(locations)
                .setcacheperiod(60 * 60) // 1小时缓存
                .resourcechain(true);
    }
}

src/main/resources/
├── index.html        ← 错误：不在默认路径内
├── config/
│   └── application.yml
└── static/
    └── css/
        └── main.css

@component
public class authinterceptor implements handlerinterceptor {
    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) {
        string token = request.getheader("authorization");
        if (token == null || !token.startswith("bearer ")) {
            response.setstatus(401);
            return false;
        }
        return true;
    }
}

@configuration
public class webmvcconfig implements webmvcconfigurer {
    @autowired
    private authinterceptor authinterceptor;

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(authinterceptor)
                .excludepathpatterns("/css/**", "/js/**", "/images/**", "/**/*.ico", "/swagger-ui/**");
    }
}

spring:
  resources:
    static-locations: classpath:/frontend/

com.example.demo
├── demoapplication.java              // 启动类
├── controller
│   └── usercontroller.java           // @restcontroller
├── service
│   └── userservice.java              // @service
└── model
    └── user.java

package com.example.demo;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;

@springbootapplication
public class demoapplication {
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }
}

package com.example.demo.controller;

import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.restcontroller;

@restcontroller
public class usercontroller {

    @getmapping("/users")
    public string listusers() {
        return "{'users': ['alice', 'bob']}";
    }
}

com.example.controllers.usercontroller  // 与demo平级

o.s.w.s.handler.simpleurlhandlermapping  : mapped url path [/users] onto handler ...

graph td
    a[启动类 demoapplication] --> b{所在包路径?}
    b --> c["com.example.demo"]
    c --> d[扫描子包: controller, service, repository]
    d --> e[发现 @restcontroller -> 注册为handler]
    f[外部包 com.example.external] --> g[不在扫描范围内]
    g --> h[controller未注册 → 404错误]

com.example
├── common
│   └── basecontroller.java
├── demo
│   └── demoapplication.java
└── api
    └── userapicontroller.java

package com.example.api;

import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.restcontroller;

@restcontroller
public class userapicontroller {

    @getmapping("/api/users")
    public string getusers() {
        return "api users list";
    }
}

package com.example;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;

@springbootapplication
public class demoapplication {
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }
}

@springbootapplication
@componentscan(basepackages = {
    "com.example.demo",
    "com.example.api",
    "com.example.common"
})
public class demoapplication {
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }
}

@componentscan(basepackages = {"com.example.service", "com.example.controller", "com.example.repository"})

parent-project/
├── user-module/
│   └── src/main/java/com/company/user/usercontroller.java
├── order-module/
│   └── src/main/java/com/company/order/orderservice.java
└── main-app/
    └── src/main/java/com/company/app/demoapplication.java

@springbootapplication
@componentscan(basepackages = {
    "com.company.user", 
    "com.company.order", 
    "com.company.app"
})
public class demoapplication {
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }
}

@componentscan(basepackageclasses = {usercontroller.class, orderservice.class})

@componentscan(
    basepackages = "com.example",
    excludefilters = @componentscan.filter(
        type = filtertype.annotation,
        classes = ignorethis.class
    )
)

@restcontroller
@requestmapping("/debug")
public class debugcontroller {
    @getmapping("/ping")
    public string ping() { return "pong"; }
}

@conditionalonproperty(name = "app.debug-mode", havingvalue = "false")
@componentscan(excludefilters = @filter(
    type = filtertype.assignable_type,
    classes = debugcontroller.class

@springbootapplication
@componentscan(
    basepackages = "com.example",
    excludefilters = @componentscan.filter(
        type = filtertype.assignable_type,
        classes = debugcontroller.class
    )
)
public class demoapplication { ... }

# application.yml
logging:
  level:
    org.springframework.context.annotation: debug
    org.springframework.web.servlet.mvc.method.annotation: debug

debug [main] annotationconfigapplicationcontext:657 - registering component class: class com.example.controller.usercontroller
debug [main] classpathscanningcandidatecomponentprovider:258 - identified candidate component: file [...usercontroller.class]
info  [main] requestmappinghandlermapping:288 - mapped "{[/users],methods=[get]}" onto public java.lang.string com.example.controller.usercontroller.listusers()

<modules>
    <module>user-service</module>
    <module>order-service</module>
    <module>gateway</module>
</modules>

@springbootapplication
@componentscan({
    "com.company.userservice.controller",
    "com.company.orderservice.controller",
    "com.company.gateway.controller"
})
public class gatewayapplication { ... }

@componentscan(basepackageclasses = {
    usercontroller.class,
    ordercontroller.class
})

<dependencies>
    <dependency>
        <groupid>com.company</groupid>
        <artifactid>user-service</artifactid>
        <version>1.0.0</version>
    </dependency>
</dependencies>

@springbootapplication
@componentscan(basepackages = {"com.example.app", "com.example.api"})
public class demoapplication {
    public static void main(string[] args) {
        springapplication.run(demoapplication.class, args);
    }
}

flowchart td
    a[出现404错误] --> b{检查controller是否被注册}
    b --> c[查看启动日志是否有mapped日志]
    c -->|无| d[检查启动类包路径]
    d --> e[controller是否在子包中?]
    e -->|否| f[方案一: 提升启动类位置]
    e -->|否| g[方案二: 添加@componentscan]
    g --> h[指定basepackages或basepackageclasses]
    h --> i[重启应用验证]
    i --> j[成功响应 → 问题解决]
    c -->|有| k[排查其他原因: 路径拼写、method限定等]

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
@inherited
@springbootconfiguration
@enableautoconfiguration
@componentscan(excludefilters = { @filter(type = filtertype.custom, classes = typeexcludefilter.class),
        @filter(type = filtertype.custom, classes = autoconfigurationexcludefilter.class) })
public @interface springbootapplication {
    // 可选排除自动配置类
    class<?>[] exclude() default {};

    string[] excludename() default {};
}

@configuration
public class application {
    public static void main(string[] args) {
        springapplication.run(application.class, args);
    }
}

flowchart td
    a[启动类标注@springbootapplication] --> b{解析复合注解}
    b --> c["@configuration: 标识为配置类"]
    b --> d["@enableautoconfiguration: 加载自动配置"]
    b --> e["@componentscan: 扫描@controller等组件"]
    d --> f["读取meta-inf/spring.factories"]
    f --> g["条件化加载webmvcautoconfiguration"]
    g --> h["注册dispatcherservlet、handlermapping等"]
    e --> i["发现usercontroller等控制器"]
    i --> j["注册@requestmapping映射关系"]
    h & j --> k[请求可被正确路由]

# meta-inf/spring.factories
org.springframework.boot.autoconfigure.enableautoconfiguration=\
org.springframework.boot.autoconfigure.web.servlet.webmvcautoconfiguration,\
org.springframework.boot.autoconfigure.data.jpa.jparepositoriesautoconfiguration,\
org.springframework.boot.autoconfigure.jackson.jacksonautoconfiguration

@configuration(proxybeanmethods = false)
@conditionalonwebapplication(type = type.servlet)
@conditionalonclass({ servlet.class, dispatcherservlet.class, webmvcconfigurer.class })
@conditionalonmissingbean(webmvcconfigurationsupport.class)
@autoconfigureorder(ordered.highest_precedence + 10)
public class webmvcautoconfiguration {
    // ...
}

$ java -jar myapp.jar --debug

auto-configuration report

positive matches:
   dispatcherservletautoconfiguration matched:
      - @conditionalonclass found required class 'org.springframework.web.servlet.dispatcherservlet'

negative matches:
   webmvcautoconfiguration:
      - @conditionalonmissingbean (types: org.springframework.web.servlet.config.annotation.webmvcconfigurationsupport; searchstrategy: all) found beans: customwebconfig

@springbootapplication(exclude = {
    datasourceautoconfiguration.class,
    hibernatejpaautoconfiguration.class
})
public class myapplication {
    public static void main(string[] args) {
        springapplication.run(myapplication.class, args);
    }
}

@configuration
public class customwebconfig extends webmvcconfigurationsupport {
    @override
    protected void addcorsmappings(corsregistry registry) {
        registry.addmapping("/**")
                .allowedorigins("*")
                .allowedmethods("get", "post");
    }
}

@springbootapplication(exclude = { webmvcautoconfiguration.class })
// 显式排除，避免条件冲突
public class application { /* ... */ }

@override
public void addresourcehandlers(resourcehandlerregistry registry) {
    registry.addresourcehandler("/**")
            .addresourcelocations("classpath:/static/");
}

@configuration
public class customwebconfig implements webmvcconfigurer {
    @override
    public void addcorsmappings(corsregistry registry) {
        registry.addmapping("/**").allowedorigins("*");
    }

    // 不覆盖其他方法，保留自动配置行为
}

@springbootapplication(exclude = {
    embeddedwebserverfactorycustomizerautoconfiguration.class,
    dispatcherservletautoconfiguration.class
})

@autowired
private environment environment;

@postconstruct
public void checkenvironment() {
    system.out.println("active profiles: " + arrays.tostring(environment.getactiveprofiles()));
    system.out.println("web application type: " + 
        ((abstractapplicationcontext)applicationcontext).getbeanfactory().gettypeconverter());
}

public static void main(string[] args) {
    springapplication app = new springapplication(myapplication.class);
    app.setwebapplicationtype(webapplicationtype.servlet); // 或 reactive / none
    app.run(args);
}

@springbootapplication(exclude = {
    httpmessageconvertersautoconfiguration.class,
    webmvcautoconfiguration.class
})
public class badapplication { }

mapped "{[/users], methods=[get]}" onto public java.util.list<...> usercontroller.getallusers()

// module-user/src/main/java/com/example/user/userapp.java
@springbootapplication
public class userapp { }

// module-order/src/main/java/com/example/order/orderapp.java
@springbootapplication
public class orderapp { }

found multiple @springbootconfiguration annotated classes

starting com.example.demoapplication using java ...
no active profile set, falling back to 1 default profile: "default"
registering beans for jmx exposure on startup
mapped url path [/api/users] onto method [public user com.example.usercontroller.getuser(...)]
tomcat started on port(s): 8080 (http) with context path ''
started demoapplication in 3.2 seconds

// ❌ 错误写法
@springbootapplication(exclude = webmvcautoconfiguration.class)

// ✅ 正确做法
@springbootapplication // 保持默认

@configuration
public class mywebconfig implements webmvcconfigurer {

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(new logginginterceptor())
                .addpathpatterns("/api/**");
    }

    @override
    public void addresourcehandlers(resourcehandlerregistry registry) {
        registry.addresourcehandler("/docs/**")
                .addresourcelocations("classpath:/docs/");
    }
}

@restcontroller
public class testcontroller {

    @getmapping("/hello")
    public string hello() {
        return "hello world!";
    }
}

// basicerrorcontroller 默认实现片段（简化）
@controller
@requestmapping("${server.error.path:${error.path:/error}}")
public class basicerrorcontroller extends abstracterrorcontroller {

    @requestmapping
    public responseentity<map<string, object>> error(httpservletrequest request) {
        map<string, object> body = geterrorattributes(request, isincludestacktrace(request, mediatype.all));
        httpstatus status = getstatus(request);
        return new responseentity<>(body, status);
    }
}

@component
public class customerrorcontroller implements errorcontroller {

    private static final string error_path = "/error";

    @override
    public string geterrorpath() {
        return error_path;
    }

    @requestmapping(error_path)
    public responseentity<errorresponse> handleerror(httpservletrequest request) {
        integer statuscode = (integer) request.getattribute(requestdispatcher.error_status_code);
        string requesturi = (string) request.getattribute(requestdispatcher.error_request_uri);

        errorresponse response = new errorresponse();
        response.settimestamp(localdatetime.now());
        response.setstatus(statuscode != null ? statuscode : 500);
        response.seterror("resource not found");
        response.setmessage("the requested resource '" + requesturi + "' was not found.");
        response.setpath(requesturi);

        // 日志记录
        system.out.println("404 detected: " + requesturi);

        return responseentity.status(httpstatus.not_found).body(response);
    }
}

// 统一错误响应体
class errorresponse {
    private localdatetime timestamp;
    private int status;
    private string error;
    private string message;
    private string path;

    // getter/setter 省略
}

{
  "timestamp": "2025-04-05t10:30:00",
  "status": 404,
  "error": "resource not found",
  "message": "the requested resource '/api/v1/nonexist' was not found.",
  "path": "/api/v1/nonexist"
}

src/
 └── main/
     └── resources/
         └── templates/
             └── error/
                 ├── 404.html
                 └── 5xx.html

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org">
<head><title>page not found</title></head>
<body>
<h1>oops! page not found (404)</h1>
<p><strong>requested url:</strong> <span th:text="${path}">/unknown</span></p>
<p><strong>error:</strong> <span th:text="${error}">not found</span></p>
<p><strong>time:</strong> <span th:text="${timestamp}"></span></p>
<a href="/" rel="external nofollow" >← go home</a>
</body>
</html>

@controlleradvice
public class errorhandlingadvice {

    @modelattribute("appname")
    public string appname() {
        return "myspringbootapp";
    }

    @exceptionhandler(nohandlerfoundexception.class)
    public string handle404(model model, httpservletrequest request) {
        model.addattribute("path", request.getrequesturi());
        return "error/404";
    }
}

spring:
  mvc:
    throw-exception-if-no-handler-found: true
  web:
    resources:
      add-mappings: true

@aspect
@component
public class errorloggingaspect {

    private static final logger log = loggerfactory.getlogger(errorloggingaspect.class);

    @afterthrowing(pointcut = "within(org.springframework.web.servlet.mvc.method.annotation.responseentityexceptionhandler+)", throwing = "ex")
    public void lognotfounderror(joinpoint jp, exception ex) {
        servletrequestattributes attributes = (servletrequestattributes) requestcontextholder.currentrequestattributes();
        httpservletrequest request = attributes.getrequest();

        if (ex instanceof nohandlerfoundexception || 
            (ex.getcause() instanceof nohandlerfoundexception)) {
            map<string, object> logdata = new hashmap<>();
            logdata.put("timestamp", localdatetime.now());
            logdata.put("method", request.getmethod());
            logdata.put("uri", request.getrequesturi());
            logdata.put("remoteaddr", request.getremoteaddr());
            logdata.put("useragent", request.getheader("user-agent"));
            logdata.put("exception", ex.getclass().getsimplename());
            logdata.put("stacktrace", arrays.tostring(ex.getstacktrace()).substring(0, 200));

            log.warn("404 request intercepted: {}", logdata);
        }
    }
}

@restcontroller
public class metricscontroller {

    @value("${server.error.include-message:false}")
    private boolean includemessage;

    @getmapping("/actuator/errors-count")
    public map<string, long> geterrorcounts() {
        // 实际应从 meterregistry 获取 counter
        return map.of(
            "404_count", 128l,
            "500_count", 12l,
            "total_errors", 140l
        );
    }
}

graph td
    a[client request /unknown] --> b{handler found?}
    b -- no --> c[forward to /error]
    c --> d{accept: json?}
    d -- yes --> e[return json via customerrorcontroller]
    d -- no --> f[render 404.html via thymeleaf]
    e --> g[log with aop & send to monitoring]
    f --> g
    g --> h[response sent]