Java HttpStatus.BAD_REQUEST属性代码示例

@RequestMapping(method = RequestMethod.POST, consumes = "application/json", produces = "application/json;charset=utf-8")
public ResponseEntity<?> post(JwtAuthenticationToken token, @RequestBody Envelope envelope) {
  UserContext userContext = (UserContext) token.getPrincipal();
  
  if (envelope != null) {
    List<Event> events = envelope.getData();
    List<String> ids = null;
    if (events != null && !events.isEmpty()) {
      ids = new ArrayList<>();
      for (Event event : events) {
        try {
          String savedId = this.eventService.save(userContext.getTenantId(), userContext.getOrgId(), event);
          ids.add(savedId);
        } catch (Exception e) {
          logger.error("Unable to save event {}",event);
          continue;
        }
      }
    }
    
    return new ResponseEntity<>(ids, null, HttpStatus.OK);
  }
  
  return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ErrorVM processValidationError(MethodArgumentNotValidException ex) {
    BindingResult result = ex.getBindingResult();
    List<FieldError> fieldErrors = result.getFieldErrors();
    ErrorVM dto = new ErrorVM(ErrorConstants.ERR_VALIDATION);
    for (FieldError fieldError : fieldErrors) {
        dto.add(fieldError.getObjectName(), fieldError.getField(), fieldError.getCode());
    }
    return dto;
}
 

@ExceptionHandler(MissingServletRequestParameterException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public FieldErrorVM processMissingServletRequestParameterError(MissingServletRequestParameterException ex) {
    FieldErrorVM dto = new FieldErrorVM(ErrorConstants.ERR_VALIDATION, translate(ErrorConstants.ERR_VALIDATION));
    dto.add(ex.getParameterType(), ex.getParameterName(), ex.getLocalizedMessage());
    return dto;
}
 

@RequestMapping(value = "/customcommand", method = RequestMethod.POST)
public ResponseEntity<CustomResponse> executeCustomCommand(@RequestParam("command") String command,
		@RequestHeader(value = "JHeapSessionId") String JHeapSessionId) {
	if (command == null || command.isEmpty()) {
		return new ResponseEntity<CustomResponse>(HttpStatus.BAD_REQUEST);
	}
	CustomResponse analysis = analysisService.executeCustomCommand(command);
	return new ResponseEntity<CustomResponse>(analysis, HttpStatus.OK);
}
 

/**
 * Handles NorthboundException exception.
 *
 * @param exception the NorthboundException instance
 * @param request   the WebRequest caused exception
 * @return the ResponseEntity object instance
 */
@ExceptionHandler(MessageException.class)
protected ResponseEntity<Object> handleMessageException(MessageException exception, WebRequest request) {
    HttpStatus status;

    switch (exception.getErrorType()) {
        case NOT_FOUND:
            status = HttpStatus.NOT_FOUND;
            break;
        case DATA_INVALID:
        case PARAMETERS_INVALID:
            status = HttpStatus.BAD_REQUEST;
            break;
        case ALREADY_EXISTS:
            status = HttpStatus.CONFLICT;
            break;
        case AUTH_FAILED:
            status = HttpStatus.UNAUTHORIZED;
            break;
        case OPERATION_TIMED_OUT:
        case INTERNAL_ERROR:
        default:
            status = HttpStatus.INTERNAL_SERVER_ERROR;
            break;
    }

    MessageError error = new MessageError(request.getHeader(CORRELATION_ID), exception.getTimestamp(),
            exception.getErrorType().toString(), exception.getMessage(), exception.getErrorDescription());
    return super.handleExceptionInternal(exception, error, new HttpHeaders(), status, request);
}
 

@ExceptionHandler({ MethodArgumentTypeMismatchException.class })
public ResponseEntity<Object> handleMethodArgumentTypeMismatch(final MethodArgumentTypeMismatchException ex, final WebRequest request) {
	logger.info(ex.getClass().getName());
	//
	final String error = ex.getName() + " should be of type " + ex.getRequiredType().getName();

	final AitException AitException = new AitException(HttpStatus.BAD_REQUEST, ex.getLocalizedMessage(), error);
	return new ResponseEntity<Object>(AitException, new HttpHeaders(), AitException.getStatus());
}
 

@GetMapping(path="/deleteImage")
@ResponseBody
public ResponseEntity<Object> deleteImage(@RequestParam int id){
    ResponseEntity response;

    try {
        imageFormRepository.deleteById(id);
        response = new ResponseEntity<>("Image successfully deleted.", HttpStatus.OK);
    } catch (Exception e) {
        response = new ResponseEntity<>("Error with request", HttpStatus.BAD_REQUEST);
    }

    return response;
}
 

@RequestMapping(value = "/register", method = RequestMethod.POST)
public ResponseEntity<?> register(@RequestBody UserRegisterDTO registerDTO) {
    Optional<ValidationErrors> errors = validators.validate(registerDTO);
    if (!errors.isPresent()) {
        //return confirmation
        UserCredentialDTO newUser = userService.regiserUser(registerDTO);
        log.debug("New user[{}] created!",newUser.getUsername());
        return new ResponseEntity<>(newUser, HttpStatus.OK);
    } else {
        log.warn("Missing or incorrect data on registration form.");
        return new ResponseEntity<>(errors.get().getErrors(), HttpStatus.BAD_REQUEST);
    }
}
 

@ExceptionHandler(MissingServletRequestParameterException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public Map<String,String> paramMissErrorHandler(MissingServletRequestParameterException e) throws Exception {
    Map error = new HashMap();
    error.put("error","参数" + e.getParameterName() + "不能为空");
    return error;
}
 

@Secured(USER)
@RequestMapping(value = "/transport/{id}/bid", method = RequestMethod.POST)
public ResponseEntity<?> makeBid(@PathVariable("id") long transportId, @RequestBody PlaceBidDTO bidDTO, Principal principal) {
    log.debug("{} trying to make a bid on transport({})",principal.getName(), transportId);
    try {
        auctionService.makeBid(transportId, bidDTO.getAmount(), principal.getName());
        return new ResponseEntity<>("Bid placed.", HttpStatus.OK);
    } catch (AuctionError auerr) {
        log.error("Error happened during bidding: {}",auerr.getMessage());
        return new ResponseEntity<>(auerr.getMessage(), HttpStatus.BAD_REQUEST);
    }
}
 

@ExceptionHandler(ServletRequestBindingException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ErrorResponse handle(final ServletRequestBindingException ex) {
    log.error("Missing parameter", ex);
    return new ErrorResponse("MISSING_PARAMETER", ex.getMessage());
}
 

@Secured(ADMIN)
@RequestMapping(value = "/{id}/admin", method = DELETE)
public ResponseEntity<?> adminDeleteTransport(@PathVariable("id") long id) {
    if (transportService.adminDelete(id)) {
        log.debug("Transport({}) deleted by admin.", id);
        return new ResponseEntity<>("Transport deleted.", HttpStatus.OK);
    } else {
        log.warn("Failed to delete transport({}).", id);
        return new ResponseEntity<>("Failed to delete transport.", HttpStatus.BAD_REQUEST);
    }
}
 

/**
 * RFC7591
 * Definitions this endpoint MAY be an OAuth 2.0 protected resource
 * and it MAY accept an initial access token.
 *
 * As we are using open registration, these endpoint MAY be rate-limited to prevent a denial-of-service attack.
 */
@PostMapping("/register")
public ResponseEntity<Object> register(@RequestBody ClientRegistrationRequest clientMetadata) {

    if (!redirectFlowSpecification.isSatisfiedBy(clientMetadata)) {
        RegistrationError error = new RegistrationError(RegistrationError.INVALID_REDIRECT_URI);
        error.setErrorDescription("You must specify redirect_uri when using flows with redirection");
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    DynamicClientDetails clientDetails = clientDetailsFactory.create(clientMetadata);
    clientRegistration.addClientDetails(clientDetails);

    return new ResponseEntity<>(createResponse(clientDetails), HttpStatus.CREATED);
}
 

public static YggdrasilException newIllegalArgumentException(String message) {
	return new YggdrasilException(HttpStatus.BAD_REQUEST, "IllegalArgumentException", message);
}
 

@ExceptionHandler(CustomParameterizedException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ParameterizedErrorVM processParameterizedValidationError(CustomParameterizedException ex) {
    return ex.getErrorVM();
}