Comment Springboot implémente l'authentification universelle Auth

AOP traditionnel

Pour cette exigence, la première chose qui vient à l'esprit est bien sûr l'interface AOP fournie par Spring-boot. Il vous suffit d'ajouter un pointcut avant la méthode Controller, et. puis traitez le pointcut Can.

Implémenter

Les étapes sont les suivantes :

1. Utilisez @Aspect Statement Regardons la classe d'aspect WhitelistAspect;

2. Ajoutez un pointcut whitelistPointcut() dans la classe d'aspect Afin de réaliser la capacité de ce pointcut à être assemblé de manière flexible, l'exécution n'est pas utilisée ici pour intercepter all , mais ajoutez une annotation @Whitelist, et la méthode annotée vérifiera la liste blanche.

3. Utilisez l'annotation AOP de Spring @Before dans la classe d'aspect pour déclarer une méthode de notification checkWhitelist() afin de vérifier la liste blanche avant l'exécution de la méthode Controller.

Le pseudo code de la classe aspect est le suivant :

 @Aspect
  public class WhitelistAspect {

    @Before(value = "whitelistPointcut() && @annotation(whitelist)")
    public void checkAppkeyWhitelist(JoinPoint joinPoint, Whitelist whitelist) {
        checkWhitelist();
        // 可使用 joinPoint.getArgs() 获取Controller方法的参数
        // 可以使用 whitelist 变量获取注解参数
    }

    @Pointcut("@annotation(com.zhenbianshu.Whitelist)")
    public void whitelistPointCut() {
    }
  }

Ajoutez l'annotation @Whitelist sur la méthode Controller à implémenter la fonction.

Extension

Dans cet exemple, les annotations sont utilisées pour déclarer les points de coupure, et j'ai implémenté des paramètres d'annotation pour déclarer la liste blanche à vérifier si après si vous en avez besoin. pour ajouter d'autres listes blanches, telles que la vérification via UID, vous pouvez ajouter des méthodes telles que uid() à cette annotation pour implémenter une vérification personnalisée.

De plus, l'AOP de Spring prend également en charge l'exécution (méthode d'exécution), le bean (méthode d'exécution des objets Bean correspondant à des noms spécifiques) et d'autres méthodes de déclaration de pointcut et @Around (exécution dans la fonction cible Méthodes de notification telles que (pendant l'exécution), @After (après l'exécution de la méthode), etc.

Donc, la fonction a été implémentée, mais le leader n'est pas satisfait =_= La raison est que l'AOP est trop utilisé dans le projet et est recommandé. Je le change. Eh bien, je devais juste le commencer. Faites également attention à : Ma Yuan Technology Column, réponse en arrière-plan : « Interview Guide » est disponible, la dernière version du PDF haute définition 3625 pages de questions d'entretien pour les grandes sociétés Internet.

Interceptor

Spring's Interceptor est également très approprié pour implémenter cette fonction. Comme son nom l'indique, l'intercepteur est utilisé pour déterminer s'il faut exécuter cette méthode via certains paramètres avant l'exécution de l'action dans le contrôleur. Pour implémenter un intercepteur, vous pouvez implémenter l'interface HandlerInterceptor de Spring.

Mise en œuvre

Les étapes de mise en œuvre sont les suivantes :

1. Définir le classe d'intercepteur Classe AppkeyInterceptor et implémente l'interface HandlerInterceptor.

2. Implémenter sa méthode preHandle()

3. Déterminer si elle est nécessaire via des annotations et des paramètres dans le méthode preHandle Intercepter la requête. L'interface renvoie false lors de l'interception de la requête ;

4. Enregistrez cet intercepteur dans la classe WebMvcConfigurerAdapter personnalisée ; 🎜#

   AppkeyInterceptor est la suivante :

@Component
public class WhitelistInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Whitelist whitelist = ((HandlerMethod) handler).getMethodAnnotation(Whitelist.class);
        // whitelist.values(); 通过 request 获取请求参数，通过 whitelist 变量获取注解参数
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  // 方法在Controller方法执行结束后执行
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  // 在view视图渲染完成后执行
    }
}

Extension

Pour activer l'intercepteur, vous devez également le configurer explicitement pour l'activer, nous utilisons ici WebMvcConfigurerAdapter pour le configurer. Il convient de noter que le MvcConfiguration qui en hérite doit se trouver dans le chemin ComponentScan.

@Configuration
public class MvcConfiguration extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new WhitelistInterceptor()).addPathPatterns("/*").order(1);
        // 这里可以配置拦截器启用的 path 的顺序，在有多个拦截器存在时，任一拦截器返回 false 都会使后续的请求方法不再执行
    }
}

Notez également qu'une fois l'intercepteur exécuté avec succès, le code de réponse est 200, mais les données de réponse sont vides.
Après avoir utilisé l'intercepteur pour implémenter la fonction, le leader a finalement proposé un grand pas : nous avons déjà un paramètre Auth, l'appkey peut être obtenue à partir du paramètre Auth, et la présence ou l'absence de la liste blanche peut être utilisé comme méthode d'authentification. Pourquoi ne pas vérifier lors de l'authentification ? emmm... Vomir du sang.

ArgumentResolver

L'analyseur de paramètres est un outil fourni par Spring pour analyser les paramètres personnalisés. Notre annotation @RequestParam couramment utilisée a son ombre. peut combiner les paramètres selon ce que nous voulons avant d'entrer dans l'action du contrôleur. Spring maintiendra une ResolverList. Lorsque la demande arrive, Spring découvre qu'il existe des paramètres de type personnalisés (types non basiques) et essaiera ces résolveurs dans l'ordre jusqu'à ce qu'un résolveur puisse analyser les paramètres requis. Pour implémenter un résolveur de paramètres, vous devez implémenter l'interface HandlerMethodArgumentResolver.

Implementation

Définissez le type de paramètre personnalisé AuthParam, et il y a des champs liés à l'application dans la classe ; #🎜🎜 #

• Définir AuthParamResolver et implémenter l'interface HandlerMethodArgumentResolver ; 🎜 🎜 #

Implémentez la méthode d'interface solveArgument() pour analyser l'objet reqest afin de générer un objet AuthParam et vérifiez l'AuthParam ici pour confirmer si la clé d'application est dans la liste blanche
•  ;

  #🎜 🎜#

  Ajoutez le paramètre AuthParam dans la signature de la méthode Controller Action pour activer ce Resolver #

  @Component
  public class AuthParamResolver implements HandlerMethodArgumentResolver {
  
      @Override
      public boolean supportsParameter(MethodParameter parameter) {
          return parameter.getParameterType().equals(AuthParam.class);
      }
  
      @Override
      public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
          Whitelist whitelist = parameter.getMethodAnnotation(Whitelist.class);
          // 通过 webRequest 和 whitelist 校验白名单
          return new AuthParam();
      }
  }

Extension

• Bien sûr ; , l'utilisation de l'analyseur de paramètres nécessite également une configuration séparée. Nous le configurons également dans WebMvcConfigurerAdapter :

• @Configuration
  public class MvcConfiguration extends WebMvcConfigurerAdapter {
  
      @Override
      public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
          argumentResolvers.add(new AuthParamResolver());
      }
  }

  Une fois l'implémentation terminée cette fois, j'étais encore un peu inquiet, alors j'ai cherché en ligne. pour voir s'il existait d'autres moyens d'obtenir cette fonction, et j'ai constaté que le plus courant était le filtre.

Filter

Filter 并不是 Spring 提供的，它是在 Servlet 规范中定义的，是 Servlet 容器支持的。被 Filter 过滤的请求，不会派发到 Spring 容器中。它的实现也比较简单，实现 javax.servlet.Filter接口即可。


由于不在 Spring 容器中，Filter 获取不到 Spring 容器的资源，只能使用原生 Java 的 ServletRequest 和 ServletResponse 来获取请求参数。


另外，在一个 Filter 中要显示调用 FilterChain 的 doFilter 方法，不然认为请求被拦截。实现类似：
public class WhitelistFilter implements javax.servlet.Filter {

@Override
    public void init(FilterConfig filterConfig) throws ServletException {
  // 初始化后被调用一次
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
     // 判断是否需要拦截
       chain.doFilter(request, response); // 请求通过要显示调用
    }

    @Override
    public void destroy() {
     // 被销毁时调用一次
    }
}

扩展


Filter 也需要显示配置：


@Configuration
public class FilterConfiguration {

    @Bean
    public FilterRegistrationBean someFilterRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new WhitelistFilter());
        registration.addUrlPatterns("/*");
        registration.setName("whitelistFilter");
        registration.setOrder(1); // 设置过滤器被调用的顺序
        return registration;
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!