Java在一个单独的方法中处理重复的异常

我正在开发一个SpringWebStart应用程序

我有2个（可能更多）方法处理多层异常子句，如：

...
    try {
        employeeService.updateEmployeePartner(employeeId, partner);
        LOG.info("partner details updated for partner id {}", employeeId);
        result = new ResponseEntity<>(partner.getId(), HttpStatus.OK);
    } catch (EmployeePartnerNotFoundException ex) {
        LOG.error(ex.getMessage() + " employee id: ", employeeId);
        errorResponse = new ErrorResponse("500", ex.getMessage());
    } catch (ReadOperationDeniedException ex) {
        LOG.error("User doesn't have permissions to update employee's {} details: {}", employeeId, ex.getMessage());
        errorResponse = new ErrorResponse("403", "User doesn't have permissions to update employee's details");
    } catch (Exception ex) {
        LOG.error("something went wrong while updating employee's {} partner details: {}", employeeId, ex.getMessage());
        errorResponse = new ErrorResponse("500", "unspecified server error");
    } finally {
        result = (result != null) ? result : new ResponseEntity<>(errorResponse, HttpStatus.I_AM_A_TEAPOT); // should be INTERNAL_SERVER_ERROR
    }
...

这是一种足够好的方法吗？或者在上述场景中是否有任何模式可以通过将处理外包给单独的方法/类来处理异常

因为它是一个Spring应用程序，我也考虑使用Spring异常处理程序，如：

 @ExceptionHandler(Exception.class)

---

，但这只能满足我的部分要求

将@ControllerAdvice与您的自定义ErrorResponse和每个处理程序一起用于seprate异常。提及

示例代码：

    @ControllerAdvice
    public class GlobalExceptionHandlers {

        private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandlers.class);


        /***************** User Defined Exceptions *************************/

        @ExceptionHandler({ EmployeePartnerNotFoundException.class })
        public ResponseEntity<Object> handleEmployeePartnerNotFoundException(EmployeePartnerNotFoundException ex) {

        logger.error("EmployeePartnerNotFoundException : ", ex);

        ErrorResponse errorResponse = new ErrorResponse("500", ex.getMessage());

        return new ResponseEntity<Object>(errorResponse, new HttpHeaders(), HttpStatus.BAD_REQUEST);
        }

        // other exception handlers

}

@ControllerAdvice
公共类GlobalExceptionHandlers{
私有静态最终记录器Logger=LoggerFactory.getLogger（GlobalExceptionHandlers.class）；
/*****************用户定义的异常*************************/
@ExceptionHandler（{EmployeePartnerNotFoundException.class}）
公共响应句柄EmployeePartnerNotFoundException（EmployeePartnerNotFoundException ex）{
logger.error（“EmployeePartnerNotFoundException:，ex”）；
ErrorResponse ErrorResponse=新的ErrorResponse（“500”，例如getMessage（））；
返回新的ResponseEntity（errorResponse，new HttpHeaders（），HttpStatus.BAD_请求）；
}
//其他异常处理程序
}

这就是我最后所做的，以及Sangam的回复：

单个异常处理程序工作得相当好；请注意，没有必要把这些放在单独的类中

但我仍然想知道，在应用程序不是SpringMVC的情况下，是否存在类似的模式

    public ResponseEntity<?> updatePartnerDetails(@PathVariable("employeeId") Long employeeId,
                                                  @RequestBody PersonDetails partnerDto) {
        LOG.info("Updating partner details for employee {}, partner details {}", employeeId, partnerDto);
        validateRequestValues(partnerDto);
        // Try-catches were around this call
        Person partner = PersonMapper.fromPersonDetails(partnerDto);
        employeeService.updateEmployeePartner(employeeId, partner);
        LOG.info("partner details updated for partner id {}", employeeId);
        return new ResponseEntity<>(partner.getId(), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: BAD_REQUEST
    @ExceptionHandler({EmployeePartnerExistsException.class, EmployeePartnerNotFoundException.class})
    public ResponseEntity<?> employeePartnerError(Exception ex) {
        LOG.error(ex.getMessage());
        return new ResponseEntity<Object>(new ErrorResponse(400, ex.getMessage()), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: BAD_REQUEST
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<?> validationError(Exception ex) {
        LOG.error(ex.getMessage());
        return new ResponseEntity<Object>(new ErrorResponse(400, ex.getMessage()), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: FORBIDDEN
    @ExceptionHandler(ReadOperationDeniedException.class)
    public ResponseEntity<?> forbidden(Exception ex) {
        LOG.error("User doesn't have permissions to amend employee's details");
        return new ResponseEntity<Object>(new ErrorResponse(403, "User doesn't have permissions to amend employee's details"), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: INTERNAL_SERVER_ERROR
    @ExceptionHandler(Exception.class)
    public ResponseEntity<?> unspecifiedError(Exception ex) {
        LOG.error("User doesn't have permissions to amend employee's details");
        return new ResponseEntity<Object>(new ErrorResponse(500, "Something went wrong while editing employee's details"), HttpStatus.OK);
    }

public ResponseEntity updatePartnerDetails（@PathVariable（“employeeId”）Long employeeId，
@请求主体个人详细信息合作伙伴（DTO）{
LOG.info（“更新员工{}的合作伙伴详细信息，合作伙伴详细信息{}”，employeeId，partnerDto）；
validateRequestValues（partnerDto）；
//这通电话周围有人吗
Person partner=PersonMapper.fromPersonDetails（partnerDto）；
updateEmployeePartner（employeeId，partner）；
LOG.info（“为合作伙伴id{}更新的合作伙伴详细信息”，employeeId）；
返回新的ResponseEntity（partner.getId（），HttpStatus.OK）；
}
@ResponseStatus（HttpStatus.I\u AM\u A\u TEAPOT）//TODO:错误的请求
@ExceptionHandler（{EmployeePartnerExistsException.class，EmployeePartnerNotFoundException.class}）
公共责任雇员合伙人错误（例外情况除外）{
LOG.error（例如getMessage（））；
返回新的ResponseEntity（新的ErrorResponse（400，例如getMessage（）），HttpStatus.OK）；
}
@ResponseStatus（HttpStatus.I\u AM\u A\u TEAPOT）//TODO:错误的请求
@ExceptionHandler（IllegalArgumentException.class）
公共响应验证错误（异常ex）{
LOG.error（例如getMessage（））；
返回新的ResponseEntity（新的ErrorResponse（400，例如getMessage（）），HttpStatus.OK）；
}
@ResponseStatus（HttpStatus.I\u AM\u A\u TEAPOT）//TODO:禁止
@ExceptionHandler（ReadOperationDeniedException.class）
禁止公众响应（例外情况除外）{
LOG.error（“用户没有修改员工详细信息的权限”）；
返回新的ResponseEntity（新的ErrorResponse（403，“用户没有修改员工详细信息的权限”），HttpStatus.OK；
}
@ResponseStatus（HttpStatus.I\u AM\u A\u TEAPOT）//TODO:内部\u服务器\u错误
@ExceptionHandler（Exception.class）
公共责任不具体错误（例外情况除外）{
LOG.error（“用户没有修改员工详细信息的权限”）；
returnnewresponseEntity（newerrorresponse（500，“编辑员工详细信息时出错”），HttpStatus.OK；
}

ControllerAdvice优于在同一控制器中定义异常处理程序。因为ExceptionHandler注释的方法仅对该特定控制器有效，而对整个应用程序无效。当然，将其添加到每个控制器中会使其不适合一般的异常处理机制。

    public ResponseEntity<?> updatePartnerDetails(@PathVariable("employeeId") Long employeeId,
                                                  @RequestBody PersonDetails partnerDto) {
        LOG.info("Updating partner details for employee {}, partner details {}", employeeId, partnerDto);
        validateRequestValues(partnerDto);
        // Try-catches were around this call
        Person partner = PersonMapper.fromPersonDetails(partnerDto);
        employeeService.updateEmployeePartner(employeeId, partner);
        LOG.info("partner details updated for partner id {}", employeeId);
        return new ResponseEntity<>(partner.getId(), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: BAD_REQUEST
    @ExceptionHandler({EmployeePartnerExistsException.class, EmployeePartnerNotFoundException.class})
    public ResponseEntity<?> employeePartnerError(Exception ex) {
        LOG.error(ex.getMessage());
        return new ResponseEntity<Object>(new ErrorResponse(400, ex.getMessage()), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: BAD_REQUEST
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<?> validationError(Exception ex) {
        LOG.error(ex.getMessage());
        return new ResponseEntity<Object>(new ErrorResponse(400, ex.getMessage()), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: FORBIDDEN
    @ExceptionHandler(ReadOperationDeniedException.class)
    public ResponseEntity<?> forbidden(Exception ex) {
        LOG.error("User doesn't have permissions to amend employee's details");
        return new ResponseEntity<Object>(new ErrorResponse(403, "User doesn't have permissions to amend employee's details"), HttpStatus.OK);
    }

    @ResponseStatus(HttpStatus.I_AM_A_TEAPOT)  // TODO: INTERNAL_SERVER_ERROR
    @ExceptionHandler(Exception.class)
    public ResponseEntity<?> unspecifiedError(Exception ex) {
        LOG.error("User doesn't have permissions to amend employee's details");
        return new ResponseEntity<Object>(new ErrorResponse(500, "Something went wrong while editing employee's details"), HttpStatus.OK);
    }