Spring AOP en Java implémente la vérification des autorisations des utilisateurs

Chaque projet disposera d'un système de gestion des autorisations

Que vous soyez un simple site Web d'entreprise ou un projet extrêmement complexe au niveau de la plate-forme, cela impliquera l'activité essentielle de la connexion des utilisateurs et de la logique de gestion des autorisations. Certaines personnes se demandent quelles autorisations les sites Web d’entreprise doivent-ils gérer ? D'accord, votre page peut être appelée une page statique. Néanmoins, vous disposerez certainement de fonctions de gestion en arrière-plan et de connexion.

Chaque projet aura presque la même logique métier. Pouvons-nous en faire un système universel ?

AOP implémente la vérification des autorités des utilisateurs

Les scénarios utilisés par AOP dans les projets réels incluent principalement la gestion des autorités (Authority Management), la gestion des transactions (Transaction Management), la gestion de la sécurité (Sécurité) et la gestion des journaux (Logging) et gestion du débogage (Debugging), etc.

Ainsi, nous pouvons utiliser AOP pour implémenter directement la vérification des autorisations. La manière de gérer les autorisations dans votre projet et le niveau de granularité de la gestion dépendent entièrement des besoins du projet et ne seront pas du tout abordés ici.

Parlons d'abord de l'idée : utilisez des annotations et des intercepteurs personnalisés pour effectuer une authentification des autorisations lorsque vous en avez besoin. Ce qui est toujours impliqué ici, ce sont les connaissances liées à l'énumération (énumération), à l'annotation (annotation personnalisée) et à l'intercepteur. Sans plus tarder, commençons simplement à écrire le code.

Commencez à jouer avec le code

** 1. Créez la classe d'énumération AuthorityType.java

public enum AuthorityType {
 
  // 登录和权限都验证 默认
  Validate,
 
  // 不验证
  NoValidate,
 
  // 不验证权限
  NoAuthority;
}

La fonction de cette classe d'énumération est toujours d'utiliser des annotations personnalisées. c'est si bon que je le veux toujours.

2. Créez une nouvelle classe d'annotation personnalisée Authority.java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface Authority {
  // 默认验证
  AuthorityType value() default AuthorityType.Validate;
 
}

3. Créez une autre classe AuthorityAnnotationInterceptor.java

/**
 * 权限认证拦截器
 *
 */
public class AuthorityAnnotationInterceptor extends HandlerInterceptorAdapter {
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
    throws Exception {
 
  if (handler instanceof HandlerMethod) {
    HandlerMethod hm = (HandlerMethod) handler;
 
    Class<?> clazz = hm.getBeanType();
    Method m = hm.getMethod();
    try {
      if (clazz != null && m != null) {
        boolean isClzAnnotation = clazz.isAnnotationPresent(Authority.class);
        boolean isMethondAnnotation = m.isAnnotationPresent(Authority.class);
        Authority authority = null;
        // 如果方法和类声明中同时存在这个注解，那么方法中的会覆盖类中的设定。
        if (isMethondAnnotation) {
          authority = m.getAnnotation(Authority.class);
        } else if (isClzAnnotation) {
          authority = clazz.getAnnotation(Authority.class);
        }
        int code = -1;
        String msg = "";
        if (authority != null) {
          if (AuthorityType.NoValidate == authority.value()) {
            // 标记为不验证,放行
            return true;
          } else if (AuthorityType.NoAuthority == authority.value()) {
            // 不验证权限，验证是否登录
            // TODO:
            return true;
          } else {
            // 验证登录及权限
            // TODO:
 
            code = 1;
            msg = "验证成功！";
            return true;
          }
        }
 
        // //跳转
        // String url = "";
        // response.getWriter().write("<script>top.location.href=&#39;"
        // + url + "&#39;</script>");
        // return false;
 
        // 未通过验证，返回提示json
        Map<String, Object> responseMap = new HashMap<String, Object>();
        responseMap.put("code", code);
        responseMap.put("msg", msg);
        responseMap.put("params", "");
        responseMap.put("rows", "");
        String json = new Gson().toJson(responseMap);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.getWriter().write(json);
        return false;
      }
    } catch (Exception e) {
    }
  }
  return false;
  } 
}

Le but de cette classe est d'effectuer une authentification d'autorisation sur les méthodes et les classes marquées de la balise Authority. Je l'ai divisé en trois types : vérification complète, vérification de connexion uniquement et aucune vérification pour répondre aux besoins de notre entreprise.

La valeur de retour ici peut être une chaîne JSON, ou elle peut accéder à la page correspondante pour obtenir l'effet souhaité.

4. Configurez la configuration du nœud de l'intercepteur

<mvc:interceptors>
  <!-- 权限认证拦截器 -->
  <mvc:interceptor>
    <mvc:mapping path="/**"/>
    <bean class="cn.mayongfa.interceptor.AuthorityAnnotationInterceptor"></bean>
  </mvc:interceptor>
</mvc:interceptors>

sous le fichier /WebContent/WEB-INF/springMVC-servlet.xml. Ici, vous pouvez configurer l'URL spécifique à intercepter.

Ceci termine le travail de vérification des autorisations. Comment l'utiliser ?

C'est très simple à utiliser

En raison de la configuration de notre intercepteur, la valeur par défaut de nos annotations personnalisées est la vérification, nous n'avons donc besoin que d'étiqueter le nom de la classe et le nom de la méthode.

Bien sûr, vous pouvez définir la valeur par défaut dans l'intercepteur pour vérifier toutes les demandes, puis définir la demande pour qu'elle ne soit pas vérifiée.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.

Pour plus d'articles liés à Spring AOP de Java implémentant la vérification des autorisations des utilisateurs, veuillez faire attention au site Web PHP chinois !