Spring Boot custom ErrorAttributes http status not set to response

All you are doing is building the body of your error response, as you can see from your sample. Spring is the one handling the status code.

If you want to have full control on all parts of the response then you should use the ControllerAdvice approach as shown in their documentation:

@ControllerAdvice(basePackageClasses = FooController.class)
public class FooControllerAdvice extends ResponseEntityExceptionHandler {

   @ExceptionHandler(MyException.class)
   public ResponseEntity<Message> handleRequestErrorMyException(HttpServletRequest request, MyException myException) {
        HttpStatus status = HttpStatus.valueOf(myException.getStatus();
        return new ResponseEntity<>(new CustomErrorType(status.value(), ex.getMessage()), status);
    }

}

With this bean in place all MyException thrown by any controller under the FooController package will be captured and processed by handleRequestErrorMyException, the response to the original request will be the one returned by this method. Just make sure in your Configuration class that this package gets scanned.

Alternatively you can use

MyException extends ResponseStatusException {
 public MyException (String msg) {
 super(HttpStatus.FORBIDDEN, msg);
} 

try below, not that valid values types are integer for status key, while you were adding enum which is HttpStatus.BAD_REQUEST it should be HttpStatus.BAD_REQUEST.value().

import org.springframework.boot.web.error.ErrorAttributeOptions;
import org.springframework.boot.web.reactive.error.DefaultErrorAttributes;
import org.springframework.boot.web.reactive.error.ErrorAttributes;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.server.ServerRequest;

import java.util.Map;

@Configuration
public class RestExceptionHandler {

    @Bean
    public ErrorAttributes errorAttributes() {
        return new DefaultErrorAttributes() {
            @Override
            public Map<String, Object> getErrorAttributes(ServerRequest request,
                                                          ErrorAttributeOptions options) {
                Map<String, Object> map = super.getErrorAttributes(
                        request, options);
                map.put("status", HttpStatus.BAD_REQUEST.value());
                //map.put("message", "Fields are missing.");
                return map;
            }
        };
    }
}

The accepted answer didn't work for me in a Spring Boot 2.3.0 application, I had to subclass ErrorController to override the original status.

This is the code of BasicErrorController, applied as default:

    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        HttpStatus status = getStatus(request);
        if (status == HttpStatus.NO_CONTENT) {
            return new ResponseEntity<>(status);
        }
        Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));
        return new ResponseEntity<>(body, status);
    }

As you can see the original status is kept on a variable gotten before the invocation of getErrorAttributes(). Thus, adding requestAttributes.setAttribute("javax.servlet.error.status_code", httpStatus, 0); in your custom getErrorAttibutes() doesn't really do anything.

In a custom extension of BasicErrorController (remember to add it as a bean) you can override error() and make sure status gets the value you want:

public class CustomBasicErrorController extends BasicErrorController {

    public CustomBasicErrorController(ErrorAttributes errorAttributes, ErrorProperties errorProperties) {
        super(errorAttributes, errorProperties);
    }

    public CustomBasicErrorController(ErrorAttributes errorAttributes, ErrorProperties errorProperties, List<ErrorViewResolver> errorViewResolvers) {
        super(errorAttributes, errorProperties, errorViewResolvers);
    }

    @Override
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));
        Integer status = (Integer) body.get("status");
        if (status == HttpStatus.NO_CONTENT.value()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(body, HttpStatus.valueOf(status));
    }
}

@Getter
public class AppException extends ResponseStatusException {
  private final ErrorAttributeOptions options;

  public AppException(HttpStatus status, String message, ErrorAttributeOptions options){
      super(status, message);
      this.options = options;
  }
}

1. Use sendError with status in ExceptionHandler:

   @ExceptionHandler(AppException .class)
   public void appException(HttpServletResponse response) throws IOException {
        response.sendError(ex.getStatus().value());
   }
   

See Spring REST Error Handling Example

2. You can crossbreed ResponseEntityExceptionHandler with DefaultErrorAttributes like this (Spring Boot 2.3 comes with additional ErrorAttributeOptions):

@RestControllerAdvice
@AllArgsConstructor
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
    private final ErrorAttributes errorAttributes;

    @ExceptionHandler(AppException.class)
    public ResponseEntity<Map<String, Object>> appException(AppException ex, WebRequest request) throws IOException {
        Map<String, Object> body = errorAttributes.getErrorAttributes(request, ex.getOptions());
        HttpStatus status = ex.getStatus();
        body.put("status", status.value());
        body.put("error", status.getReasonPhrase());
        return ResponseEntity.status(status).body(body);
    }
}

I've checked it for MESSAGE, EXCEPTION and STACK_TRACE options.
See also Using ErrorAttributes in our custom ErrorController