Correct way to implement a 'heartbeat' service in SpringFramework

I have a java web application running on tomcat. I wanted to create a 'heartbeat' method that will simply return a 200 status code that I can use to verify the status of the service. I created a simple controller class that looks like this:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.function.ServerResponse;

@CrossOrigin(origins = "*")
@Controller
@RequestMapping(path = "/status")
public class StatusController {

    private static final Logger logger = LoggerFactory.getLogger(StatusController.class);
    @CrossOrigin(origins = "*")
    @GetMapping(path = "/heartbeat")
    public ServerResponse getHeartbeat()
    {
        logger.info("checking heartbeat");
        return ServerResponse.ok().build();
    }

    @CrossOrigin(origins = "*")
    @GetMapping(path = "/hello", produces = "text/html")
    @ResponseBody
    public String getHello()
    {
        return "Hello World";
    }
}

If I deploy my application, I can call mysite.com/myapp/status/hello and get a return value of 'Hello World'. However, if I try to call the heartbeat service ( mysite.com/myapp/status/heartbeat ) I get a 404 error.

I'm not quite sure what I'm doing wrong here. What is the correct way to simply return a status code from a service call?

To add to Abhinav's answer, as he stated don't use ServerResponse here; it's not the appropriate response type.

If you just want to return a 200 if everything is ok, you can do something like this:

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.function.ServerResponse;
import static org.springframework.http.HttpStatus.SERVICE_UNAVAILABLE;

...

@CrossOrigin(origins = "*")
@GetMapping(path = "/heartbeat")
public ResponseEntity<?> getHeartbeat()
{
    logger.info("checking heartbeat");
    if (isEverythingKosher()) {
      return ResponseEntity.ok().build();
    } else {
      return ResponseEntity.status(SERVICE_UNAVAILABLE).build();
    }
}

But, as stated in the previous answer, I would leverage Actuator as it's already got built-in support for most checks that you'll want to use. You can even extend it with your own health checks if you want to by defining a class that extends AbstractHealthIndicator

@Component
public class MyHealthCheck extends AbstractHealthIndicator {
  @Override
  protected void doHealthCheck(Health.Builder builder) throws Exception {
    // Do your checks here, set the builder up or down depending on the status
    if (isEverythingKosher()) {
      builder.up();
    } else {
      builder.down();
    }
  }
}

Then when you call the actuator/health endpoint, it will contribute to the health status of your application.

Here is what the output would look like using the actuator (I set the custom health indicator to indicate down).

{
  "status": "DOWN",
  "components": {
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 1000240963584,
        "free": 472888266752,
        "threshold": 10485760,
        "path": "/Users/lane.maxwell/git/actuator-demo/.",
        "exists": true
      }
    },
    "mongo": {
      "status": "UP",
      "details": {
        "maxWireVersion": 13
      }
    },
    "myHealthCheck": {
      "status": "DOWN"
    },
    "ping": {
      "status": "UP"
    }
  }
}

The ServerResponse is from Spring Reactive framework, used in Spring webflux.

So for simple healthcheck/heartbeat implementation, your second method getHello() construct will do just fine, if you are building spring web project and deploying in a tomcat server. Because your second method's response status will be 200 OK as well.

Side-note: I've seen you've tagged your question as a spring-boot. So, if you are building a spring-boot app, then i'll suggest to use it's spring-boot-actuator which adds many production grade capabilities, out of which, two which i've used in our enterprise apps are health check and shutdown

 http://localhost:8080/actuator/health
{"status":"UP"}

http://localhost:8080/actuator/shutdown
{ "message" : "Shutting down, bye..."}

So, \actuatot\health endpoint is also good fit for heartbeat implementation