proyecto de optimización SpringBoot- en el manejo de excepciones

1.0 ¿Por qué es necesaria una excepción

Sobre excepción de Java, puede hacer referencia a antes de escribir un blog Fundamentos de Java (8) - el uso de anormalidades y proyectos de sistemas , algunos de los cuales hace referencia a un pensamiento anormal y cómo utilizar excepciones.

¿Por qué lo necesitamos anormal?

Creo que podemos pensar desde tres ángulos diferentes.

1. desarrolladores de back-end: hacen que los desarrolladores de back-end a localizar rápidamente el origen del problema por la tala en el programa, y ​​para resolver los problemas.
2. desarrollador front-end: Dependiendo del tipo de excepción, hacer el show estilo apropiado
3. Usuario: er er? ? Los usuarios no entienden la tecnología, no es necesario saber qué tipo de excepción es sólo texto o indicaciones gráficas.

Por ejemplo, RDCC subir archivos de error de una red rápida, mi lado de la red no tendrá ningún problema, pero es un error del servidor ocupado o interno, por lo que tiramos a la identidad de red equivocada.

Manipulación 1.1 1.0 Excepción

Por lo tanto, a lo largo anormal entre la parte trasera y front-end, back-end se produce una excepción, las necesidades delanteras para mostrar diferentes páginas presentadas al usuario en base a una excepción, esta es la forma más básica de manejo de excepciones:

1.2 Gestión de excepciones 2,0

En 1.0 modo, esencialmente por extremo distal anormal de la captura y la conversión, pero ya generada por el backend anormal, entonces el enfoque más correcta es para ser manejado por el extremo trasero, que se extrae a cabo algunas de las formas en que el manejo de excepciones . El método actual es utilizar código de estado de implementación simple en lugar de la excepción:

La excepción al extremo posterior de la capturada y transformada en un código de estado anormal, que corresponde a la preparación de los extremos frontal de acuerdo con el código de estado de la pantalla:

La ventaja de esto es:

1. Hacer un control de excepciones de fondo, información específica no se hizo para exponer anomalías, más seguro
2. El extremo frontal sólo puede basarse en el back-end de la correspondiente designación de salto de página al código de estado, sin la necesidad de excepciones adicionales proceso, sólo se manejan adecuadamente cada extremo de cada lado de la lógica se puede lograr el objetivo de la cohesión alta, baja acoplamiento.

1.3 Excepción Manejo de una primera forma de realización

La primera manera es muy simple y crudo, donde sólo posibles anomalías en la capa de servicio lanzan una excepción, entonces capturado y procesado en la capa del controlador, que es inusual para un pequeño número de casos:

Más adelante en conjunción con un módulo de mensaje de plantilla para tocar sobre el uso de manejo de excepciones, que es un SpringBoot proyecto / SSM, el proceso de pensamiento es una excepción lanzada en la capa de servicio, y la capa a unificarse en la captura anormal controlador y el procesamiento:

• ArgsLoseException

/**
 * @Auther: ARong
 * @Description: 参数缺失异常
 **/
public class ArgsLoseException extends Exception {
    public ArgsLoseException(){}
    public ArgsLoseException(String message){super(message);}
}

• ArgsErrorException

/**
 * @Auther: ARong
 * @Description: 参数错误异常
 **/
public class ArgsErrorException extends Exception {
    public ArgsErrorException() {}
    public ArgsErrorException(String messasge) {super(messasge);}
}

• TemplateMessageSerivceImp

/**
 * @Auther: ARong
 * @Description: 发送模板消息
 **/
@Service
@Transactional
@Slf4j
public class TemplateMessageSerivceImp implements TemplateMessageSerivce {
    @Autowired
    private MessageUtil messageUtil;
/**
     * @param messageEntity
     * @param opeType
     * @auther: Arong
     * @description: 注册成功后发送
     * @param: [messageEntity]
     * @return: AjaxResult
     */
    @Override
    public AjaxResult sendMessage(MessageEntity messageEntity, String opeType) throws ArgsLoseException, ArgsErrorException { 
        Map map = MessageUtil.MessageMap(
                messageEntity.getOpenId(),
                messageEntity.getPage(),
                messageEntity.getFormId()
        );

        if (opeType == null || "".equals(opeType.trim())) {
            throw new ArgsLoseException("opeType参数缺失");
        }

        if (!"YES".equals(opeType)) {
            throw new ArgsErrorException("opeType参数错误");
        }

        //...业务逻辑
        return null;
    }
  }

En este punto nos centramos en, capa del controlador debe ser cómo manejar estas excepciones hacen?

En primer lugar, tenemos que tener en cuenta que una excepción no se debe permitir estar directamente expuesto a los ojos del usuario, sino más bien a un estado anormal en una especie de código de front-end, de modo que la parte delantera para hacer el tratamiento adecuado, por ejemplo, para pedir al usuario que funciona aplicando el código de estado está mal , o que los retrasos en la red, etc., en una palabra de enfoque convenciones de código de estado y los extremos delantero y trasero en una condición de anormalidad en los ojos del usuario:

• TemplateMessageController

@Controller
@CrossOrigin
@RequestMapping(value = "/message")
@ResponseBody
@Slf4j
public class TemplateMessageController {
    @Autowired
    private TemplateMessageSerivce templateMessageSerivce;

    /**
     * @auther: Arong
     * @description: 注册成功后发送
     * @param: [messageEntity]
     * @return: AjaxResult
     */
    @PostMapping(value = "/sendMessage")
    public AjaxResult sendMessage(
            @ModelAttribute MessageEntity messageEntity,
            @RequestParam(name = "opeType") String opeType //操作类型
    ) {
        AjaxResult ajaxResult = null;
        try {
            ajaxResult = templateMessageSerivce.sendMessage(messageEntity, opeType);
        } catch (Exception e) {
            //打印异常栈堆路径
            e.printStackTrace();
            //分不同异常给前端返回不同的状态码(不要将异常暴露给前端,而是通过状态码让前端去反应)
            if (e instanceof ArgsLoseException) {
            	//回传状态码501
                return new AjaxResult(501, "传入opeType为空");
            } else if (e instanceof ArgsErrorException) {
            	//回传状态码502
                return new AjaxResult(502, "参数错误");
            }
        }
        return ajaxResult;
    }，
}

Esta manipulación de una manera personalizada para tratar con muy pocas excepciones excepción cuando ha sido lo suficientemente bueno, pero a medida que más y más excepción personalizada, entonces usted necesita para hacer frente a la más anormales del controlador de la siguiente manera:

			if (e instanceof ArgsLoseException) {
            	//回传状态码501
                return new AjaxResult(501, "传入opeType为空");
            } else if (e instanceof ArgsErrorException) {
            	//回传状态码502
                return new AjaxResult(502, "参数错误");
            } else if (e instanceof Xx1Exception) {
            	//...
			} else if (e instanceof Xx2Exception) {
            	//...
			} else if (e instanceof Xx3Exception) {
            	//...
			}

Así, la próxima necesidad de optimizar el manejo de excepciones camino

1.4 Gestión de excepciones La segunda manera - manejador de excepción mundial

Con el fin de optimizar el manejo de los problemas más si excesiva excepción se ha descrito anteriormente, e incorporada aquí SpringBoot mundial manejo de excepciones, código de manejo de excepción se simplifica, el siguiente es un programa Demo, no relacionado con módulo de servicio específico, es sólo a modo de ejemplo:

• Resultados de retorno AjaxResult

/**
 * @Auther: ARong
 * @Description: 处理结果
 */
@Data
public class AjaxResult {
    public AjaxResult() {
    }

    public AjaxResult(int code, String message) {
        this.code = code;
        this.message = message;
    }

    private int code;
    private String message;
}

• GlobalException excepción global, la clase interna dentro de definir una excepción personalizada

/**
 * @Auther: ARong
 * @Description: 全局异常定义
 */
public class GlobalException {
    /*
     * @Author ARong
     * @Description 参数缺少异常
     **/
    @Data
    public static class ArgsLoseException extends RuntimeException{
        private int code = 501;
        private String message;

        public ArgsLoseException(String message) {
            this.message = message;
        }
    }

    /*
     * @Author ARong
     * @Description 参数错误异常
     **/
    @Data
    public static class ArgsErrorException extends RuntimeException{
        private int code = 502;
        private String message;

        public ArgsErrorException(String message) {
            this.message = message;
        }
    }
}

• GlobalExceptionHandler
  uso @ControllerAdvice y @ExceptionHandler lograr gestor de excepciones mundial

/**
 * @Auther: ARong
 * @Description: 全局异常处理器
 */
@ControllerAdvice
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {

    /*
     * @Author ARong
     * @Description 捕捉异常并进行处理
     * @Param
     * @return
     **/
    @ExceptionHandler(value = Exception.class)
    public AjaxResult exceptionHandler(Exception e) {
        // 打印异常调用栈
        e.printStackTrace();
        AjaxResult result = new AjaxResult();

        int code = 500;
        String message = "服务器出现错误";

        // 如果是自定义异常则进行转化
        if (e instanceof GlobalException.ArgsErrorException) {
            // 参数错误异常
             code = ((GlobalException.ArgsErrorException) e).getCode();
             message = ((GlobalException.ArgsErrorException) e).getMessage();
        }
        if (e instanceof GlobalException.ArgsLoseException) {
            // 参数缺失异常
            code = ((GlobalException.ArgsLoseException) e).getCode();
            message = ((GlobalException.ArgsLoseException) e).getMessage();
        }

        result.setCode(code);
        result.setMessage(message);
        return result;
    }
}

• capa de control de DemoController

/**
 * @Auther: ARong
 * @Description: 控制层
 */
@Controller
@ResponseBody
public class DemoController {
    @Autowired
    private DemoService demoService;

    @RequestMapping(value = "/get")
    public AjaxResult get(
            @RequestParam(name = "id") String id
    ) {
        AjaxResult result = demoService.get(id);
        return result;
    }
}

• capa de negocio DemoService

/**
 * @Auther: ARong
 * @Description: 业务层
 */
@Service
public class DemoService {
    public AjaxResult get(String id) {
        if ("bug".equals(id)) {
            // 参数错误
            throw new GlobalException.ArgsErrorException("参数错误");
        }
        if ("null".equals(id)) {
            // 参数缺失
            throw new GlobalException.ArgsLoseException("参数缺失");
        }
        return new AjaxResult(200, "OK");
    }
}

Después de configurar un controlador global de excepción, una capa Controller en una necesidad de capturar y procesar la excepción personalizada, y el procesador para hacer todo el procesamiento que corresponde a, y devolver un código de estado. Iniciar el proyecto, mediante la prueba del cartero simple:

1. normalmente

2. Disparador excepción error de parámetro
   

3. parámetros anormales de activación faltan
   

Después de los pasos anteriores, se puede lograr un manejador de excepción mundial básica, que se simplifica en gran medida y la capa del controlador de cantidad de código menos redundante, para mejorar la legibilidad del programa, el resto de la cosa más importante es cómo el acuerdo debe indicar código cómo hacer el front-end y salto.

Gracias

https://blog.csdn.net/Colton_Null/article/details/84592748