[JAVA] Authentifizierungsfunktion mit Play Framework [Zugriffsbeschränkungen]
Dies ist eine Fortsetzung von Last Post. Beim Erstellen einer Webanwendung möchten Sie häufig Benutzerinformationen registrieren und den Seitenzugriff einschränken. Dieses Mal habe ich versucht, die Authentifizierungsfunktion mit Play Framework zu implementieren. Die Quelle finden Sie unter GitHub.
Zu realisierende Funktionen
- Registrierung von Benutzerinformationen und Authentifizierung durch Überprüfung (vorheriger Beitrag)
- Eingeschränkter Zugriff auf den Startbildschirm
- Übertragung der Authentifizierungsberechtigung, wenn sich derselbe Benutzer wie der authentifizierende Benutzer von einem anderen Browser aus anmeldet
Im vorherigen Beitrag habe ich über das Speichern von Benutzerinformationen in der Datenbank und das Anmelden geschrieben. Nach der Anmeldung wechselt der Bildschirm zum Startbildschirm. Manchmal möchten Sie jedoch, dass nur der angemeldete Benutzer (Browser mit Benutzerinformationsauthentifizierung) auf den Startbildschirm zugreift. In diesem Beitrag möchte ich die Sitzung des Browsers sehen und beurteilen, ob er sich derzeit authentifiziert oder nicht, und den Bildschirmübergang durchführen.
Ich möchte ungefähr so einen Übergang machen. In Play sind die Sitzungen die Informationen, die im Cookie des Browsers enthalten sind, und der Cache sind die Informationen, die im Serverspeicher gespeichert sind.
UUID-Ausgabe
Sie müssen Ihren Browser identifizieren, um den Zugriff einzuschränken. Dafür möchte ich eine UUID ausstellen und in der Sitzung haben. Es implementiert die Schnittstelle play.http.ActionCreator. Definieren Sie dann den implementierten Klassennamen in application.conf.
AppActionCreator.java
package common.global;
//Importanweisung weggelassen
public class AppActionCreator implements ActionCreator {
/**UUID-Sitzungsschlüssel*/
public static final String UUID = "UUID";
@Override
public Action<?> createAction(Request arg0, Method arg1) {
return new Action.Simple() {
@Override
public CompletionStage<Result> call(Http.Context ctx) {
/*
*Wenn die UUID in der Sitzung nicht vorhanden ist
*Generieren Sie eine UUID und legen Sie sie in der Sitzung fest.
*/
if(ctx.session().get(UUID) == null){
String uuid = java.util.UUID.randomUUID().toString();
ctx.session().put(UUID, uuid);
}
return delegate.call(ctx);
}
};
}
}
conf/application.conf
play.http {
actionCreator = "common.global.AppActionCreator"
}
Wenn Sie diese Schnittstelle implementieren, wird sie durchlaufen, bevor eine Anforderung empfangen und Routen eingegeben werden. Wenn die Sitzung keine UUID hat, geben Sie eine UUID aus und legen Sie sie in der Sitzung fest. Ich verwende java.util.UUID, um ___UUID zu generieren, aber es gibt keine Garantie dafür, dass die dadurch generierte UUID vollständig eindeutig ist (obwohl es äußerst unwahrscheinlich ist, dass sie nicht eindeutig ist). Wir werden hier nicht diskutieren, ob es für die UUID-Ausgabemethode geeignet ist, aber bei der Implementierung die entsprechende UUID-Ausstellungsmethode berücksichtigen. ___
Aufbewahrung authentifizierter Benutzerinformationen
Sobald Sie den Browser identifizieren können, müssen Sie wissen, mit welchen Benutzerinformationen der Browser authentifiziert wurde. Speichern Sie dazu die durch Anmeldung authentifizierten Benutzerinformationen und die UUID des Browsers, der die Anforderung gestellt hat, im Server-Cache. Dies erfolgt durch setCacheUser (Benutzer) im POST-Prozess von SigninController.java.
SigninController.java
package controllers;
//Importanweisung weggelassen
@Singleton
public class SigninController extends AppController {
//Auslassen anderer Mitglieder als des Cache-Speichers
/**Benutzerinformationsschlüssel*/
public static final String USER_KEY = "USER";
/**
*Speichern Sie Benutzerinformationen im Cache
* @param Benutzer Benutzerinformationen
*/
public void setCacheUser(User user){
setCache(USER_KEY, user);
this.cache.set((USER_KEY + user.id), getClientId(), savetime);
}
/**
*Benutzerinformationen aus dem Cache abrufen
* @Benutzerinformationen zurückgeben
*/
public User getCacheUser(){
Object objectUser = getCache(USER_KEY);
if(objectUser == null) return null;
/*
*Mit der Sitzungs-UUID des Browsers, der die Benutzerinformationen gespeichert hat
*Vergleichen Sie die UUIDs der Sitzungen, auf die Sie gerade zugreifen, und
*Wenn sie unterschiedlich sind, werden die Benutzerinformationen nicht erfasst.
*/
User user = User.class.cast(objectUser);
String uuid = this.cache.get(USER_KEY + user.id).toString();
if(!uuid.equals(getClientId())) return null;
return user;
}
/**
*Benutzerinformationen im Cache löschen
*/
public void clearCacheUser(){
clearCache(USER_KEY);
}
}
Speichern Sie die Sitzungs-UUID mit der Benutzer-ID, die beim Speichern von Benutzerinformationen als Schlüssel gespeichert wurde, rufen Sie die UUID aus dem Cache aus der Benutzer-ID ab, die Sie beim Abrufen von Benutzerinformationen erhalten haben, vergleichen Sie sie mit der Sitzungs-UUID, und geben Sie die Benutzerinformationen ein, wenn es sich um eine andere UUID handelt. Ich werde nicht zulassen, dass du es bekommst. Dadurch wird verhindert, dass mehrere Browser gleichzeitig mit einer Benutzerinformation authentifiziert werden.
Beschränkungen
Nachdem Sie Ihren Browser identifiziert und Ihre Benutzerinformationen beibehalten haben, müssen Sie lediglich Ihre Authentifizierung überprüfen, wenn Sie auf die Seite zugreifen, die Sie einschränken möchten. Sie können dies mit Play mit dem Paket play.mvc.Security tun. Erstellen Sie zunächst eine Klasse, die Authenticator erbt, und implementieren Sie zwei Methoden.
AppAuthenticator.java
package common.secure;
//Importanweisung weggelassen
public class AppAuthenticator extends Authenticator {
/**Zwischenspeicher*/
private CacheApi cache;
@Inject
public AppAuthenticator(CacheApi cache){
this.cache = cache;
}
@Override
public String getUsername(Context ctx) {
/*
*Benutzerinformationen aus dem Cache abrufen.
*Wenn die Benutzerinformationen vorhanden sind, gelten sie als authentifiziert und der Zugriff ist zulässig.
*/
SigninController signinController = new SigninController(cache);
User user = signinController.getCacheUser();
if(user != null){
signinController.setCacheUser(user);
return user.toString();
}else{
return null;
}
}
@Override
public Result onUnauthorized(Context ctx) {
/*
*Wenn der Zugriff nicht gewährt wird
*Weiterleiten zum Anmeldebildschirm.
*/
return redirect(routes.SigninController.get());
}
}
Wenn Sie eine Zeichenfolge mit getUsername () zurückgeben, haben Sie die Berechtigung. Wenn null zurückgegeben wird, wird onUnauthorized () aufgerufen. Jetzt müssen Sie nur noch eine authentifizierte Anmerkung zum Startbildschirm-Controller hinzufügen, den Sie einschränken möchten.
IndexController.java
package controllers;
//Importanweisung weggelassen
@Singleton
public class IndexController extends AppController {
@Inject
public IndexController(CacheApi cache) {
super(cache);
}
@Authenticated(AppAuthenticator.class) // <-Dies
@Override
public Result get() {
/*
*Erstellen Sie einen Startbildschirm mit Benutzerinformationen und geben Sie diese zurück.
*/
User user = new SigninController(cache).getCacheUser();
return ok(views.html.index.render(user));
}
@Authenticated(AppAuthenticator.class) // <-Dies
@Override
public Result post() {
/*
*Löschen Sie Benutzerinformationen aus dem Cache
*Weiterleiten zum Anmeldebildschirm.
*/
new SigninController(cache).clearCacheUser();
return redirect(routes.SigninController.get());
}
}
Fügen Sie dem Prozess, den Sie einschränken möchten, einfach eine Anmerkung hinzu und geben Sie die Klasse an, die die Authentifizierungsüberprüfung implementiert, um den Zugriff einzuschränken.
Schließlich
Ich denke, es gibt viele andere Möglichkeiten, Benutzer zu authentifizieren, aber dieses Mal habe ich die einfachste und einfachste An- und Anmeldung implementiert. Ich hoffe es wird für Sie hilfreich sein. GitHub
Recommended Posts