springboot---拦截器__HandlerInterceptor

拦截器__HandlerInterceptor

在有些时候，需要拦截一些接口进行业务和权限的判断，所以需要一个拦截器对每次请求进行过滤和拦截。

1、首先建立一个类继承接口HandlerInterceptor 。

package cn.springboot.yzpt.Interceptor;

import cn.springboot.yzpt.common.CodeEnums;
import cn.springboot.yzpt.exception.YzptException;
import cn.springboot.yzpt.utils.CommonUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.Set;

public class LoginInterceptor implements HandlerInterceptor {

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

    private Set<String> restList;

    public LoginInterceptor(Set<String> restList) {
        this.restList = restList;
    }


    /**
     * 在请求被处理之前调用
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        Map<String,String> map = CommonUtils.getIpAddr(request);
        if (restList.contains(map.get("uri"))) {
            logger.info(map.get("uri")+"是白名单");
            return true;
        }

        // 检查每个到来的请求对应的session域中是否有登录标识
        Object loginName = request.getSession().getAttribute("loginName");
        if (null == loginName || !(loginName instanceof String)) {
            // 未登录，重定向到登录页
            throw new YzptException(CodeEnums.USER_TOKEN_FAIL);
        }
        String userName = (String) loginName;
        System.out.println("当前用户已登录，登录的用户名为： " + userName);
        return true;
    }


    /**
     * 在请求被处理后，视图渲染之前调用
     *
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    /**
     * 在整个请求结束后调用
     *
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

2、之后注册这个拦截器，进行拦截。

package cn.springboot.yzpt.config;

import cn.springboot.yzpt.Interceptor.LoginInterceptor;
import cn.springboot.yzpt.config.restAuth.AuthConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 拦截器的配置选项
 */
@Configuration
public class LoginConfiguration implements WebMvcConfigurer {

    @Autowired
    private AuthConfig authConfig;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        // 注册拦截器
        LoginInterceptor loginInterceptor = new LoginInterceptor(authConfig.getRestList());
        InterceptorRegistration loginRegistry = registry.addInterceptor(loginInterceptor);
        // 拦截路径
        loginRegistry.addPathPatterns("/**");
    }
}