异常 日志
在后端框架开发中能够抽取出来的公共部分有以下部分

  • 自定义枚举类
  • 自定义异常信息
  • 统一返回信息
  • 全局异常处理
  • 统一日志打印

    自定义枚举类

    对于一些经常返回的错误信息，可以将其抽取出来封装成公共部分，然后将变化的作为参数传入。例如在业务中经常要校验某个字段是否为空，如果为空的话就要返回错误信息xxx字段不能为空，那么为什么不将xxx作为一个变量参数传递过来呢。于是就想到了用枚举类定义异常信息，然后用String.format()方法进行转义
    1. public enum ResponseInfoEnum {
    2.   SUCCESS(ResponseResult.OK,"处理成功"),
    3.   PARAM_LENGTH_ERROR(ResponseResult.ERROR, "参数:%s,长度错误，max length: %s"),
    4.   REQ_PARAM_ERROR(ResponseResult.ERROR, "请求报文必填参数%s缺失"),;
    5.   private Integer code;
    6.   private String message;
    7.   ResponseInfoEnum(Integer code, String message) {
    8.       this.code = code;
    9.       this.message = message;
    10.   }
    11.   public Integer getCode() {
    12.       return code;
    13.   }
    14.   public String getMessage() {
    15.       return message;
    16.   }
    17. }
    使用方法如下
    1. String.format(ResponseInfoEnum.REQ_PARAM_ERROR.getMessage(),"testValue")
    可以看到生成的错误信息是请求报文必填参数testValue缺失

    自定义异常信息

    首先需要知道为什么要用自定义异常信息呢？使用它有什么好处呢？
  1. 首先开发中肯定是分模块进行开发的，所以首先统一了自定义异常类就统一了对外异常的展示方式。
  2. 使用自定义异常继承相关的异常来抛出处理后的异常信息可以隐藏底层的异常，这样更安全，异常信息也更加的直观。自定义异常可以抛出自己想要抛出的信息，可以通过抛出的信息区分异常发生的位置，根据异常名就可以知道哪里有异常，根据异常提示信息进行程序修改。
  3. 有时候遇到某些校验或者问题时，需要直接结束掉当前的请求，这时便可以通过抛出自定义异常来结束，如果项目中使用了SpringMVC比较新的版本的话有控制器增强，可以通过@ControllerAdvice注解写一个控制器增强类来拦截自定义的异常并响应给前端相应的信息。

    自定义异常需要继承RuntimeException

  1. public class CheckException extends RuntimeException{
  2.     public CheckException() {
  3.     }
  4.     public CheckException(String message) {
  5.         super(message);
  6.     }
  7.     public CheckException(ResponseInfoEnum responseInfoEnum,String ...strings) {
  8.         super(String.format(responseInfoEnum.getMessage(),strings));
  9.     }
  10. }

统一返回信息

接触的最多的项目就是前后端交互的项目了。所以有一个统一的返回信息不仅对前端来说更加便利，对于后面的AOP代理也有很大的好处。

  1. @Data
  2. @NoArgsConstructor
  3. public class ResponseResult<T> {
  4.     public static final Integer OK = 0;
  5.     public static final Integer ERROR = 100;
  6.     private Integer code;
  7.     private String message;
  8.     private T data;
  9. }

这样前后端进行交互时就会更加便利了，如果要取业务数据那么就从data中取，去过要取是否成功的标志，那么就从code码中取，如果要取后端返回的信息，那么就从message中取。

全局异常处理

在之前的项目中每个Controller方法中都充斥着try....catch...的代码，而catch后的代码都是大同小异，都是封装了一下返回的错误信息之类的。那么为什么不将这些代码抽取出来，利用Spring的全局异常处理简化代码。

  1. @Slf4j
  2. @ControllerAdvice
  3. public class ControllerExceptionHandler {
  4.     @ExceptionHandler(value = Exception.class)
  5.     @ResponseBody
  6.     public ResponseResult<String> defaultErrorHandler(HttpServletRequest request, Exception exception){
  7.         log.error(ControllerLog.getLogPrefix()+"Exception: {}"+exception);
  8.         return handleErrorInfo(exception.getMessage());
  9.     }
  10.     @ExceptionHandler(CheckException.class)
  11.     @ResponseBody
  12.     public ResponseResult<String> checkExceptionHandler(HttpServletRequest request, CheckException exception){
  13.         return handleErrorInfo(exception.getMessage());
  14.     }
  15.     private ResponseResult<String> handleErrorInfo(String message) {
  16.         ResponseResult<String> responseEntity = new ResponseResult<>();
  17.         responseEntity.setMessage(message);
  18.         responseEntity.setCode(ResponseResult.ERROR);
  19.         responseEntity.setData(message);
  20.         ControllerLog.destoryThreadLocal();
  21.         return responseEntity;
  22.     }
  23. }

其中全局异常处理中，自定义的异常就没有打印日志，因为对于自定义的异常是已知的异常，并且错误信息也已经很明确的返回了。而对于未知异常例如Exception就属于未知的异常，就需要打印日志，如果这里有特殊需求，例如发短信、发邮件通知相关人员的话，这里也能够进行全局的配置。

统一日志打印

统一日志打印只是将项目中公共的打印日志抽取出来，利用AOP来进行打印，例如项目中基本上每个Controller方法的入参和出参都会打印，所以就将此部分抽取出来进行统一管理。

  1. @Slf4j
  2. @Aspect
  3. @Component
  4. public class ControllerLog {
  5.     private static final ThreadLocal<Long> START_TIME_THREAD_LOCAL =
  6.             new NamedThreadLocal<>("ThreadLocal StartTime");
  7.     private static final ThreadLocal<String> LOG_PREFIX_THREAD_LOCAL =
  8.             new NamedThreadLocal<>("ThreadLocal LogPrefix");
  9.     /**
  10.      * <li>Before       : 在方法执行前进行切面</li>
  11.      * <li>execution    : 定义切面表达式</li>
  12.      * <p>public * com.example.javadevelopmentframework.javadevelopmentframework.controller..*.*(..))
  13.      *      <li>public :匹配所有目标类的public方法，不写则匹配所有访问权限</li>
  14.      *      <li>第一个* :方法返回值类型，*代表所有类型 </li>
  15.      *      <li>第二个* :包路径的通配符</li>
  16.      *      <li>第三个..* :表示impl这个目录下所有的类，包括子目录的类</li>
  17.      *      <li>第四个*(..) : *表示所有任意方法名,..表示任意参数</li>
  18.      * </p>
  19.      * @param
  20.      */
  21.     @Pointcut("execution(public * com.example.javadevelopmentframework.javadevelopmentframework.controller..*.*(..))")
  22.     public void exectionMethod(){}
  23.     @Before("exectionMethod()")
  24.     public void doBefore(JoinPoint joinPoint){
  25.         START_TIME_THREAD_LOCAL.set(System.currentTimeMillis());
  26.         StringBuilder argsDes = new StringBuilder();
  27.         //获取类名
  28.         String className = joinPoint.getSignature().getDeclaringType().getSimpleName();
  29.         //获取方法名
  30.         String methodName = joinPoint.getSignature().getName();
  31.         //获取传入目标方法的参数
  32.         Object[] args = joinPoint.getArgs();
  33.         for (int i = 0; i < args.length; i++) {
  34.             argsDes.append("第" + (i + 1) + "个参数为:" + args[i]+"\n");
  35.         }
  36.         String logPrefix = className+"."+methodName;
  37.         LOG_PREFIX_THREAD_LOCAL.set(logPrefix);
  38.         log.info(logPrefix+"Begin 入参为:{}",argsDes.toString());
  39.     }
  40.     @AfterReturning(pointcut="exectionMethod()",returning = "rtn")
  41.     public Object doAfter(Object rtn){
  42.         long endTime = System.currentTimeMillis();
  43.         long begin = START_TIME_THREAD_LOCAL.get();
  44.         log.info(LOG_PREFIX_THREAD_LOCAL.get()+"End 出参为:{},耗时:{}",rtn,endTime-begin);
  45.         destoryThreadLocal();
  46.         return rtn;
  47.     }
  48.     public static String getLogPrefix(){
  49.         return LOG_PREFIX_THREAD_LOCAL.get();
  50.     }
  51.     public static void destoryThreadLocal(){
  52.         START_TIME_THREAD_LOCAL.remove();
  53.         LOG_PREFIX_THREAD_LOCAL.remove();
  54.     }
  55. }

测试

在Conroller中写如下测试

  1. @RestController
  2. public class TestFrameworkController {
  3.     @RequestMapping("/success/{value}")
  4.     public String success(@PathVariable String value){
  5.         return "Return "+value;
  6.     }
  7.     @RequestMapping("/error/{value}")
  8.     public String error(@PathVariable String value){
  9.         int i = 10/0;
  10.         return "Return "+value;
  11.     }
  12. }

单元测试中代码如下

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @SpringBootTest(classes = JavadevelopmentframeworkApplication.class)
  3. @AutoConfigureMockMvc
  4. public class JavadevelopmentframeworkApplicationTests {
  5.     @Autowired
  6.     private MockMvc mockMvc;
  7.     @Test
  8.     public void success() throws Exception {
  9.         mockMvc.perform(get("/success/11"));
  10.         mockMvc.perform(get("/error/11"));
  11.     }
  12. }

可以看到打印如下

  1. 2019-09-03 20:38:22.248  INFO 73902 --- [           main] c.e.j.j.aop.ControllerLog                : TestFrameworkController.successBegin 入参为:第1个参数为:11
  2. 2019-09-03 20:38:22.257  INFO 73902 --- [           main] c.e.j.j.aop.ControllerLog                : TestFrameworkController.successEnd 出参为:Return 11,耗时:10
  3. 2019-09-03 20:38:22.286  INFO 73902 --- [           main] c.e.j.j.aop.ControllerLog                : TestFrameworkController.errorBegin 入参为:第1个参数为:11
  4. 2019-09-03 20:38:22.288 ERROR 73902 --- [           main] c.e.j.j.aop.ControllerExceptionHandler   : TestFrameworkController.errorException: {}java.lang.ArithmeticException: / by zero

可以看到每个访问Controller的方法入参、出参、整个方法的执行时间都已经打印出来了。另外在第二个测试的方法中异常信息捕捉到并打印日志了。