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 avoir saisi les informations d’identification, l’application doit redirect vers la page d’accueil.

La question ici est: comment dois-je gérer les rôles? Dois-je avoir un espace de noms pour chaque rôle? c’est-à-dire: students / index.jsp, professor / 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 / modèle 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 liée aux rôles de traitement de présentation / navigation / permission et à la création de la structure webapp. appelé étudiants, un autre dossier administrateur et un autre étudiant et concernant le point que j’ai mentionné ci-dessus (motif décoratif ou 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.

Vous ne voulez certainement PAS avoir des pages séparées (“espaces de noms”) pour différents rôles, car cela conduirait presque inévitablement à la duplication de code.

Vous devriez avoir une page pour chaque fonction et restreindre l’access 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 permissions basées sur les rôles, car il existe des frameworks éprouvés au combat: comme d’autres l’ont déjà souligné, dans le monde Java, Spring and Spring Security est la solution.

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

Comme la configuration d’un projet Spring / Angular n’est pas anodine, 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 (il vous suffit de répondre à quelques questions. Lorsque vous êtes interrogé sur le type, sélectionnez 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’access 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 restreindre les appels dans le backend Java: recherchez les org.springframework.security.access.annotation.Secured annotation org.springframework.security.access.annotation.Secured dans le projet généré
  • affiche quelques astuces personnalisées pour afficher / masquer certaines parties de l’interface utilisateur en fonction de rôles, comme ceci:

    Hello, admin user

    , 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 l’ monolithic web application la plus simple!)

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, inclusion de vues et 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 dynamic pendant 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’append de nouveaux rôles au cours du processus de développement du projet, l’ @PreAuthorize ("hasRole ('ROLE_USER')") ne sera pas bonne. Parce que si vous ajoutez un nouveau rôle à la firebase database, vous devrez append beaucoup de code au projet pour accorder l’access requirejs à ce nouveau rôle. Donc, dans ce cas, il sera préférable d’accorder l’access via des permissions. Et créer des relations many to many entre les roles <-> permissions

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 étudiant.
  • Student peut voir le score mais ne peut pas l’éditer.
  • Professor peut voir, éditer, append 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, user.hasPrivilege 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 essence

Vous pouvez créer différents rôles pour donner access à 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’access au contenu en fonction des rôles. La sécurité de spring peut être bonne pour vous.

Avoir différentes pages viole le principe DRY (ne vous répétez pas). Si vous souhaitez une solution simple, ajoutez des filtres dans votre application Web et faites-y votre autorisation (déléguer à une application tierce). Vous devez append 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.

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

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 , 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 scope 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’access 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.

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/

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 se charge de l’authentification et de l’autorisation (les rôles en mots simples). De plus, il a beaucoup de soutien de la communauté.

Voici un exemple pour commencer: Sécurité de spring – Bonjour tout le monde

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 que, chaque fois que vous essayez d’accéder à la page /admin ou à une URL sous les pages admin, 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 ton cas). La sécurité de spring 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 pour votre application.

Bien que dans l’exemple de poste, des noms d’utilisateur codés en dur soient utilisés, mais il est également très facile de twigr votre firebase database. Mais cet exemple est un bon moyen de commencer et de voir par vous-même s’il convient à votre cas d’utilisation.

Il existe plusieurs approches pour résoudre ce problème. Par exemple, vous pouvez utiliser un filtre pour authentifier et autoriser l’access de vos ressources à différents utilisateurs / rôles. En dehors de cela, Spring Security fournit un mécanisme intégré pour garantir un access autorisé aux ressources Web. En dehors de cela, vous pouvez créer un panneau d’administrateur dans votre application et affecter 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.

La meilleure approche serait: la sécurité du spring

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 un utilisateur de table dans votre firebase database. Ajoutez un nom de colonne, par exemple, user_rights .
  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 access, il s’agit d’un exemple de code simplifié:

Au début de votre page Web:

      

et dans votre méthode de haricot:

 @Override @Transactional public Ssortingng accessCheck(Ssortingng page) { try { HttpSession sess = Util.getSession(); Ssortingng user = sess.getAtsortingbute("username").toSsortingng(); 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.

Vous pouvez utiliser un champ dans votre firebase database qui enregistre le rôle, mais vous pouvez en savoir plus sur ACL et RBAC.

Je recommanderai de jeter un coup d’œil à la sécurité de spring https://projects.spring.io/spring-security/#quick-start

Bonne question. En réalité, l’extension de ce module est complète. Pour votre petit cas, une page commune est la meilleure solution. Selon le rôle souhaité, des zones de texte ou des champs apparaissent. Par exemple, dans le cas où Role Student: subject, le numéro de rôle sera disponible. Mais si le professeur se connecte à la même page, il peut voir des champs supplémentaires tels que des chiffres, des présences, etc. La solution la plus simple peut être: Créer une table maîtresse, avec Nom, Id, TYPE (Entrez ici si étudiant / Professeur / Administrateur, etc.). ), et utilisez ce TYPE comme facteur décisif pour l’affichage des champs.