Troubleshooting 404 Error when Accessing Spring Boot REST Controller on Localhost

If you’re developing a Spring Boot application and are unable to access your REST controller on localhost, you may be encountering a 404 error. This can be a frustrating issue to resolve, but with a little troubleshooting, you should be able to get your application up and running.



Using @ComponentScan annotation

The first step in troubleshooting this issue is to check your application’s configuration. Make sure that the package containing your REST controller is correctly specified in your application’s main class. For example, the following code snippet shows an example of how to correctly configure a REST controller package:

@SpringBootApplication
@ComponentScan(basePackages = "com.example.restcontroller")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

In this example, the @ComponentScan annotation is used to specify that the package com.example.restcontroller should be scanned for components, including REST controllers. Make sure that the package specified in your application’s configuration matches the package containing your REST controller.



Using @RestController and @RequestMapping

Next, check your REST controller’s class and method annotations. Make sure that the class is correctly annotated with @RestController and that each method is annotated with @RequestMapping. The following code snippet shows an example of a properly annotated REST controller:

@RestController
@RequestMapping("/api")
public class MyRestController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

In this example, the class is annotated with @RestController and @RequestMapping("/api"), and the sayHello() method is annotated with @GetMapping("/hello"). These annotations are used to map the REST controller to URLs that can be accessed by clients.



Using application.properties or application.yml file

Finally, check your application’s properties file (application.properties or application.yml) to make sure that the server is listening on the correct port. By default, Spring Boot applications listen on port 8080, but you can configure the application to listen on a different port by setting the server.port property. For example, the following code snippet shows how to configure the application to listen on port 9000:

server:
  port: 9000


Request URL format

Another possible cause of a 404 error when accessing a Spring Boot REST controller on localhost is a problem with the URL path. Make sure that the URL path specified in your client’s request matches the path specified in the @RequestMapping annotation of your REST controller method. For example, if your REST controller method is mapped to /api/hello, make sure that your client is sending a request to http://localhost:8080/api/hello (or the correct port if you have configured a different one).



Spring boot dependencies

If you are still encountering a 404 error, another thing you can check is your application’s dependencies. Make sure that you have the correct version of spring-web and spring-webmvc dependencies. You can check this by looking at your application’s pom.xml or build.gradle file.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Additionally, if you are using Spring Boot version 2.3.x or later, it is important to check that you have added the spring-web and spring-webmvc modules to your classpath. These modules provide the necessary support for creating REST controllers and handling HTTP requests and responses.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}


Using servlet context path

Another possible cause of a 404 error when accessing a Spring Boot REST controller on localhost is a problem with the context path. By default, Spring Boot applications use an empty context path, but you can configure the application to use a different context path by setting the server.servlet.context-path property in your application’s properties file. For example, the following code snippet shows how to configure the application to use a context path of /myapp:

Copy codeserver:
  servlet:
    context-path: /myapp

This means that all requests to your application should include the context path. So if your REST controller is mapped to /api/hello, the client should send a request to http://localhost:8080/myapp/api/hello



Debugging and Troubleshooting the 404 error

If you’ve checked all of these items and are still encountering a 404 error, you may need to check the logs for more information. Spring Boot applications log detailed information about each request, including any errors that occur. You can access the logs by running the application with the --debug or --trace command line options, or by setting the logging.level.root property in your application’s properties file.



Conclusion

In conclusion, troubleshooting a 404 error when accessing a Spring Boot REST controller on localhost requires checking the application’s configuration, REST controller class and method annotations, server listen port, URL path, dependencies and context path. By going through these steps and checking the logs for more information, you should be able to resolve the issue and access your REST controller as expected.



Leave a Reply