Java DeleteMapping类代码示例

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
/**
 * Remove um lançamento por ID.
 * 
 * @param id
 * @return ResponseEntity<Response<Lancamento>>
 */
@DeleteMapping(value = "/{id}")
@PreAuthorize("hasAnyRole('ADMIN')")
public ResponseEntity<Response<String>> remover(@PathVariable("id") Long id) {
	log.info("Removendo lançamento: {}", id);
	Response<String> response = new Response<String>();
	Optional<Lancamento> lancamento = this.lancamentoService.buscarPorId(id);

	if (!lancamento.isPresent()) {
		log.info("Erro ao remover devido ao lançamento ID: {} ser inválido.", id);
		response.getErrors().add("Erro ao remover lançamento. Registro não encontrado para o id " + id);
		return ResponseEntity.badRequest().body(response);
	}

	this.lancamentoService.remover(id);
	return ResponseEntity.ok(new Response<String>());
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping("/users/{id}")
public void deleteUser(@PathVariable int id) {
	User user = service.deleteById(id);
	
	if(user==null)
		throw new UserNotFoundException("id-"+ id);		
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
/**
   * 删除文件
   * @param id
   * @return
   */
  @DeleteMapping("/{id}")
  @ResponseBody
  public ResponseEntity<String> deleteFile(@PathVariable String id) {
 
  	try {
	fileService.removeFile(id);
	return ResponseEntity.status(HttpStatus.OK).body("DELETE Success!");
} catch (Exception e) {
	return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
}
  }
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
/**
 * DELETE /users/:userKey : delete the "userKey" User.
 *
 * @param userKey the user key of the user to delete
 * @return the ResponseEntity with status 200 (OK)
 */
@DeleteMapping("/users/{userKey}")
@Timed
@Secured(AuthoritiesConstants.ADMIN)
public ResponseEntity<Void> deleteUser(@PathVariable String userKey) {
    userService.deleteUser(userKey);
    return ResponseEntity.ok().headers(HeaderUtil.createAlert("userManagement.deleted", userKey)).build();
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
Annotation findMappingAnnotation(AnnotatedElement element) {
  Annotation mappingAnnotation = element.getAnnotation(RequestMapping.class);

  if (mappingAnnotation == null) {
    mappingAnnotation = element.getAnnotation(GetMapping.class);

    if (mappingAnnotation == null) {
      mappingAnnotation = element.getAnnotation(PostMapping.class);

      if (mappingAnnotation == null) {
        mappingAnnotation = element.getAnnotation(PutMapping.class);

        if (mappingAnnotation == null) {
          mappingAnnotation = element.getAnnotation(DeleteMapping.class);

          if (mappingAnnotation == null) {
            mappingAnnotation = element.getAnnotation(PatchMapping.class);
          }
        }
      }
    }
  }

  if (mappingAnnotation == null) {
    if (element instanceof Method) {
      Method method = (Method) element;
      mappingAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
    } else {
      Class<?> clazz = (Class<?>) element;
      mappingAnnotation = AnnotationUtils.findAnnotation(clazz, RequestMapping.class);
    }
  }

  return mappingAnnotation;
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@Override
public boolean canProcess(Method method) {
  return method.getAnnotation(RequestMapping.class) != null ||
      method.getAnnotation(GetMapping.class) != null ||
      method.getAnnotation(PutMapping.class) != null ||
      method.getAnnotation(PostMapping.class) != null ||
      method.getAnnotation(PatchMapping.class) != null ||
      method.getAnnotation(DeleteMapping.class) != null;
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping(
    path = "usingDeleteMapping/{targetName}",
    consumes = {"text/plain", "application/*"},
    produces = {"text/plain", "application/*"})
public String usingDeleteMapping(@RequestBody User srcUser, @RequestHeader String header,
    @PathVariable String targetName, @RequestParam(name = "word") String word, @RequestAttribute String form) {
  return String.format("%s %s %s %s %s", srcUser.name, header, targetName, word, form);
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping("/books/{ISBN}")
public ResponseEntity<Book> deleteBook(@PathVariable long ISBN) {

	Book book = bookDAO.getBook(ISBN);
	
	if (book == null) {
		return new ResponseEntity<Book>(HttpStatus.NOT_FOUND);
	}
	boolean deleted = bookDAO.deleteBook(ISBN);
	return new ResponseEntity(book, HttpStatus.OK);
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@PreAuthorize("isFullyAuthenticated()")
@DeleteMapping("/api/account/remove")
public ResponseEntity<GeneralController.RestMsg> removeAccount(Principal principal){
    boolean isDeleted = accountService.removeAuthenticatedAccount();
    if ( isDeleted ) {
        return new ResponseEntity<>(
                new GeneralController.RestMsg(String.format("[%s] removed.", principal.getName())),
                HttpStatus.OK
        );
    } else {
        return new ResponseEntity<GeneralController.RestMsg>(
                new GeneralController.RestMsg(String.format("An error ocurred while delete [%s]", principal.getName())),
                HttpStatus.BAD_REQUEST
        );
    }
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping("")
public RestResult<Boolean> delete(@RequestParam("job_name") String jobName,
		@RequestParam("job_group_name") String jobGroupName) throws SchedulerException {
	jobService.delete(jobName, jobGroupName);

	return new RestResult<>(true);
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
/**
 * DELETE  /votes/:id : delete the "id" vote.
 *
 * @param id the id of the vote to delete
 * @return the ResponseEntity with status 200 (OK)
 */
@DeleteMapping("/votes/{id}")
@Timed
public ResponseEntity<Void> deleteVote(@PathVariable Long id) {
    log.debug("REST request to delete Vote : {}", id);
    voteRepository.delete(id);
    voteSearchRepository.delete(id);
    return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping(value = "/{username}")
@PreAuthorize("hasRole('ROLE_ADMIN')")
@ApiOperation(value = "${UserController.delete}")
@ApiResponses(value = {//
    @ApiResponse(code = 400, message = "Something went wrong"), //
    @ApiResponse(code = 403, message = "Access denied"), //
    @ApiResponse(code = 404, message = "The user doesn't exist"), //
    @ApiResponse(code = 500, message = "Expired or invalid JWT token")})
public String delete(@ApiParam("Username") @PathVariable String username) {
  userService.delete(username);
  return username;
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping(value = "/{id}")
public ResponseEntity<User> deleteUser(@PathVariable("id") long id) {
	logger.info("Deleting User with id : {}", id);

	Optional<User> optionalUser = userService.findById(id);
	if (optionalUser.isPresent()) {
		userService.deleteUserById(id);
		return ResponseEntity.noContent().build();
	}
	else {
		logger.info("User with id: {} not found", id);
		return ResponseEntity.notFound().build();
	}

}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
@DeleteMapping("/xm-entities/self/links/targets/{targetId}")
@Timed
public ResponseEntity<Void> deleteSelfLinkTarget(@PathVariable String targetId) {
    log.debug("REST request to delete link target {} for self", targetId);
    xmEntityService.deleteSelfLinkTarget(targetId);
    return ResponseEntity.ok().build();
}
 

import org.springframework.web.bind.annotation.DeleteMapping; //导入依赖的package包/类
/**
 * Delete relation between {@link by.kraskovski.pms.domain.model.Stock} and {@link Store}
 */
@DeleteMapping("/stock-manage")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void deleteStock(@RequestParam final String storeId,
                        @RequestParam final String stockId) {
    log.info("Start delete stock: {} from store: {}", stockId, storeId);
    storeService.deleteStock(storeId, stockId);
}