Ceci est une continuation de Dernier message. Lors de la création d'une application Web, vous souhaitez souvent enregistrer les informations utilisateur et restreindre l'accès aux pages. Cette fois, j'ai essayé d'implémenter la fonction d'authentification à l'aide de Play Framework. La source peut être trouvée sur GitHub.

Fonctions à réaliser

--Enregistrement des informations utilisateur et authentification par vérification (article précédent)

Accès restreint à l'écran d'accueil
Transfert de l'autorité d'authentification lorsque le même utilisateur que l'utilisateur authentifiant se connecte à partir d'un autre navigateur

Dans le post précédent, j'ai écrit sur l'enregistrement des informations utilisateur dans la base de données et la connexion. Une fois connecté, l'écran passe à l'écran d'accueil, mais il arrive parfois que seul l'utilisateur connecté (navigateur avec authentification des informations utilisateur) accède à l'écran d'accueil. Dans cet article, j'aimerais voir la session du navigateur et juger s'il s'authentifie actuellement ou non et effectuer la transition d'écran.

Je veux faire une transition à peu près comme ça. Dans Play, la session correspond aux informations détenues par le cookie du navigateur et le cache correspond aux informations conservées dans la mémoire du serveur.

Émission d'UUID

Vous devez identifier votre navigateur pour restreindre l'accès. Pour cela, je voudrais émettre un UUID et l'avoir dans la session. Il implémente l'interface play.http.ActionCreator. Définissez ensuite le nom de la classe implémentée dans application.conf.

`AppActionCreator.java`


package common.global;

//instruction d'importation omise

public class AppActionCreator implements ActionCreator {
	/**Clé de session UUID*/
	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) {
            	/*
            	 *Si l'UUID n'existe pas dans la session
            	 *Générez un UUID et définissez-le dans la session.
            	 */
                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"
}

Si vous implémentez cette interface, elle passera par elle avant de recevoir une demande et d'entrer des routes. Si la session n'a pas d'UUID, émettez un UUID et définissez-le dans la session. J'utilise java.util.UUID pour générer ___UUID, mais il n'y a aucune garantie que l'UUID généré par celui-ci soit complètement unique (bien qu'il soit extrêmement improbable qu'il ne soit pas unique). Nous ne discuterons pas ici de l'opportunité de la méthode d'émission d'UUID, mais lors de sa mise en œuvre, considérons la méthode d'émission d'UUID appropriée. ___

Conservation des informations utilisateur authentifiées

Une fois que vous pouvez identifier un navigateur, vous devez savoir quelles informations utilisateur il a utilisées pour s'authentifier. Pour ce faire, enregistrez les informations utilisateur authentifiées par la connexion et l'UUID du navigateur qui a effectué la demande dans le cache du serveur. Cela est fait par setCacheUser (utilisateur) dans le processus POST de SigninController.java.

`SigninController.java`


package controllers;

//instruction d'importation omise

@Singleton
public class SigninController extends AppController {

    //Omettre des membres autres que le stockage en cache

	/**Clé d'informations utilisateur*/
	public static final String USER_KEY = "USER";
	
	/**
	 *Enregistrer les informations utilisateur dans le cache
	 * @informations utilisateur param utilisateur
	 */
	public void setCacheUser(User user){
		setCache(USER_KEY, user);
		this.cache.set((USER_KEY + user.id), getClientId(), savetime);
	}
	
	/**
	 *Obtenir des informations utilisateur à partir du cache
	 * @retourner les informations utilisateur
	 */
	public User getCacheUser(){
		Object objectUser = getCache(USER_KEY);
		if(objectUser == null) return null;
		
		/*
		 *Avec l'UUID de session du navigateur qui a enregistré les informations utilisateur
		 *Comparez les UUID des sessions auxquelles vous accédez actuellement et
		 *S'ils sont différents, les informations utilisateur ne sont pas acquises.
		 */
		User user = User.class.cast(objectUser);
		String uuid = this.cache.get(USER_KEY + user.id).toString();
		if(!uuid.equals(getClientId())) return null;
		
		return user;
	}
	
	/**
	 *Effacer les informations utilisateur dans le cache
	 */
	public void clearCacheUser(){
		clearCache(USER_KEY);
	}
	
}

Enregistrez l'UUID de session à l'aide de l'ID utilisateur enregistré lors de l'enregistrement des informations utilisateur en tant que clé, obtenez l'UUID du cache à partir de l'ID utilisateur obtenu lors de l'acquisition des informations utilisateur, comparez-le avec l'UUID de session et, s'il s'agit d'un UUID différent, entrez les informations utilisateur. Je ne te laisserai pas l'obtenir. Cela empêche plusieurs navigateurs d'être authentifiés avec une seule information utilisateur en même temps.

Restrictions

Une fois que vous avez identifié votre navigateur et conservé vos informations utilisateur, il ne vous reste plus qu'à vérifier votre authentification lorsque vous accédez à la page que vous souhaitez restreindre. Vous pouvez le faire avec Play en utilisant le package play.mvc.Security. Tout d'abord, créez une classe qui hérite d'Authenticator et implémentez deux méthodes.

`AppAuthenticator.java`


package common.secure;

//instruction d'importation omise

public class AppAuthenticator extends Authenticator {
	/**cache*/
	private CacheApi cache;
	@Inject
	public AppAuthenticator(CacheApi cache){
		this.cache = cache;
	}
	
	@Override
	public String getUsername(Context ctx) {
		/*
		 *Obtenez des informations utilisateur à partir du cache.
		 *Si les informations utilisateur existent, elles sont considérées comme authentifiées et l'accès est autorisé.
		 */
		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) {
		/*
		 *Si l'accès n'est pas accordé
		 *Redirigez-vous vers l'écran de connexion.
		 */
		return redirect(routes.SigninController.get());
	}
}

Si vous renvoyez une chaîne avec getUsername (), vous avez l'autorisation. Si null est retourné, onUnauthorized () sera appelé. Il ne vous reste plus qu'à ajouter une annotation authentifiée au contrôleur d'écran d'accueil que vous souhaitez limiter.

`IndexController.java`


package controllers;

//instruction d'importation omise

@Singleton
public class IndexController extends AppController {
	@Inject
	public IndexController(CacheApi cache) {
		super(cache);
	}

	@Authenticated(AppAuthenticator.class) // <-cette
	@Override
    public Result get() {
		/*
		 *Créez un écran d'accueil avec les informations utilisateur et renvoyez-le.
		 */
		User user = new SigninController(cache).getCacheUser();
        return ok(views.html.index.render(user));
    }

	@Authenticated(AppAuthenticator.class) // <-cette
	@Override
	public Result post() {
		/*
		 *Effacer les informations utilisateur du cache
		 *Redirigez-vous vers l'écran de connexion.
		 */
		new SigninController(cache).clearCacheUser();
		return redirect(routes.SigninController.get());
	}

}

Ajoutez simplement une annotation au processus que vous souhaitez restreindre et spécifiez la classe qui implémente la vérification d'authentification pour restreindre l'accès.

finalement

Je pense qu'il existe de nombreuses autres façons d'authentifier les utilisateurs, mais cette fois, j'ai implémenté la connexion et l'inscription la plus simple et la plus simple. J'espère que cela vous sera utile. GitHub

[JAVA] Fonction d'authentification avec Play Framework [Restrictions d'accès]

Fonctions à réaliser

Émission d'UUID

AppActionCreator.java

conf/application.conf