Spring AOP in Java implementiert die Überprüfung der Benutzerberechtigungen

Jedes Projekt wird über ein Berechtigungsverwaltungssystem verfügen

Ob es sich um eine einfache Unternehmenswebsite oder ein äußerst komplexes Projekt auf Plattformebene handelt, es umfasst das wesentliche Geschäft der Benutzeranmeldung und Berechtigungsverwaltung. Manche Leute fragen: Welche Berechtigungen benötigen Unternehmenswebsites zur Verwaltung? OK, Ihre Seite wird möglicherweise als statische Seite bezeichnet. Sie verfügen jedoch auf jeden Fall über Hintergrundverwaltungs- und Anmeldefunktionen.

Jedes Projekt wird fast die gleiche Geschäftslogik haben. Können wir daraus ein universelles System machen?

AOP implementiert die Überprüfung der Benutzerberechtigung

Die von AOP in tatsächlichen Projekten verwendeten Szenarien umfassen hauptsächlich die Berechtigungsverwaltung (Authority Management), die Transaktionsverwaltung (Transaction Management), die Sicherheitsverwaltung (Security) und die Protokollverwaltung (Protokollierung) und Debugging-Management (Debugging) usw.

So können wir AOP verwenden, um die Berechtigungsüberprüfung direkt zu implementieren. Wie Sie Berechtigungen in Ihrem Projekt verwalten und wie hoch die Verwaltungsgranularität ist, hängt vollständig von den Anforderungen des Projekts ab und wird hier überhaupt nicht besprochen.

Lassen Sie uns zunächst über die Idee sprechen: Verwenden Sie benutzerdefinierte Annotationen und Interceptors, um bei Bedarf eine Berechtigungsauthentifizierung durchzuführen. Hier geht es noch um Enum (Aufzählung), Annotation (benutzerdefinierte Annotation) und Interceptor-bezogenes Wissen. Beginnen wir ohne weitere Umschweife einfach mit dem Schreiben des Codes.

Beginnen Sie mit dem Code zu spielen

** 1. Erstellen Sie die Aufzählungsklasse AuthorityType.java

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

Die Funktion dieser Aufzählungsklasse besteht weiterhin darin, benutzerdefinierte Anmerkungen zu verwenden fühlt sich so gut an, dass ich es immer noch will.

2. Erstellen Sie eine neue benutzerdefinierte Authority.java-Annotationsklasse

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. Erstellen Sie eine weitere AuthorityAnnotationInterceptor.java-Klasse

/**
 * 权限认证拦截器
 *
 */
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;
  } 
}

Der Zweck dieser Klasse besteht darin, die Berechtigungsauthentifizierung für Methoden und Klassen durchzuführen, die mit dem Authority-Tag gekennzeichnet sind. Ich habe es in drei Typen unterteilt: vollständige Verifizierung, nur Anmeldeverifizierung und keine Verifizierung, um unseren Geschäftsanforderungen gerecht zu werden.

Der Rückgabewert kann hier eine JSON-Zeichenfolge sein oder zur entsprechenden Seite springen, um den gewünschten Effekt zu erzielen.

4. Konfigurieren Sie den Interceptor

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

ad6669fcacaee0dbae1311edd5eb66da unter der Datei /WebContent/WEB-INF/springMVC-servlet.xml Hier können Sie die spezifische URL konfigurieren, die abgefangen werden soll.

Damit ist die Berechtigungsüberprüfung abgeschlossen. Wie verwende ich es?

Es ist sehr einfach zu verwenden

Aufgrund unserer Interceptor-Konfiguration ist die Standardeinstellung für unsere benutzerdefinierten Anmerkungen die Überprüfung, sodass wir nur den Klassennamen und den Methodennamen kennzeichnen müssen.

Natürlich können Sie im Interceptor die Standardeinstellung festlegen, um alle Anforderungen zu überprüfen, und die Anforderung dann auf „Nicht überprüfen“ festlegen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.

Weitere Artikel zur Implementierung der Benutzerberechtigungsüberprüfung durch Javas Spring AOP finden Sie auf der chinesischen PHP-Website!