在springboot工程中实现统一功能的处理，主要分析以下3个统一功能场景：
1、统一用户登录权限验证
2、统一数据格式返回
3、统一异常处理

1、统一用户登录权限验证

用户登录权限验证从最初每个方法中自己验证用户登录权限，逐步发展到进行统一用户登录权限验证，是随着需求逐渐完善和优化的过程。下面对发展过程中典型阶段的实现回故一下。

1.1、最初用户登录权限验证

最初⽤户登录权限验证的实现⽅法如下

@RestController
@RequestMapping("/user")
public class UserController {
    /**
     * 端点 1
     */
    @RequestMapping("/hello1")
    public Object hello1(HttpServletRequest request) {
        // 有 session 就获取，没有不会创建
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
            // 说明已经登录，业务处理
            return true;
        } else {
            // 未登录
            return false;
        }
    }
    /**
     * 端点 2
     */
    @RequestMapping("/hello2")
    public Object hello2(HttpServletRequest request) {
        // 有 session 就获取，没有不会创建
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
            // 说明已经登录，业务处理
            return true;
        } else {
            // 未登录
            return false;
        }
    }
    
}

从上面可以看到，每个端点都有着相同的用户登录权限验证代码块，缺点是每个端点中都有单独写用户登录验证的代码，即使封装成公共方法，也一样要传参调用和在方法中进行判断。随着业务扩展，控制器Controller越多，调用用户登录权限验证的方法也越多，这样增加了后期的维护成本。

这些用户登录权限验证的方法和需要实现的业务几乎没有任何关联，但每个端点中都要写一遍。所以，出现了通过AOP切面的方式来进行统一的用户登录权限验证实现。

1.2、Spring AOP统一用户登录权限验证

通过AOP前置通知或环绕通知来实现统一用户登录权限验证，实现方法如下

@Aspect
@Component
public class UserAspect {
    // 定义切点⽅法 controller 包下、⼦孙包下所有类的所有⽅法
    @Pointcut("execution(* com.example.demo.controller..*.*(..))")
    public void pointcut(){ }
    // 前置⽅法
    @Before("pointcut()")
    public void doBefore(){
    }
    // 环绕⽅法
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        Object obj = null;
        System.out.println("Around ⽅法开始执⾏");
        try {
            // 执⾏拦截⽅法
            obj = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("Around ⽅法结束执⾏");
        return obj;
    }
}

从上面可以看到，通过AOP切面实现用户登录权限验证，出现两个问题，一是没办法获取到HttpSession对象，二是要对一部分方法进行拦截，而另一部分方法不拦截，过滤规则很难定义，这时考虑通过拦截器Interceptor实现。

1.3、Spring Interceptor统一用户登录权限验证

对于以上问题 Spring 中提供了具体的实现拦截器：HandlerInterceptor，拦截器的实现分为以下两个步骤：

创建⾃定义拦截器，实现 HandlerInterceptor 接⼝的 preHandle（执⾏具体⽅法之前的预处理）⽅法；
将⾃定义拦截器加⼊ WebMvcConfigurer 的 addInterceptors ⽅法中；

问：有小伙伴会问，是否可以通过过滤器Filter来实现统一用户登录权限验证呢？
答：过滤器是Web容器提供的，触发的时机比拦截器更靠前，Spring 初始化前就执行了，所以并不能处理用户登录权限验证问题。

通过拦截器Interceptor来实现统一用户登录权限验证，实现方法如下

控制器代码

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {
    @RequestMapping("/login")
    public boolean login(HttpServletRequest request,
                         String username, String password) {
        // 1.非空判断
        if (StringUtils.hasLength(username) && StringUtils.hasLength(password)) {
            // 2.验证用户名和密码是否正确
            if ("admin".equals(username) && "admin".equals(password)) {
                // 登录成功
                HttpSession session = request.getSession();
                session.setAttribute("userinfo", "admin");
                return true;
            } else {
                // 用户名或密码输入错误
                return false;
            }
        }
        return false;
    }
    
}

自定义拦截器

@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 登录判断业务
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
            return true;
        }
        log.error("当前用户没有访问权限");
        response.setStatus(401);
        return false;
    }
}

从上面可以看到，若为false则不能继续往下执行，为true则可以。

系统配置类

@Configuration 
public class MyConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login") // 排除不拦截的 url
                .excludePathPatterns("/**/*.html")
                .excludePathPatterns("/**/*.js")
                .excludePathPatterns("/**/*.css"); // 排除不拦截的 url
    }
}

或者

@Configuration
public class MyConfig implements WebMvcConfigurer {
    // 不拦截的 url 集合
    List<String> excludes = new ArrayList<String>() {{
        add("/**/*.html");
        add("/js/**");
        add("/css/**");
        add("/img/**"); // 放行 static/img 下的所有文件
        add("/user/login"); // 放行登录接口
    }};
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 配置拦截器
        InterceptorRegistration registration =
                registry.addInterceptor(loginInterceptor);
        registration.addPathPatterns("/**");
        registration.excludePathPatterns(excludes);
    }
}

或者

@Configuration 
public class MyConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login") // 排除不拦截的 url
                .excludePathPatterns("/**/*.html")
                .excludePathPatterns("/**/*.js")
                .excludePathPatterns("/**/*.css"); // 排除不拦截的 url
    }
}

其中：
addPathPatterns：表示需要拦截的 URL，“**”表示拦截任意⽅法（也就是所有⽅法）。
excludePathPatterns：表示需要排除的 URL。
说明：以上拦截规则可以拦截此项⽬中的使⽤ URL，包括静态⽂件 (图⽚⽂件、JS 和 CSS 等⽂件)。
引入了拦截器之后，会在调⽤ Controller 之前进⾏相应的业务处理，因为所有的 Controller 执⾏都会通过⼀个调度器 DispatcherServlet 来实现，⽽所有⽅法都会执⾏ DispatcherServlet 中的 doDispatch 调度⽅法，在doDispatch 方法中会先调⽤预处理⽅法applyPreHandle，在applyPreHandle 方法中会获取所有的拦截器HandlerInterceptor 并执⾏拦截器中的 preHandle ⽅法。

2、统一数据格式返回

统⼀数据返回格式的优点有很多，比如以下几个：

⽅便前端程序员更好的接收和解析后端数据接⼝返回的数据；
降低前端程序员和后端程序员的沟通成本，按照某个格式实现就⾏了，因为所有接⼝都是统一格式返回的；
有利于项⽬统⼀数据的维护和修改；
有利于后端技术部⻔统⼀规范的标准制定，不会出现稀奇古怪的返回内容；

统⼀的数据返回格式可以使用 @ControllerAdvice + ResponseBodyAdvice接口的方式实现，具体如下

@RestController
@RequestMapping
public class HelloController {

    @RequestMapping("/hello")
    public Object hello() {
        return "hello";
    }

    @RequestMapping("/hello2")
    public Map hello2() {
        HashMap<String, Object> result = new HashMap<>();
        result.put("data", "hello2");
        return result;
    }
}

@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
    /**
     * 内容是否需要重写（通过此⽅法可以选择性部分控制器和⽅法进⾏重写）
     * 返回 true 表示重写
     */
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;
    }
    /**
     * ⽅法返回之前调⽤此⽅法
     */
    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                  MediaType selectedContentType,
                                  Class selectedConverterType,
                                  ServerHttpRequest request,
                                  ServerHttpResponse response) {
        // 构造统⼀返回对象
        HashMap<String, Object> result = new HashMap<>();
        result.put("state", 1);
        result.put("msg", "");
        result.put("data", body);
        if (body instanceof String) { // 返回类型是 String（特殊）
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.writeValueAsString(result);
        }
        return result;
    }
}

统一处理后，此时所有返回的都是 json 格式的数据了，结果类似如下
在这里插入图片描述

实际开发中，通常我们会写一个统一封装的类，返回时统一返回这个类 (软性约束)，如下

public class AjaxResult {
    /**
     * 业务执行成功时进行返回的方法
     *
     * @param data
     * @return
     */
    public static HashMap<String, Object> success(Object data) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", 200);
        result.put("msg", "");
        result.put("data", data);
        return result;
    }
    /**
     * 业务执行成功时进行返回的方法
     *
     * @param data
     * @return
     */
    public static HashMap<String, Object> success(String msg, Object data) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", 200);
        result.put("msg", msg);
        result.put("data", data);
        return result;
    }
    /**
     * 业务执行失败返回的数据格式
     *
     * @param code
     * @param msg
     * @return
     */
    public static HashMap<String, Object> fail(int code, String msg) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", code);
        result.put("msg", msg);
        result.put("data", "");
        return result;
    }
    /**
     * 业务执行失败返回的数据格式
     *
     * @param code
     * @param msg
     * @return
     */
    public static HashMap<String, Object> fail(int code, String msg, Object data) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", code);
        result.put("msg", msg);
        result.put("data", data);
        return result;
    }
}

@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
    /**
     * 内容是否需要重写（通过此⽅法可以选择性部分控制器和⽅法进⾏重写）
     * 返回 true 表示重写
     */
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;
    }
    /**
     * ⽅法返回之前调⽤此⽅法
     */
    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                  MediaType selectedContentType,
                                  Class selectedConverterType,
                                  ServerHttpRequest request,
                                  ServerHttpResponse response) {
        // 构造统⼀返回对象
//        HashMap<String, Object> result = new HashMap<>();
//        result.put("state", 1);
//        result.put("msg", "");
//        result.put("data", body);
//        if (body instanceof String) { // 返回类型是 String（特殊）
//            ObjectMapper objectMapper = new ObjectMapper();
//            return objectMapper.writeValueAsString(result);
//        }
//        return result;

        if (body instanceof HashMap) { // 本身已经是封装好的对象
            return body;
        }
        if (body instanceof String) { // 返回类型是 String（特殊）
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.writeValueAsString(AjaxResult.success(body));
        }
        return AjaxResult.success(body);
    }
}

@RestController
@RequestMapping
public class HelloController {

    @RequestMapping("/hello")
    public Object hello() {
        return "hello";
    }

    @RequestMapping("/hello2")
    public Map hello2() {
        HashMap<String, Object> result = new HashMap<>();
        result.put("data", "hello2");
        return result;
    }

    @RequestMapping("/hello3")
    public Object hello3() {
        return AjaxResult.success("hello3");
    }
}

测试结果类似如下
在这里插入图片描述

3、统一异常处理

统⼀异常处理使⽤的是 @ControllerAdvice + @ExceptionHandler 来实现的，@ControllerAdvice 表示控制器通知类，@ExceptionHandler 是异常处理器，两个结合表示当出现异常的时候执⾏某个通知，也就是执⾏某个⽅法事件，具体实现代码如下：

@ControllerAdvice
public class ErrorAdive {
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public HashMap<String, Object> exceptionAdvie(Exception e) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", "-1");
        result.put("msg", e.getMessage());
        return result;
    }
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public HashMap<String, Object> arithmeticAdvie(ArithmeticException e) {
        HashMap<String, Object> result = new HashMap<>();
        result.put("code", "-2");
        result.put("msg", e.getMessage());
        return result;
    }
}

其中，方法名和返回值可以⾃定义。
从上面可以看到，如果出现了异常就返回给前端⼀个 HashMap 的对象，其中包含的字段如代码中定义的那样。
此时若出现异常就不会报错了，代码会继续执行，但是会把自定义的异常信息返回给前端。
统一数据返回格式，实现如下

@ControllerAdvice
@ResponseBody
public class ExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public Object exceptionAdvice(Exception e) {
        return AjaxResult.fail(-1, e.getMessage());
    }
    
}

其中，统一异常处理不用配置路径，是拦截整个项目中的所有异常。