阅读 2614

后端框架开发需要注意的几点

后端框架开发需要注意的几点

笔者文笔功力尚浅,如有不妥,请慷慨指出,必定感激不尽

跌跌撞撞了在程序员的道路上也有一年的时间了,慢慢的觉得这一年的工作大部分时间都是在简单的CRUD中度过,而有时候我们在CRUD中有多少重复性的代码呢?有些代码我们每次写都需要重复性的写一次,不仅浪费时间,而且对于自己提升并没有多大的提高。无意中看到了程序员你为什么这么累文章后,才幡然醒悟,为什么我们工作这么久了不把一些公共部分抽取出来,减少了代码量才能让我们更加专注于技术或者业务的提升不是吗?

结合着上面提到的文章中所描述的问题,并且又结合最近一年我的一些遭遇,于是在后端框架开发中能够抽取出来的公共部分有以下部分

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

自定义枚举类

对于一些我们经常返回的错误信息,我们可以将其抽取出来封装成公共部分,然后将变化的作为参数传入。例如我们在业务中经常要校验某个字段是否为空,如果为空的话就要返回错误信息xxx字段不能为空,那么我们为什么不将xxx作为一个变量参数传递过来呢。于是就想到了用枚举类定义异常信息,然后用String.format()方法进行转义

 1public enum ResponseInfoEnum {
2
3    SUCCESS(ResponseResult.OK,"处理成功"),
4    PARAM_LENGTH_ERROR(ResponseResult.ERROR, "参数:%s,长度错误,max length: %s"),
5    REQ_PARAM_ERROR(ResponseResult.ERROR, "请求报文必填参数%s缺失"),;
6
7    private Integer code;
8    private String message;
9
10    ResponseInfoEnum(Integer code, String message) {
11        this.code = code;
12        this.message = message;
13    }
14
15    public Integer getCode() {
16        return code;
17    }
18
19    public String getMessage() {
20        return message;
21    }
22
23}
复制代码

使用方法如下

1String.format(ResponseInfoEnum.REQ_PARAM_ERROR.getMessage(),"testValue")
复制代码

可以看到生成的错误信息是请求报文必填参数testValue缺失

自定义异常信息

首先我们需要知道我们为什么要用自定义异常信息呢?使用它有什么好处呢?

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

自定义异常我们需要继承RuntimeException

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

统一返回信息

在我刚开始工作的一年中,所接触的最多的项目就是前后端交互的项目了。所以有一个统一的返回信息不仅对前端来说更加便利,对于我们后面的AOP代理也有很大的好处。

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

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

全局异常处理

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

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

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

统一日志打印

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

 1@Slf4j
2@Aspect
3@Component
4public class ControllerLog {
5
6    private static final ThreadLocal<Long> START_TIME_THREAD_LOCAL =
7            new NamedThreadLocal<>("ThreadLocal StartTime");
8
9    private static final ThreadLocal<String> LOG_PREFIX_THREAD_LOCAL =
10            new NamedThreadLocal<>("ThreadLocal LogPrefix");
11
12    /**
13     * <li>Before       : 在方法执行前进行切面</li>
14     * <li>execution    : 定义切面表达式</li>
15     * <p>public * com.example.javadevelopmentframework.javadevelopmentframework.controller..*.*(..))
16     *      <li>public :匹配所有目标类的public方法,不写则匹配所有访问权限</li>
17     *      <li>第一个* :方法返回值类型,*代表所有类型 </li>
18     *      <li>第二个* :包路径的通配符</li>
19     *      <li>第三个..* :表示impl这个目录下所有的类,包括子目录的类</li>
20     *      <li>第四个*(..) : *表示所有任意方法名,..表示任意参数</li>
21     * </p>
22     * @param
23     */

24    @Pointcut("execution(public * com.example.javadevelopmentframework.javadevelopmentframework.controller..*.*(..))")
25    public void exectionMethod(){}
26
27
28    @Before("exectionMethod()")
29    public void doBefore(JoinPoint joinPoint){
30        START_TIME_THREAD_LOCAL.set(System.currentTimeMillis());
31        StringBuilder argsDes = new StringBuilder();
32        //获取类名
33        String className = joinPoint.getSignature().getDeclaringType().getSimpleName();
34        //获取方法名
35        String methodName = joinPoint.getSignature().getName();
36        //获取传入目标方法的参数
37        Object[] args = joinPoint.getArgs();
38        for (int i = 0; i < args.length; i++) {
39            argsDes.append("第" + (i + 1) + "个参数为:" + args[i]+"\n");
40        }
41        String logPrefix = className+"."+methodName;
42        LOG_PREFIX_THREAD_LOCAL.set(logPrefix);
43        log.info(logPrefix+"Begin 入参为:{}",argsDes.toString());
44    }
45
46    @AfterReturning(pointcut="exectionMethod()",returning = "rtn")
47    public Object doAfter(Object rtn){
48        long endTime = System.currentTimeMillis();
49        long begin = START_TIME_THREAD_LOCAL.get();
50        log.info(LOG_PREFIX_THREAD_LOCAL.get()+"End 出参为:{},耗时:{}",rtn,endTime-begin);
51        destoryThreadLocal();
52        return rtn;
53    }
54
55    public static String getLogPrefix(){
56        return LOG_PREFIX_THREAD_LOCAL.get();
57    }
58
59    public static void destoryThreadLocal(){
60        START_TIME_THREAD_LOCAL.remove();
61        LOG_PREFIX_THREAD_LOCAL.remove();
62    }
63
64}
复制代码

测试

我们在Conroller中写如下测试

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

单元测试中代码如下

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

可以看到打印如下

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

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

完整代码

总结

在编写代码过程中我们也需要不断的总结,无论是需求的变更还是系统的搭建,我们都需要考虑哪一部分是变化的哪一部分是不变的,将不变的抽取出来,变化的封装起来。这样在以后无论是系统扩展还是需求变更中我们都能够以最小的代价来完成任务。