Java-Backend-Entwicklung: Verwendung des Java Authentication and Authorization Service für die API-Mehrrollen-Berechtigungsverwaltung

Mit der Entwicklung des Internets werden die Anwendungsszenarien verschiedener Webanwendungen und APIs immer umfangreicher und das API-Mehrrollen-Berechtigungsmanagement ist zu einem immer wichtigeren Thema geworden. In der Java-Backend-Entwicklung ist der Java Authentication and Authorization Service (JAAS) eine zuverlässige Lösung. Er bietet einen rollenbasierten Berechtigungskontrollmechanismus, der es uns ermöglicht, Zugriffsberechtigungen auf API-Schnittstellen einfach zu verwalten.

In der Java-Entwicklung ist das JAAS-Framework die Abkürzung für Java Authentication and Authorization Service. Es ist eine der Java SE-Standard-APIs und wird hauptsächlich zur Authentifizierung und Autorisierung von Anwendungen verwendet. Die Kernkonzepte des JAAS-Frameworks sind Konfigurations- und Richtlinienquellen, die zur Identifizierung und Verwaltung verschiedener Benutzertypen und Zugriffsrichtlinien in einem Programm verwendet werden.

Das JAAS-Framework bietet zwei Hauptabstraktionen: Subject und LoginModule. Betreff stellt einen Benutzer oder eine Benutzergruppe im Programm dar, und LoginModule ist die spezifische Implementierung von Authentifizierung und Autorisierung. Das JAAS-Framework implementiert durch diese beiden Abstraktionen einen rollenbasierten Berechtigungskontrollmechanismus.

Sehen wir uns an, wie Sie das JAAS-Framework zur Implementierung der API-Rollenberechtigungsverwaltung verwenden.

1. JAAS konfigurieren

Zuerst muss JAAS konfiguriert werden. Wir können im Projekt eine Konfigurationsdatei erstellen, zum Beispiel: jaas.conf. Der Inhalt der Konfigurationsdatei lautet wie folgt:

Sample {
    com.example.security.SimpleLoginModule required;
};

In der obigen Konfiguration ist Sample ein Programmname und com.example.security.SimpleLoginModule der Klassenname, der die LoginModule-Schnittstelle implementiert.

2. Implementieren Sie die LoginModule-Schnittstelle

Als nächstes müssen Sie eine Klasse implementieren, die die LoginModule-Schnittstelle implementiert, um Benutzer zu authentifizieren und zu autorisieren. Das Codebeispiel lautet wie folgt:

package com.example.security;

import java.util.Map;
import javax.security.auth.Subject;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.auth.login.LoginException;
import javax.security.auth.spi.LoginModule;

public class SimpleLoginModule implements LoginModule {

    private Subject subject;
    private CallbackHandler callbackHandler;
    private Map<String, ?> sharedState;
    private Map<String, ?> options;
    private String username;

    public void initialize(
        Subject subject,
        CallbackHandler callbackHandler,
        Map<String, ?> sharedState,
        Map<String, ?> options
    ) {
        this.subject = subject;
        this.callbackHandler = callbackHandler;
        this.sharedState = sharedState;
        this.options = options;
    }

    public boolean login() throws LoginException {
        Callback[] callbacks = new Callback[2];
        callbacks[0] = new NameCallback("username: ");
        callbacks[1] = new PasswordCallback("password: ", false);

        try {
            callbackHandler.handle(callbacks);

            String username = ((NameCallback) callbacks[0]).getName();
            String password = String.valueOf(((PasswordCallback) callbacks[1]).getPassword());

            // 验证用户名和密码，通过返回true
            if ("admin".equals(username) && "123456".equals(password)) {
                this.username = username;
                return true;
            } else {
                throw new LoginException("Invalid username or password");
            }
        } catch (UnsupportedCallbackException | IOException e) {
            e.printStackTrace();
            throw new LoginException(e.getMessage());
        }
    }

    public boolean commit() throws LoginException {
        subject.getPrincipals().add(new SimplePrincipal(username));
        return true;
    }

    public boolean abort() throws LoginException {
        return true;
    }

    public boolean logout() throws LoginException {
        subject.getPrincipals().removeIf(principal -> principal.getName().equals(username));
        return true;
    }

}

Unter anderem implementieren wir die Benutzerauthentifizierung und -autorisierung, indem wir die Methoden in der LoginModule-Schnittstelle implementieren. Bei der Anmeldemethode verwenden wir den CallbackHandler, um den vom Benutzer eingegebenen Benutzernamen und das Kennwort abzurufen und zu authentifizieren. Bei der Festschreibungsmethode fügen wir die Benutzerinformationen zur späteren Rollenautorisierung hinzu.

3. Rollenautorisierung implementieren

Als nächstes muss die Rollenautorisierung für bestimmte API-Schnittstellen durchgeführt werden. Wir können die von Java EE bereitgestellten Annotationen für die Autorisierung verwenden, wie zum Beispiel:

@RolesAllowed({"admin","user"})
@Path("/api/hello")
public class HelloResource {

    @GET
    public Response greet() {
        return Response.ok("Hello World!").build();
    }

}

Im obigen Beispiel verwenden wir die Annotation @RolesAllowed, um die Zugriffsrolle der API anzugeben. Nur Benutzer mit den Rollen „Administrator“ und „Benutzer“ können auf die API zugreifen Schnittstelle.

4. Konfigurieren Sie den Anwendungsserver

Um schließlich JAAS-Unterstützung auf dem Anwendungsserver hinzuzufügen, können wir die folgende Konfiguration in server.xml hinzufügen:

<server>
  ...
  <featureManager>
    ...
    <feature>appSecurity-2.0</feature>
  </featureManager>
  ...
</server>

Fügen Sie den folgenden Code in web.xml hinzu:

<login-config>
  <auth-method>FORM</auth-method>
  <realm-name>sampleRealm</realm-name>
  <form-login-config>
    <form-login-page>/login.html</form-login-page>
    <form-error-page>/error.html</form-error-page>
  </form-login-config>
</login-config>

<security-constraint>
  <web-resource-collection>
    <web-resource-name>helloResource</web-resource-name>
    <url-pattern>/api/hello</url-pattern>
  </web-resource-collection>
  <auth-constraint>
    <role-name>admin</role-name>
    <role-name>user</role-name>
</auth-constraint>

Im Obigen In der Konfiguration haben wir die Verwendung der FORM-Authentifizierungsmethode angegeben und die entsprechende Seite für die Seite bereitgestellt. Gleichzeitig müssen Sie auch eine Sicherheitseinschränkung angeben, um die Rolle der /hello-API zu autorisieren.

Zu diesem Zeitpunkt haben wir die Konfiguration der API-Mehrrollen-Berechtigungsverwaltung abgeschlossen.

Zusammenfassung

JAAS-Framework ist die Abkürzung für Java Authentication and Authorization Service. Es ist eine der Java SE-Standard-APIs und wird hauptsächlich zur Authentifizierung und Autorisierung von Anwendungen verwendet. In der Java-Back-End-Entwicklung kann die Rollenautorisierung mithilfe des JAAS-Frameworks für die API-Mehrrollen-Berechtigungsverwaltung problemlos implementiert werden. Wir haben einen rollenbasierten Berechtigungskontrollmechanismus über Konfigurations- und Richtlinienquellen implementiert, die LoginModule-Schnittstelle für die Identitätsauthentifizierung und -autorisierung verwendet und Anmerkungen für die API-Rollenautorisierung verwendet. Durch die Konfiguration des Anwendungsservers haben wir schließlich die API-Mehrrollen-Berechtigungsverwaltung implementiert.

Das obige ist der detaillierte Inhalt vonJava-Backend-Entwicklung: Verwendung des Java Authentication and Authorization Service für die API-Mehrrollen-Berechtigungsverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!