Spring Boot 拦截器之验证登录

最新推荐文章于 2024-05-16 10:05:00 发布

clypm

最新推荐文章于 2024-05-16 10:05:00 发布

阅读量3.3k

点赞数 1

分类专栏： Spring Boot

Spring Boot 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

添加jar包，这个jar包不是必须的，只是在拦截器里用到了，如果不用的话，完全可以不引入

[java]view plaincopy
 <dependency>  
             <groupId>org.apache.commons</groupId>  
             <artifactId>commons-lang3</artifactId>  
             <version>3.5</version>  
         </dependency>  

springboot默认为Tomcat，如果用jetty，还需要引入

[java]view plaincopy
 <dependency>  
             <groupId>javax.servlet</groupId>  
             <artifactId>javax.servlet-api</artifactId>  
             <version>3.1.0</version>  
         </dependency>  

1、以登录验证为例，首先创建个@Auth注解

[java]view plaincopy
 package com.demo.interceptor;  
   
 import java.lang.annotation.*;  
   
 /** 
  * 在类或方法上添加@Auth就验证登录 
  */  
 @Target({ElementType.TYPE, ElementType.METHOD})  
 @Retention(RetentionPolicy.RUNTIME)  
 @Documented  
 public @interface Auth {  
 }  

2、创建一个Constants，在拦截器里用

[java]view plaincopy
 package com.demo.util;  
   
  
 public interface Constants {  
     int MAX_FILE_UPLOAD_SIZE = 5242880;  
     String MOBILE_NUMBER_SESSION_KEY = "sessionMobileNumber";  
     String USER_CODE_SESSION_KEY = "userCode";  
     String SESSION_KEY = "sessionId";  
 }  

3、创建一个SessionData，用于保存在session中的字段

[java]view plaincopy
 package com.demo.model;  
   
 import lombok.Data;  
 
 
 @Data  
 public class SessionData {  
     private Integer userCode;  
     private String mobileNumber;  
 }  

4、实现登录拦截实现

[java]view plaincopy
 package com.demo.interceptor;  
   
 import com.demo.model.SessionData;  
 import com.demo.util.RedisUtil;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.stereotype.Component;  
 import org.springframework.web.method.HandlerMethod;  
 import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;  
   
 import javax.servlet.http.HttpServletRequest;  
 import javax.servlet.http.HttpServletResponse;  
 import java.lang.reflect.Method;  
   
 import static com.demo.util.Constants.MOBILE_NUMBER_SESSION_KEY;  
 import static com.demo.util.Constants.SESSION_KEY;  
 import static com.demo.util.Constants.USER_CODE_SESSION_KEY;  
   
 
 
 @Component  
 public class LoginInterceptor extends HandlerInterceptorAdapter {  
     @Autowired  
     private RedisUtil redisUtils;  
     private final static String SESSION_KEY_PREFIX = "session:";  
     public boolean preHandle(HttpServletRequest request,  
                              HttpServletResponse response, Object handler) throws Exception {  
         if (!handler.getClass().isAssignableFrom(HandlerMethod.class)) {  
             return true;  
         }  
         handlerSession(request);  
   
         final HandlerMethod handlerMethod = (HandlerMethod) handler;  
         final Method method = handlerMethod.getMethod();  
         final Class<?> clazz = method.getDeclaringClass();  
         if (clazz.isAnnotationPresent(Auth.class) ||  
                 method.isAnnotationPresent(Auth.class)) {  
             if(request.getAttribute(USER_CODE_SESSION_KEY) == null){  
     
                  throw new Exception();  
                  
             }else{  
                 return true;  
             }  
         }  
   
         return true;  
   
     }  
     public void  handlerSession(HttpServletRequest request) {  
         String sessionId = request.getHeader(SESSION_KEY);  
         if(org.apache.commons.lang3.StringUtils.isBlank(sessionId)){  
             sessionId=(String) request.getSession().getAttribute(SESSION_KEY);  
         }  
         if (org.apache.commons.lang3.StringUtils.isNotBlank(sessionId)) {  
             SessionData model = (SessionData) redisUtils.get(SESSION_KEY_PREFIX+sessionId);  
             if (model == null) {  
                 return ;  
             }  
             request.setAttribute(SESSION_KEY,sessionId);  
             Integer userCode = model.getUserCode();  
             if (userCode != null) {  
                 request.setAttribute(USER_CODE_SESSION_KEY, Long.valueOf(userCode));  
             }  
             String mobile = model.getMobileNumber();  
             if (mobile != null) {  
                 request.setAttribute(MOBILE_NUMBER_SESSION_KEY, mobile);  
             }  
         }  
         return ;  
     }  
 }  

5、配置拦截器

[java]view plaincopy
 package com.demo.interceptor;  
   
 import org.hibernate.validator.HibernateValidator;  
 import org.slf4j.Logger;  
 import org.slf4j.LoggerFactory;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.context.MessageSource;  
 import org.springframework.context.annotation.Bean;  
 import org.springframework.context.annotation.ComponentScan;  
 import org.springframework.context.annotation.Configuration;  
 import org.springframework.context.annotation.PropertySource;  
 import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;  
 import org.springframework.context.support.ReloadableResourceBundleMessageSource;  
 import org.springframework.validation.Validator;  
 import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;  
 import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;  
 import org.springframework.web.servlet.ViewResolver;  
 import org.springframework.web.servlet.config.annotation.*;  
 import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;  
 import org.springframework.web.servlet.view.InternalResourceViewResolver;  
   
 
 
 @Configuration  
 @EnableWebMvc  
 @ComponentScan(basePackages = "com.demo.controller")  
 @PropertySource(value = "classpath:application.properties",  
         ignoreResourceNotFound = true,encoding = "UTF-8")  
 public class MvcConfig extends WebMvcConfigurerAdapter {  
     private static final Logger logger = LoggerFactory.getLogger(MvcConfig.class);  
     @Autowired  
     LoginInterceptor loginInterceptor;  
   
     /** 
  
      * <p> 
      *     视图处理器 
      * </p> 
      * 
      * @return 
      */  
     @Bean  
     public ViewResolver viewResolver() {  
         logger.info("ViewResolver");  
         InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();  
         viewResolver.setPrefix("/WEB-INF/jsp/");  
         viewResolver.setSuffix(".jsp");  
         return viewResolver;  
     }  
   
     /** 
      * 拦截器配置 
      * @param registry 
      */  
     @Override  
     public void addInterceptors(InterceptorRegistry registry) {  
         // 注册监控拦截器，解决@Autowired注入失败（配置在Spring 之前加载） 
         registry.addInterceptor(loginInterceptor)  
                 .addPathPatterns("/**")  
          .excludePathPatterns("/configuration/ui");  
   
     }  
   
     @Override  
     public void addCorsMappings(CorsRegistry registry) {  
         registry.addMapping("/**")  
                 .allowedOrigins("*")  
                 .allowedHeaders("*/*")  
                 .allowedMethods("*")  
                 .maxAge(120);  
     }  
   
     /** 
      * 资源处理器 
      * @param registry 
      */  
     @Override  
     public void addResourceHandlers(ResourceHandlerRegistry registry) {  
         logger.info("addResourceHandlers");  
         registry.addResourceHandler("/swagger-ui.html")  
                 .addResourceLocations("classpath:/META-INF/resources/");  
         registry.addResourceHandler("/webjars/**")  
                 .addResourceLocations("classpath:/META-INF/resources/webjars/");  
     }  
   
 }  

以上就完成了，测试时可以在LoginInterceptor里打断点，然后在controller上或者方法上添加@Auth注解，

controller上添加以后这个controller里所有请求都验证登录，在方法里添加只有请求这个方法时验证

[java]view plaincopy
 @Auth  
 @RestController  
 public class TestController {  
   
   
 }  

clypm

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
3
评论
Spring Boot 拦截器之验证登录

添加jar包，这个jar包不是必须的，只是在拦截器里用到了，如果不用的话，完全可以不引入[java] view plain copy org.apache.commons commons-lang3 3.5 springboot
复制链接

扫一扫