web-dev-qa-db-fra.com

Quelle est la meilleure approche pour créer une application Web basée sur les rôles?

Je dois créer une application Web pour une école et avoir différents rôles, tels que:

  • Étudiant
  • Professeur
  • Admin

J'ai besoin d'un identifiant au début, puis après la saisie des informations d'identification, l'application doit rediriger vers la page d'accueil. 

La question ici est: comment devrais-je gérer les rôles? Dois-je avoir un espace de noms pour chaque rôle? c.-à-d. étudiants/index.jsp, professeurs/index.jsp, admin/index.jsp ou avez-vous un espace de noms commun pour tous les rôles? quelque chose comme home/index.jsp? puis utilisez décorateur/motif composite pour que les menus aient différentes options en fonction du rôle?

Pour cette question, je sais que je dois stocker les utilisateurs et les rôles, chacun dans sa propre table. Cette question est plus en rapport avec la gestion des rôles de présentation/navigation/permission et la création d'une structure webapp, c.-à-d. appelé les étudiants, un autre dossier administrateur, et un autre étudiants et sur le point que j'ai mentionné ci-dessus (décorateur ou modèle composite)

Bien sûr, je ne fais pas une application aussi petite, mais je voulais simplifier les problèmes auxquels je suis confronté afin de créer une application Web grand rôle, et je crois que ce sont les principes principaux.

Merci pour votre temps et votre aide. 

javawebloginroles
12
Diego Ramos

Vous ne souhaitez certainement PAS avoir des pages séparées ("espaces de noms") pour différents rôles, car cela entraînerait presque inévitablement une duplication du code. 

Vous devriez avoir une page pour chaque fonction et restreindre l'accès en fonction des rôles des utilisateurs. (Par exemple, certains éléments de menu ne sont pas visibles pour un étudiant, mais affichés pour les professeurs et les administrateurs.)

Vous ne devez absolument pas essayer de réinventer la roue pour la gestion des autorisations basées sur les rôles, car il existe des infrastructures éprouvées à cette fin: comme d'autres l'ont déjà souligné, dans le monde Java, Spring et Spring Security est la voie à suivre.

Je pense que JSP en tant que technologie vieillit, vous devriez donc probablement commencer à apprendre Angular à la place. 

Etant donné que l’installation d’un projet Spring/Angular fonctionnel n’est pas triviale, je vous recommande d’utiliser le générateur d’applications JHipster qui vous guide tout au long du processus à l’aide d’un assistant (vous devez simplement répondre à quelques questions type select monolithic web application): il crée ensuite une configuration de projet opérationnelle avec une sécurité basée sur les rôles mise en place conformément aux recommandations modernes.

Si vous souhaitez en savoir plus sur le contrôle d'accès basé sur les rôles approprié dans une application Web moderne, vous trouverez, à mon avis, les solutions utilisées dans une application générée par JHipster:

  • il utilise les fonctionnalités de Spring Security pour limiter les appels dans Java backend: recherchez les utilisations de l'annotation org.springframework.security.access.annotation.Secured dans le projet généré.
  • montre quelques astuces personnalisées pour afficher/masquer certaines UIparts basées sur des rôles, comme ceci: <h1 *jhiHasAnyAuthority="'ROLE_ADMIN'">Hello, admin user</h1>, que vous pourriez facilement adopter pour votre propre cas d'utilisation.
  • vous pouvez avoir un projet en 2 minutes: idéal pour apprendre (optez pour le plus simple monolithic web application!)
10
Peter G. Horvath

Il n'y a pas de réponse unique à votre question. Tout dépend de la structure du projet. S'il y a beaucoup de points communs entre les rôles que vous avez mentionnés, il est préférable d'utiliser un seul index.jsp pour tous les rôles. Ensuite, vous ne devez pas dupliquer la logique commune (bibliothèques js et css, scripts communs personnalisés, vues et inclusion de styles). S'il y a peu de points communs entre les rôles, il est préférable de disposer de fichiers index.jsp distincts pour chaque rôle, puisqu'un fichier index.jsp unique sera créé de manière dynamique lors de l'exécution du programme en fonction du rôle sélectionné (je pense que c'est toujours possible. réparer en mettant en cache).

Dans nos projets, nous utilisons une approche avec un seul fichier index.jsp. Cela est dû en premier lieu au fait qu’ils ont beaucoup de logique commune. Mais dans tous les cas, la décision sera prise par vous.

De plus, si vous utilisez Spring Security et qu'il est possible d'ajouter de nouveaux rôles au cours du processus de développement du projet, l'approche @PreAuthorize ("hasRole ('ROLE_USER')") ne sera pas bonne. Parce que si vous ajoutez un nouveau rôle à la base de données, vous devrez ajouter beaucoup de code au projet pour accorder l’accès requis à ce nouveau rôle. Donc, dans ce cas, il sera préférable d’accorder l’accès via des autorisations. Et créer une relation many to many entre roles <-> permissions

1
Bohdan Petrenko

Je ne suis pas sûr que ma solution ira à l'encontre de votre problème. Mais dans mon cas, je le fais comme suit:

Utilisateur 0..n --- 0..m Rôle

Rôle 0..n --- 0..m Privilège

Code de production

Dans votre cas, vous voudrez peut-être:

  • Admin ne peut pas voir, éditer le score d'un élève.
  • Student peut voir le score mais ne peut pas l'éditer.
  • Professor peut voir, éditer, ajouter un score.

Vous pouvez faire comme ci-dessous:

Rôle

  • ROLE_SCORE_EDITOR
  • ROLE_SCORE_VIEWER

Privilège

  • OP_READ_SCORE
  • OP_CREATE_SCORE
  • OP_UPDATE_SCORE
  • OP_DELETE_SCORE ---> Probablement pas besoin de celui-ci mais cela suffit pour un exemple.

Rôle - Privilège

ROLE_SCORE_EDITOR

  • OP_READ_SCORE
  • OP_CREATE_SCORE
  • OP_UPDATE_SCORE

ROLE_SCORE_VIEWER

  • OP_READ_SCORE

Rôle d'utilisateur

Admin (ça dépend vraiment de vous, dans mon cas je devrais le laisser vide)

Professeur

  • ROLE_SCORE_EDITOR

Studen

  • ROLE_SCORE_VIEWER

Ensuite, dans votre modèle, gardez votre vue avec user.hasPrivilege ou user.hasRole. Cela fonctionnera bien.

P/s: Désolé pour mon mauvais anglais. Si vous avez besoin de quelque chose s'il vous plaît commenter ci-dessous ou commenter dans mon Gist

1
Liem Le

Vous pouvez créer différents rôles pour donner accès à différentes zones restreintes. Par exemple, vous pouvez avoir des rôles Étudiant, Professeur et Administrateur. Plus tard, vous pourrez autoriser ou empêcher l'accès au contenu en fonction des rôles. Spring Security peut être bon pour vous. 

1
amanzoor

La meilleure approche serait: Spring Security

Mais il faut du temps et des études pour le faire correctement, alors jusque-là je fais quelque chose comme ça:

  1. Supposons que vous ayez une table utilisateur dans votre base de données. Ajoutez un nom de colonne, par exemple. droits de l'utilisateur.
  2. Dans votre application, cette colonne est un champ de votre classe de modèle Utilisateur.
  3. Créez une méthode qui vérifie ce champ et gère les rôles comme vous le souhaitez

Par exemple, si un rôle d'utilisateur détermine sur quelles pages il a accès, il s'agit d'un exemple de code simplifié:

Au début de votre page Web:

<h:body>

<f:metadata>
    <f:viewAction action="#{userService.checkIfLogged()}" />
    <f:viewAction action="#{userService.accessCheck('page 2')}" />
</f:metadata>

et dans votre méthode de haricot:

@Override
@Transactional
public String accessCheck(String page) {
    try {
       HttpSession sess = Util.getSession();
       String user = sess.getAttribute("username").toString();
       Session session = this.sessionFactory.getCurrentSession();
       User logged = (User) session.createQuery("select u from User u where 
                     u.username = :logged").setParameter("logged", 
                                            user).uniqueResult();
       if (page.equals("page 1")) {
        if (logged.getRights().equals("simple")) {
            return "profile?faces-redirect=true";
        } 
        else {
            return "#";
        }
    }   ... etc.

J'espère que cela vous aidera, je recommande toujours les fonctionnalités de Spring Framework, mais en attendant, cela me convient parfaitement pour les petites applications Web.

0
Maral Kay

Essayez de développer votre application Web en utilisant Spring Framework et Spring Security Veuillez vous reporter à l'exemple ci-dessous http://websystique.com/spring-security/spring-security-4-role-based-login-example/

0
Sumesh TG

Il existe plusieurs approches pour résoudre ce problème. Par exemple, vous pouvez utiliser un filtre pour authentifier et autoriser l'accès de vos ressources à différents utilisateurs/rôles. En dehors de cela, Spring Security fournit un mécanisme intégré pour garantir un accès autorisé aux ressources Web. En dehors de cela, vous pouvez créer un panneau d’administrateur dans votre application et attribuer différentes pages à différents rôles (mais cette approche implique davantage de travail de programmation). Vous pouvez également penser à créer des contraintes de sécurité dans web.xml et vous pouvez associer des collections de ressources Web à différents rôles. 

0
Dr. Muhammad Wasim Bhatti

Je crois que vous devriez aller de l'avant avec Spring Security. Il vous fournit de nombreuses fonctionnalités prêtes à l'emploi et la configuration et la maintenance de votre application deviennent tellement plus simples. En outre, vous pourrez vous concentrer davantage sur la construction de la logique de votre application pendant que la bibliothèque gère pour vous l'authentification et l'autorisation (les rôles en mots simples). De plus, il bénéficie d'un soutien important de la part de la communauté.

Voici un exemple pour commencer: Sécurité de printemps - hello world

Dans l'exemple ci-dessus, laissez-moi vous montrer un extrait de code pour donner plus de poids à ma revendication:

@Override
    protected void configure(HttpSecurity http) throws Exception {

      http.authorizeRequests()
        .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')")
        .antMatchers("/dba/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_DBA')")
        .and().formLogin();

    }

Donc ce que la configuration ci-dessus va faire est, chaque fois que vous essayez d’accéder à la page /admin ou à une URL quelconque sous les pages d’administration, par exemple /admin/profile, /admin/home etc., il vous sera demandé de vous authentifier (avec un nom d'utilisateur et un mot de passe dans votre cas). La sécurité de printemps vérifiera si le nom d'utilisateur et le mot de passe sont corrects. En plus de cela, il vérifiera également si le nom d'utilisateur fourni a le rôle admin. Si les deux vérifie (mot de passe et rôle) réussit, alors seulement vous serez autorisé à accéder à cette page.

Ainsi, avec seulement quelques lignes de code, vous contrôlez toute la sécurité grâce à la gestion des rôles de votre application. 

Bien que dans l'exemple de poste, des noms d'utilisateur codés en dur soient utilisés, mais il est également assez facile de brancher votre base de données. Mais l'exemple est un bon moyen de commencer et de voir par vous-même s'il convient à votre cas d'utilisation.

0
tryingToLearn

vous pouvez créer une table basée nommée comme role_user basée sur ce que vous pouvez séparer

différents rôles 

0
rohit raj

Avoir différentes pages viole le principe DRY (ne vous répétez pas) ... Si vous voulez une solution simple, ajoutez des filtres dans votre application Web et faites votre autorisation là-bas (délégué à une application tierce). Vous devez ajouter des conditions dans la page jsp au niveau du groupe afin d'éviter de les modifier à chaque fois.

Vous pouvez également utiliser la sécurité Spring et l'authentification JDBC.

0
DevEmani

Je suis dans une situation similaire en ce moment. Mes projets nécessitent une authentification et une autorisation basée sur les rôles. Un certain nombre de solutions sont disponibles pour les applications Java. Notre équipe a décidé d'utiliser Keycloak , qui est une application supplémentaire permettant de gérer la plupart des tâches de gestion des utilisateurs. Il peut fonctionner sur un serveur séparé. Toutefois, en fonction de la portée de votre application, cela peut être excessif.

À mon avis, vous n'avez encore implémenté aucune authentification. Cette partie est terminée dans mon cas et elle s’est principalement effectuée via la configuration du serveur Web Keycloak +. 

En règle générale, vous pouvez utiliser la sécurité Java EE pour l'autorisation dans la plupart des serveurs Web modernes. Cela vous permettra d'utiliser des annotations telles que @RolesAllowed pour accorder ou refuser l'accès et peut fonctionner indépendamment de Keycloak. Exemples . De cette façon, vous pouvez conserver une structure unifiée pour tous vos différents rôles et décider de la légitimité d'une demande juste avant son exécution.

0
P Laack