springboot登录拦截方法

已于 2023-02-01 11:05:14 修改
阅读量285 收藏
点赞数
文章标签： spring boot java 数据库
于 2022-11-24 20:17:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56506584/article/details/128025829
版权

controller代码

@RestController
@RequestMapping("/user")
@LoginValidator
public class UserController {

    @Autowired
    private RedisTemplate redisTemplate;

    /** 模拟的用户列表 */
    private static final List<User> PRE_USER_LIST = new ArrayList<User>() {
        private static final long serialVersionUID = 1L;
        {
            add(new User(1, "zhangsan", "123", true));
            add(new User(2, "lisi", "456", true));
            add(new User(3, "wangwu", "789", true));
        }
    };

    @PostMapping("/login")
    @LoginValidator(validated = false)
    public Result login(@RequestBody User user){
        String username = user.getUsername();
        String password = user.getPassword();
        if(StringUtils.isAnyBlank(username,password)){
            return Result.builder().code(HttpStatus.INTERNAL_SERVER_ERROR.value()).errorMsg("用户名或者密码错误").build();
        }

        List<User> userList = PRE_USER_LIST.stream().filter(vo -> StringUtils.equals(username, vo.getUsername())).collect(Collectors.toList());
        if(userList.size() != 1){
            return Result.builder().code(HttpStatus.INTERNAL_SERVER_ERROR.value()).errorMsg("用户名不存在").build();
        }
        User loginUser = userList.get(0);
        if(!StringUtils.equals(password, loginUser.getPassword())){
            return Result.builder().code(HttpStatus.INTERNAL_SERVER_ERROR.value()).errorMsg("密码错误").build();
        }
        if(!loginUser.isEnable()){
            return Result.builder().code(HttpStatus.INTERNAL_SERVER_ERROR.value()).errorMsg("账户已经被锁定").build();
        }
        String token = UUID.randomUUID().toString().replace("-", "");
        redisTemplate.opsForValue().set(Constant.REDIS_USER_PREFIX + token, loginUser, 30, TimeUnit.MINUTES);
        Object o = redisTemplate.opsForValue().get(Constant.REDIS_USER_PREFIX + token);
        System.out.println(o.toString());
        return Result.builder().code(HttpStatus.OK.value()).data(token).build();
    }

    @PostMapping("/test")
    public String test(@RequestBody User user) {
        User user1 = LoginUserThread.get();
        System.out.println(user1.toString());
        return "测试编码";
    }
}```

## 1.使用aspect+注解+redis实现

```java
@Component
@Aspect
public class LoginAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 切点，方法上有注解或者类上有注解
     *  拦截标有注解的类或者方法
     */
    @Pointcut(value = "@annotation(com.zzc.hlh.annotition.LoginValidator) || @within(com.zzc.hlh.annotition.LoginValidator)")
    public void pointCut(){}

    @Around("pointCut()")
    public Object before(ProceedingJoinPoint joinpoint) throws Throwable {
        // 获取方法方法上的LoginValidator注解
        MethodSignature methodSignature = (MethodSignature)joinpoint.getSignature();
        Method method = methodSignature.getMethod();
        LoginValidator loginValidator = method.getAnnotation(LoginValidator.class);
        // 如果有，并且值为false，则不校验
        if (loginValidator != null && !loginValidator.validated()) {
            return joinpoint.proceed(joinpoint.getArgs());
        }
        // 正常校验 获取request和response
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (requestAttributes == null || requestAttributes.getResponse() == null) {
            // 如果不是从前段过来的，没有request，则直接放行
            return joinpoint.proceed(joinpoint.getArgs());
        }
        HttpServletRequest request = requestAttributes.getRequest();
        HttpServletResponse response = requestAttributes.getResponse();
        // 获取token
        String token = request.getHeader(Constant.TOKEN_HEADER_NAME);
        if (StringUtils.isBlank(token)) {
            returnNoLogin(response);
            return null;
        }
        // 从redis中拿token对应user
        User user = (User) redisTemplate.opsForValue().get(Constant.REDIS_USER_PREFIX + token);
        if (user == null) {
            returnNoLogin(response);
            return null;
        }
        // 存放如ThreadLocal
        LoginUserThread.put(user);
        // token续期
        Long templateExpire = redisTemplate.getExpire(Constant.REDIS_USER_PREFIX + token);
        if(templateExpire < 20*60){
            redisTemplate.expire(Constant.REDIS_USER_PREFIX + token, 30, TimeUnit.MINUTES);
        }
        //放行
        return joinpoint.proceed(joinpoint.getArgs());
    }

    /**
     * 返回未登录的错误信息
     * @param response ServletResponse
     */
    private void returnNoLogin(HttpServletResponse response) throws IOException {
        ServletOutputStream outputStream = response.getOutputStream();
        // 设置返回401 和响应编码
        response.setStatus(401);
        response.setContentType("Application/json;charset=utf-8");
        // 构造返回响应体
        Result<String> result = Result.<String>builder()
                .code(HttpStatus.UNAUTHORIZED.value())
                .errorMsg("未登陆，请先登陆")
                .build();
        String resultString = JSONUtil.toJsonStr(result);
        outputStream.write(resultString.getBytes(StandardCharsets.UTF_8));
    }
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LoginValidator {
    boolean validated() default true;
}

2.使用filter监听器

public class LoginFilter implements Filter {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private LoginProperties loginProperties;
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public LoginFilter(RedisTemplate redisTemplate, LoginProperties loginProperties) {
        this.redisTemplate = redisTemplate;
        this.loginProperties = loginProperties;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 过滤路径
        String requestURI = httpServletRequest.getRequestURI();
        if (!loginProperties.getFilterExcludeUrl().contains(requestURI)) {
            // 获取token
            String token = httpServletRequest.getHeader(Constant.TOKEN_HEADER_NAME);
            if (StringUtils.isBlank(token)) {
                returnNoLogin(response);
                return;
            }
            // 从redis中拿token对应user
            User user = (User) redisTemplate.opsForValue().get(Constant.REDIS_USER_PREFIX + token);
            if (user == null) {
                returnNoLogin(response);
                return;
            }
            // 存放如ThreadLocal
            LoginUserThread.put(user);
            // token续期
            Long templateExpire = redisTemplate.getExpire(Constant.REDIS_USER_PREFIX + token);
            if(templateExpire < 20*60){
                redisTemplate.expire(Constant.REDIS_USER_PREFIX + token, 30, TimeUnit.MINUTES);
            }
        }
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {

    }

    /**
     * 返回未登录的错误信息
     * @param response ServletResponse
     */
    private void returnNoLogin(ServletResponse response) throws IOException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        ServletOutputStream outputStream = httpServletResponse.getOutputStream();
        // 设置返回401 和响应编码
        httpServletResponse.setStatus(401);
        httpServletResponse.setContentType("Application/json;charset=utf-8");
        // 构造返回响应体
        Result<String> result = Result.<String>builder()
                .code(HttpStatus.UNAUTHORIZED.value())
                .errorMsg("未登陆，请先登陆")
                .build();
        String resultString = JSONUtil.toJsonStr(result);
        outputStream.write(resultString.getBytes(StandardCharsets.UTF_8));
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private  LoginInterception loginInterception;
    @Autowired
    private LoginProperties loginProperties;
    @Autowired
    private RedisTemplate redisTemplate;
//    @Override
//    public void addInterceptors(InterceptorRegistry registry) {
//        registry.addInterceptor(loginInterception)
//                .addPathPatterns(loginProperties.getInterceptorIncludeUrl())
//                .excludePathPatterns(loginProperties.getInterceptorExcludeUrl());
//    }

    /*
     * 添加过滤器
     */
    @Bean
    public FilterRegistrationBean<Filter> loginFilterRegistration() {
        // 注册LoginFilter
        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new LoginFilter(redisTemplate, loginProperties));
        // 设置名称
        registrationBean.setName("loginFilter");
        // 设置拦截路径
        registrationBean.addUrlPatterns(loginProperties.getFilterIncludeUrl().toArray(new String[0]));
        // 指定顺序
        registrationBean.setOrder(-1);
        return registrationBean;
    }
}

3.使用过滤器

@Component
public class LoginInterception implements HandlerInterceptor {

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 获取token
        String token = request.getHeader(Constant.TOKEN_HEADER_NAME);
        if (StringUtils.isBlank(token)) {
            returnNoLogin(response);
            return false;
        }
        User user = (User) redisTemplate.opsForValue().get(Constant.REDIS_USER_PREFIX + token);
        if (user == null) {
            returnNoLogin(response);
            return false;
        }
        // 存放如ThreadLocal
        LoginUserThread.put(user);
        // token续期
        Long templateExpire = redisTemplate.getExpire(Constant.REDIS_USER_PREFIX + token);
        if(templateExpire < 20*60){
            redisTemplate.expire(Constant.REDIS_USER_PREFIX + token, 30, TimeUnit.MINUTES);
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        LoginUserThread.remove();
    }

    /**
     * 返回未登录的错误信息
     * @param response ServletResponse
     */
    private void returnNoLogin(HttpServletResponse response) throws IOException {
        ServletOutputStream outputStream = response.getOutputStream();
        // 设置返回401 和响应编码
        response.setStatus(401);
        response.setContentType("Application/json;charset=utf-8");
        // 构造返回响应体
        Result<String> result = Result.<String>builder()
                .code(HttpStatus.UNAUTHORIZED.value())
                .errorMsg("未登陆，请先登陆")
                .build();
        String resultString = JSONUtil.toJsonStr(result);
        outputStream.write(resultString.getBytes(StandardCharsets.UTF_8));
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private  LoginInterception loginInterception;
    @Autowired
    private LoginProperties loginProperties;
    @Autowired
    private RedisTemplate redisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterception)
                .addPathPatterns(loginProperties.getInterceptorIncludeUrl())
                .excludePathPatterns(loginProperties.getInterceptorExcludeUrl());
    }
}

其它

public class LoginUserThread {

    /** 线程池变量 */
    private static final ThreadLocal<User> LOGIN_USER = new ThreadLocal<User>();

    private LoginUserThread() {}

    public static User get() {
        return LOGIN_USER.get();
    }

    public static void put(User user) {
        LOGIN_USER.set(user);
    }

    public static void remove() {
        LOGIN_USER.remove();
    }

}

public class Constant {

        /** redis存储的key的前缀 */
        public static final String REDIS_USER_PREFIX = "user:";
        /** token存储的请求头名称 */
        public static final String TOKEN_HEADER_NAME = "Authorization";

}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Result<T> implements Serializable {
    private static final long serialVersionUID = 9110032459932964235L;

    private int code;
    private String errorMsg;
    private T data;
}

@Component
@ConfigurationProperties(prefix = "login")
@Data
public class LoginProperties implements Serializable {
    private static final long serialVersionUID = 1L;

    private List<String> filterIncludeUrl;
    private List<String> filterExcludeUrl;

    private List<String> interceptorIncludeUrl;
    private List<String> interceptorExcludeUrl;

}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private int id;
    private String username;
    private String password;
    private boolean enable;

}

```yaml
login:
  filter-include-url:
    - /*
  filter-exclude-url:
    - /user/login
  interceptor-include-url:
    - /**
  interceptor-exclude-url:
    - /user/login
    - /error/**```
好人好报i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【SpringBoot】7、SpringBoot中实现未登录拦截
Asurplus
04-16 20万+
我们需要在项目中对未登录的用户进行拦截，使其登录后才能访问 1、创建 LoginInterceptor.java，实现 HandlerInterceptor 接口 @Component public class LoginInterceptor implements HandlerInterceptor { @Override public boolean preHandle(H...
springboot登录拦截器
weixin_45539338的博客
05-15 6684
springboot配置登录拦截器
Springboot——拦截器
热门推荐
weixin_51351637的博客
11-27 4万+
假设controller层抛了异常，在这里是可以拿到异常对象的，但是我们有异常处理机制，所以这里就没有那么大的需求了。封装了SpringMVC进行页面跳转的相关数据，但是我们现在都是反JSON，一般不会这么搞了。是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行。通过这个ex可以拿到原始的程序执行过程中出现的异常的。那当我们配置了两个拦截器以后，会有一个执行顺序。Object handler 是什么参数。request：请求对象。response：响应对象。
SpringBoot实现登录拦截器（实战版）
2401_83641360的博客
04-18 499
一般像这样的大企业都有好几轮面试，所以自己一定要花点时间去收集整理一下公司的背景，公司的企业文化，俗话说「知己知彼百战不殆」，不要盲目的去面试，还有很多人关心怎么去跟HR谈薪资。这边给大家一个建议，如果你的理想薪资是30K，你完全可以跟HR谈33~35K，而不是一下子就把自己的底牌暴露了出来，不过肯定不能说的这么直接，比如原来你的公司是25K，你可以跟HR讲原来的薪资是多少，你们这边能给到我的是多少？你说我这边希望可以有一个20%涨薪。
关于SpringBoot中拦截方法（登陆）
qq_35069673的博客
03-08 388
1.拦截器进行登陆检 PS： 登陆操作时设置对应的session进行保存人员的身份 创建拦截器实现SpringBoot本身的接口： 3.还要注册拦截器，让他能够使用： ...
SpringBoot之登录拦截器
m0_61104769的博客
06-03 1185
上述拦截器可以用于实现用户登录认证功能。在Web应用程序中，有些功能需要用户登录后才能访问，例如用户个人中心、购物车、订单等功能。为了保护这些功能不被未登录用户访问，可以使用拦截器来实现登录认证。拦截器可以拦截所有需要登录认证的请求，检查用户是否已经登录，如果未登录则重定向到登录页面，否则放行请求并允许用户访问受保护的功能。这样可以有效地保护用户数据安全，防止未经授权的访问。
全面了解SpringBoot拦截器
万猫学社
06-28 1万+
拦截器（Interceptor）是一种特殊的组件，它可以在请求处理的过程中对请求和响应进行拦截和处理。拦截器可以在请求到达目标处理器之前、处理器处理请求之后以及视图渲染之前执行特定的操作。拦截器的主要目的是在不修改原有代码的情况下，实现对请求和响应的统一处理。本文详细介绍了SpringBoot中的拦截器，包括拦截器的概念、作用、实现方式、执行顺序、生命周期以及高级应用。我们还探讨了拦截器的性能优化策略和常见问题。希望本文能帮助您更好地理解和使用SpringBoot中的拦截器。
SpringBoot实现登录拦截器
leeta的博客
08-09 5243
1、SpringBoot实现登录拦截的原理 1.1、实现HandlerInterceptor接口 1.2、实现WebMvcConfigurer接口，注册拦截器 1.3、保持登录状态 2、代码实现及示例 3、效果验证 3.1、访问localhost:8081/index页面： 3.2、正确输入用户名和密码登录 3.3、再次访问localhost:8081/index 对于管理系统或其他需要用户登录的系统，登录验证都是必不可少的环节，在SpringBoot开发的项目中，通过实现拦
SpringBoot登录拦截器
不愧是暮言的博客
02-15 1280
拦截器（Interceptor）类似于Servlet中的过滤器， 同Filter 过滤器一样，它俩都是面向切面编程——AOP 的具体实现(AOP切面编程只是一种编程思想而已)，主要用于拦截客户请求并做出相应的处理。过滤器只能在容器初始化时被调用一次，在action的生命周期中，而拦截器可以多次被调用。过滤器可以对几乎所有的请求起作用，拦截器只能对action请求起作用。
springboot自定义拦截器的方法
菜鸟教程
04-06 4675
更多python、PHP、JAVA教程请到友情连接： 菜鸟教程https://www.piaodoo.com 茂名一技http://www.enechn.comppt制作教程步骤 http://www.tpyjn.cn 兴化论坛http://www.yimoge.cn 电白论坛 http://www.fcdzs.com表格制作excel教程 http://www.tsgmyy.cn 高州阳光论坛 http://www.tsgmyy.cn 拦截器应该分属于web框架的组件，每个框架提供的自己的支持，实现
SpringBoot实现登录拦截功能
weixin_44431073的博客
06-11 2427
springboot 实现登录拦截功能，避免恶意登录
SpringBoot登录拦截配置详解(实测可用)
08-18
SpringBoot登录拦截配置详解 SpringBoot登录拦截配置详解是指在SpringBoot应用程序中实现登录拦截的配置过程。登录拦截是指在用户请求资源之前，检查用户是否已经登录，如果未登录，则抛出异常，提示用户登录。这种...
SpringBoot的拦截器
11-26
1. 创建自定义拦截器类：你需要创建一个实现了`HandlerInterceptor`接口的类，这个接口包含三个方法：`preHandle()`, `postHandle()`, 和 `afterCompletion()`。这些方法会在请求生命周期的不同阶段被调用。 ```...
SpringBoot拦截器实现登录拦截的方法示例
08-25
主要介绍了SpringBoot拦截器实现登录拦截的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot+springmvc实现登录拦截
08-25
Spring Boot + Spring MVC 实现登录拦截 概述： Spring Boot + Spring MVC 是一种流行的 Java 웹应用程序框架，它提供了许多有用的特性和工具来帮助开发者快速构建 Web 应用程序。登录拦截是 Web 应用程序中的一项...
SpringBoot的拦截器中依赖注入为null的解决方法
08-27
SpringBoot拦截器中依赖注入为null的解决方法 在Spring Boot框架中，拦截器是一个常用的技术手段，用于处理请求和响应的逻辑。然而，在使用拦截器时，开发者可能会遇到依赖注入为null的问题。这主要是由于拦截器...
Spring Boot集成pf4j实现插件开发功能
最新发布
HBLOG
07-10 540
一个插件框架，用于实现插件的动态加载，支持的插件格式（zip、jar）。
Spring Boot中的多租户架构实现
微赚淘客开发者博客
07-06 1423
在多租户系统中，每个租户都能够安全且有效地使用相同的应用程序，同时确保数据隔离和性能独立性。通过合理的设计和实施，开发人员可以有效地管理和运行支持多个租户的应用程序，从而提升系统的灵活性和扩展性。每个租户是一个逻辑上独立的客户，拥有自己的数据、配置、用户界面等资源，而这些资源又可以在同一个应用程序实例中共享。在Spring Boot中配置多租户数据源，可以使用AbstractRoutingDataSource实现动态数据源切换，根据不同的租户标识动态选择数据源。
Spring Boot单体服务之间用feign调用
木槿
07-09 161
会定义路径和url等信息，用于指定服务调用服务调用启动feign配置调用url。
springboot 登录拦截
10-03
SpringBoot登录拦截配置是通过添加依赖和编写相应的代码来实现的。你可以在你的项目中引入以下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> 通过这个依赖，你可以在你的Spring Boot应用程序中使用Thymeleaf模板引擎来构建用户界面。 此外，你可以参考以下链接，了解更多关于Spring Boot登录拦截配置的详细信息和示例代码： [01-spring-boot-auth-filter · master · csdn / spring-boot-csdn · GitLab](https://gitlab.sea-clouds.cn/csdn/spring-boot-csdn/-/tree/master/01-spring-boot-auth-filter) 希望这些信息能帮到你！如果你还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值