自定义拦截器处理作用在Controller方法上的自定义注解

TTc_

已于 2024-03-25 15:33:22 修改

阅读量205

点赞数 3

文章标签： java 开发语言

于 2024-03-25 10:59:59 首次发布

本文链接：https://blog.csdn.net/weixin_53618357/article/details/137007505

版权

1.创建AccessLimitInterceptor类实现HandlerInterceptor接口

2.实现preHandle()方法，写入自己的拦截处理逻辑

3.处理接口上的自定义防刷注解

具体实现代码如下：

1.自定义注解

package com.hspedu.seckill.config;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author TTc
 * @version 1.0
 * 自定义注解 AccessLimit
 * @date 2024/3/25 10:10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AccessLimit {
    int second();
    int maxCount();
    boolean needLogin() default true;
}

2.注册拦截器

package com.hspedu.seckill.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author TTc
 * @version 1.0
 * @date 2024/3/18 9:16
 */
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private UserArgumentResolver userArgumentResolver;
    @Resource
    private AccessLimitInterceptor accessLimitInterceptor;
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(accessLimitInterceptor);
    }
    // 静态资源加载
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
    }
    // 将我们自定义的UserArgumentResolver 解析器加入到HandlerMethodArgumentResolver 列表
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers){
        resolvers.add(userArgumentResolver);
    }
}

3.拦截器实现

package com.hspedu.seckill.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hspedu.seckill.pojo.User;
import com.hspedu.seckill.service.UserService;
import com.hspedu.seckill.util.CookieUtil;
import com.hspedu.seckill.vo.RespBean;
import com.hspedu.seckill.vo.RespBeanEnum;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.messaging.handler.HandlerMethod;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

/**
 * @author TTc
 * @version 1.0
 * @date 2024/3/25 10:15
 */
@Component
public class AccessLimitInterceptor implements HandlerInterceptor {
    @Resource
    private UserService userService;
    @Resource
    private RedisTemplate redisTemplate;

    @Override
    public boolean preHandle
            (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            User user = getUser(request, response);
            //存入 threadlocal 中
            UserContext.setUser(user);
            HandlerMethod hm = (HandlerMethod) handler;
            //获取目标方法的注解 AccessLimit,进行解析
            AccessLimit accessLimit =
                    hm.getMethodAnnotation(AccessLimit.class);
            if (accessLimit == null) {
                //没有，直接放行
                return true;
            }
            int second = accessLimit.second();
            int maxCount = accessLimit.maxCount();
            boolean needLogin = accessLimit.needLogin();
            String uri = request.getRequestURI();
            if (needLogin) {
                if (user == null) {
                    render(response, RespBeanEnum.SESSION_ERROR);
                    // 返回前端页面
                    return false;
                }
            }
            String key = uri + ":" + user.getId();
            ValueOperations valueOperations = redisTemplate.opsForValue();
            Integer count = (Integer) valueOperations.get(key);
            //查看计数器，判断计数器
            if (count == null) {
                valueOperations.set(uri + ":" + user.getId(), 1, second, TimeUnit.SECONDS);
            } else if (count < maxCount) {
                valueOperations.increment(uri + ":" + user.getId());
            } else {
                //返回错误信息
                render(response, RespBeanEnum.ACCESS_LIMIT_REAHCED);
                return false;
            }
        }
        return true;
    }

    //构建返回对象
    private void render(HttpServletResponse response, RespBeanEnum sessionError) throws IOException {
        System.out.println("render-" + sessionError.getMessage());
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        PrintWriter out = response.getWriter();
        RespBean error = RespBean.error(sessionError);
        out.write(new ObjectMapper().writeValueAsString(error));
        out.flush();
        out.close();
    }

    //获取当前用户
    private User getUser(HttpServletRequest request, HttpServletResponse response) {
        String ticket = CookieUtil.getCookieValue(request, "userTicket");
        if (StringUtils.isEmpty(ticket)) {
            return null;
        }
        return userService.getUserByCookie(ticket, request, response);
    }
}

为什么我们在Springmvc拦截器的时候要加判断 handler instanceof HandlerMethod

在Spring MVC中，拦截器（Interceptor）的preHandle、postHandle和afterCompletion方法的第三个参数是一个Object类型的handler参数。这个handler参数实际上就是处理当前请求的处理器。

在Spring MVC中，处理器不一定是HandlerMethod类型的。例如，当请求的URL对应的是一个静态资源时，处理器可能是ResourceHttpRequestHandler类型的。另外，如果你自定义了处理器类型，那么处理器也可能是你自定义的类型。

因此，如果你的拦截器的代码只适用于HandlerMethod类型的处理器，你需要在代码中加入if (handler instanceof HandlerMethod)这样的判断，以确保代码不会在处理其他类型的处理器时出错。

HandlerMethod

在Spring MVC中，HandlerMethod是一个特殊的处理器类型，它用于处理由@RequestMapping注解（或其变体，如@GetMapping、@PostMapping等）标注的方法。

当一个HTTP请求到达Spring MVC时，Spring MVC需要找到一个处理器来处理这个请求。如果这个请求的URL匹配了某个@RequestMapping注解的路径，那么Spring MVC会创建一个HandlerMethod对象来处理这个请求。

HandlerMethod对象包含了处理请求的方法和这个方法所在的bean。当请求被处理时，Spring MVC会调用HandlerMethod对象的invoke方法，这个方法会调用原始的@RequestMapping方法来处理请求。

因此，HandlerMethod是Spring MVC处理由@RequestMapping注解标注的方法的关键部分。

4. 根据ThreadLocal存放和获取当前登录用户

package com.hspedu.seckill.config;

import com.hspedu.seckill.pojo.User;

/**
 * @author TTc
 * @version 1.0
 * @date 2024/3/25 10:14
 */
//用来存储拦截器获取的 user 对象.
public class UserContext {
    //每个线程都有自己的 threadlocal，存在这里不容易混乱,线程安全
    private static ThreadLocal<User> userHolder = new ThreadLocal<>();

    public static void setUser(User user) {
        userHolder.set(user);
    }

    public static User getUser() {
        return userHolder.get();
    }
}

5.Controller层接口演示

@RequestMapping(value = "/path", method = RequestMethod.GET)
    @ResponseBody
    /**
     * @AccessLimit(second = 5, maxCount = 5, needLogin = true)
     * 1. 使用注解的方式完成通用的接口防刷功能
     * 2. second = 5, maxCount = 5 5 秒内,最多 5 次请求,否性进行限流* 3. needLogin = true 表示需要登录
     */
    @AccessLimit(second = 5, maxCount = 5, needLogin = true)
//    public RespBean getPath(User user, Long goodsId, String captcha) {
    public RespBean getPath(User user, Long goodsId, String captcha, HttpServletRequest request) {
        if (user == null) {
            return RespBean.error(RespBeanEnum.SESSION_ERROR);
        }
        //也可以使用注解提高使用通用性
//        String uri = request.getRequestURI();
//        log.info(">>>>>>>>>>>请求地址uri: {}<<<<<<<<<<<", uri);
//        ValueOperations valueOperations = redisTemplate.opsForValue();
//        Integer count = (Integer) valueOperations.get(uri + ":" + user.getId());
//        if (count == null) {
//            valueOperations.set(uri + ":" + user.getId(), 1, 5, TimeUnit.SECONDS);
//        } else if (count < 5) {
//            valueOperations.increment(uri + ":" + user.getId());
//        } else {
//            return RespBean.error(RespBeanEnum.ACCESS_LIMIT_REACHED);
//        }
        //验证用户输入的验证码
        boolean check = orderService.checkCaptcha(user, goodsId, captcha);
        if (!check) {
            return RespBean.error(RespBeanEnum.CAPTCHA_ERROR);
        }
        //创建真正的地址
        String url = orderService.createPath(user, goodsId);
        return RespBean.success(url);
    }