Plateforme de Sécurité Éducative Basée sur le Framework SSM et Vue
Vue d'ensemble du système
Contexte de recherche
Avec le développement rapide des technologies informatiques et la généralisation progressive des réseaux informatiques, Internet est devenu un lieu essentiel pour la recherche d'informations. Le XXIème siècle est l'ère de l'information, rendant la gestion de l'information particulièrement importante. Par conséquent, l'utilisation d'ordinateurs pour gérer les informations d'une plateforme de sécurité éducative est devenue une nécessité. Le développement d'une plateforme de sécurité éducative appropriée peut faciliter la gestion administrative, améliorer l'efficacité de la gestion et des requêtes d'information, et permettre un meilleur service au public.
Objectifs de recherche
Avec le développement rapide des technologies Internet, l'avènement de l'ère numérique et la transformation de la société par les informations en ligne, divers secteurs convergent progressivement vers la normalisation et la numérisation dans leur gestion quotidienne. Le niveau de numérisation d'une plateforme de sécurité éducative se reflète dans l'application d'Internet et des technologies de l'information à la gestion et à l'exploitation, remplaçant les méthodes manuelles traditionnelles par des outils modernes. L'utilisation de la gestion numérique rend la gestion de l'information plus avancée, efficace et scientifique, avec une communication d'informations plus rapide.
La gestion traditionnelle des plateformes de sécurité éducative se faisait principalement par des méthodes manuelles, entraînant une faible efficacité et une fréquence élevée d'erreurs. Avec le temps, l'accumulation de données posait des problèmes pour leur sauvegarde, leur recherche, leur mise à jour et leur maintenance, créant également des risques importants lors du transfert de données. Une solution de stockage électronique apporterait une amélioration significative et faciliterait grandement les recherches des utilisateurs. Par conséquent, la conception d'une plateforme de sécurité éducative est une priorité absolue pour améliorer le niveau de gestion de l'information.
Principe de conception du système
Un site web réussi doit définir clairement son objectif, déterminer ses fonctionnalités, évaluer son envergure et les coûts d'investissement, et effectuer une analyse de marché nécessaire. Une planification détaillée permet d'éviter de nombreux problèmes lors du développement et assure une progression fluide. De plus, un grand système informatique doit disposer d'une orientation de conception appropriée, en sélectionnant raisonnablement les structures de données, les architectures réseau, les systèmes d'exploitation et les environnements de développement pour constituer une architecture réseau complète, maximisant ainsi les avantages de la gestion informatique. Selon les besoins réels des utilisateurs, la conception de ce système suit les principes suivants :
- Efficacité : Cela comprend deux aspects : l'utilité et la disponibilité. L'utilité fait référence aux fonctions potentielles du site qui peuvent répondre aux besoins des utilisateurs, tandis que la disponibilité permet d'atteindre des objectifs spécifiques par l'intermédiaire des opérations du site. Un site qui ne fonctionne pas correctement ou est mal conçu n'est pas un bon site. Un site efficace devrait être très performant, facile à apprendre et satisfaisant sans erreur dans l'atteinte des objectifs des utilisateurs.
- Haute fiabilité : Un site pratique doit également être fiable. Cette conception garantit la fiabilité et la tolérance aux pannes grâce à une conception réseau raisonnable et avancée, ainsi qu'à une optimisation matérielle et logicielle.
- Haute sécurité : La conception exploite pleinement les diverses mesures de sécurité fournies par le matériel et le logiciel réseau, garantissant à la fois le partage des ressources des utilisateurs et la prise en compte des exigences de continuité, de sauvegarde et de restauration du système et des données. Des outils puissants de sauvegarde de base de données sont fournis pour garantir la sécurité des données critiques. Des niveaux d'autorisation opérationnelle sont définis avec différents rôles pour assurer que chaque opération respecte les permissions, configurables par l'administrateur.
- Caractère avancé : L'utilisation des technologies de développement les plus avancées internationalement, telles que la technologie de développement JSP et MySQL comme base de données pour le site web. Ces technologies réduisent les coûts d'exploitation futurs du système et améliorent sa stabilité et sa facilité de maintenance.
- Utilisation de technologies standard : Toute la conception de ce site suit les normes internationales en vigueur pour améliorer l'ouverture du système.
- Équilibre entre apparence et technologie : Le système adopte une interface de style Web conviviale, esthétique et facile à utiliser. La clé de la conception de site web est l'équilibre entre l'apparence et la technologie. Un site peu attrayant est rebutant, même s'il fonctionne bien, il ne peut susciter l'enthousiasme des utilisateurs. Inversement, une apparence très expressive mais avec une technologie limitée décevra les utilisateurs. Il faut établir une relation claire et cohérente entre l'apparence et la technologie, où l'apparence est liée à l'intention du site, avec des traitements différents selon les types de sites.
Technologies associées
Base de données MySQL
MySQL est un véritable serveur de base de données SQL multi-utilisateurs et multi-threads. C'est un système de gestion de base de données relationnelle basé sur le mode client/serveur SQL. Ses avantages incluent une fonctionnalité puissante, une utilisation simple, une gestion pratique, une haute sécurité et fiabilité, une vitesse d'exécution rapide, un support multi-thread, une multiplateforme, une connectivité complète réseau, une grande stabilité, etc. Il est très adapté au développement de backends de base de données pour sites web ou autres applications logicielles. De plus, les utilisateurs peuvent écrire des programmes accédant à la base de données MySQL dans de nombreux langages. En tant que produit du mouvement du code source ouvert, le système de gestion de base de données relationnelle MySQL gagne en popularité et son champ d'application s'élargit constamment. La vitesse et la facilité d'utilisation rendent MySQL particulièrement adapté au développement de backends de base de données pour sites web ou applications logicielles.
La base de données MySQL présente les caractéristiques suivantes :
- Développée et testée en C et C++ pour assurer la portabilité et la flexibilité du code source.
- Supporte de nombreux systèmes d'exploitation tels qu'AIX, FreeBSD, HP-UX, Linux, Mac OS, NetWare, OpenBSD, OS/2, Solaris, Windows, etc.
- Fournit des API pour différents langages de programmation comme C, C++, Python, Java, Perl, PHP, Eiffel, Ruby et Tcl.
- Supporte le multithreading pour une utilisation efficace des ressources CPU.
- Optimisation des algorithmes de requête SQL pour améliorer considérablement la vitesse de recherche.
- Supporte plusieurs langues dont le chinois (GB2312, BIG5), le japonais (shift_jis) pour la programmation dans n'importe quel environnement de programmation réseau client/serveur, et permet l'utilisation de ces jeux de caractères comme noms de tables et autres éléments logiciels.
- Fournit des connexions à d'autres bases de données via TCP/IP, ODBC et JDBC.
- Outils de gestion pour contrôler et optimiser les opérations sur la base de données.
- Peut gérer des dizaines de millions d'enregistrements dans une grande base de données.
Architecture Client/Serveur (B/S)
L'architecture B/S est une architecture de développement de systèmes logiciels basée sur Internet, largement utilisée dans le développement de systèmes logiciels aujourd'hui. Elle a été adoptée en masse, dépassant l'architecture C/S et fournissant un excellent support pour les systèmes logiciels basés sur le réseau. L'architecture B/S s'est développée et mise à jour progressivement avec l'évolution des technologies réseau. Avec le développement d'Internet, la plupart des systèmes de gestion doivent non seulement pouvoir fonctionner sur un seul ordinateur, mais aussi être accessibles et exploitables sur d'autres ordinateurs connectés à Internet. Dans ce contexte, la méthode de conception de systèmes logiciels basée sur l'architecture B/S est de plus en plus utilisée, avec des mises à jour constantes de sa base.
L'architecture B/S utilise le navigateur du système d'exploitation, ce qui n'est pas un système logiciel basé sur des formulaires, et n'exige pas d'installation sur l'ordinateur utilisant le système. Le mode de fonctionnement de l'architecture B/S consiste à déployer le système logiciel développé sur un serveur distant. Une fois le système logiciel déployé, il devient accessible sur n'importe quel ordinateur connecté à Internet. L'architecture B/S apporte une grande commodité aux utilisateurs des systèmes de gestion.
Dans les systèmes B/S (Browser/Server, architecture navigateur/serveur) à trois couches, les utilisateurs peuvent envoyer des requêtes à de nombreux serveurs distribués sur le réseau via un navigateur. Le système B/S simplifie considérablement la charge du client, qui n'a besoin d'installer et de configurer qu'un petit nombre de logiciels clients. Le serveur assume la majeure partie du travail, l'accès à la base de données et l'exécution des applications étant effectués par le serveur.
La maturation continue de l'architecture B/S utilise principalement les technologies de navigateur WWW, combinées à divers langages de script de navigateur, pour réaliser des fonctions puissantes qui nécessitaient auparavant des logiciels propriétaires complexes, réduisant ainsi les coûts de développement. Il s'agit d'une nouvelle architecture logicielle. Le système B/S comprend : la couche de logique de présentation, la couche de logique de contrôle et la couche de présentation des données, trois couches relativement indépendantes mais interconnectées.
Présentation du framework SSM
Le framework SSM est l'abréviation de Spring + Spring MVC + MyBatis. C'est, après SSH, l'un des frameworks Java EE d'entreprise les plus populaires actuellement, adapté à la construction de divers grands systèmes d'applications d'entreprise.
- Introduction à Spring
Spring est un framework open source, apparu en 2003 comme un framework de développement Java léger, dérivé en partie des concepts et des prototypes décrits par Rod Johnson dans son ouvrage "Expert One-On-One J2EE Development and Design". Il a été créé pour résoudre la complexité du développement d'applications d'entreprise. Spring utilise des JavaBean de base pour accomplir des tâches qui ne pouvaient être réalisées auparavant que par des EJB. Cependant, l'utilisation de Spring ne se limite pas au développement côté serveur. En termes de simplicité, de testabilité et de faible couplage, toute application Java peut bénéficier de Spring. En bref, Spring est un framework de conteneur léger basé sur l'inversion de contrôle (IoC) et la programmation orientée aspect (AOP).
A. Qu'est-ce que l'inversion de contrôle (IOC) ?
L'IOC (Inversion of Control), également appelée injection de dépendance, utilise le pattern Factory pour confier la gestion des objets au conteneur. Il vous suffit de configurer les beans correspondants dans le fichier de configuration Spring et de définir les propriétés associées, permettant au conteneur Spring de créer des instances de classes et de gérer ces objets. Lors du démarrage du conteneur Spring, celui-ci initialise tous les beans configurés dans le fichier de configuration. Lorsque vous avez besoin de les utiliser, il les injecte dans les classes qui les appellent (supposons que cette classe s'appelle A) via des méthodes setter, sans avoir à créer ces objets avec l'opérateur 'new' dans la classe A.
B. Qu'est-ce que la programmation orientée aspect (AOP) ?
Tout d'abord, il faut noter que l'AOP est une caractéristique de Spring, tout comme l'OOP (Programmation Orientée Objet), il s'agit d'un paradigme de programmation, pas d'une technologie spécifique. L'AOP peut être considérée comme un complément et une amélioration de l'OOP. L'OOP introduit des concepts comme l'encapsulation, l'héritage et le polymorphisme pour établir une structure hiérarchique d'objets simulant une collection de comportements communs. Lorsque nous devons introduire des comportements communs dans des objets dispersés, l'OOP montre ses limites. Autrement dit, l'OOP vous permet de définir des relations verticales, mais n'est pas adapté pour définir des relations horizontales. Par exemple, la fonction de journalisation (logging). Le code de journalisation est souvent dispersé horizontalement dans toutes les couches d'objets, sans rapport avec la fonctionnalité principale des objets où il est dispersé. Dans la conception OOP, cela entraîne une duplication importante de code et nuit à la réutilisabilité des différents modules. On encapsule les logiques métier transversales (comme la sécurité, les journaux, les transactions, etc.) en aspects, puis on les injecte dans les objets cibles (logiques métier spécifiques).
Les techniques d'implémentation de l'AOP se divisent principalement en deux catégories : l'utilisation de la technologie de proxy dynamique, qui intercepte les messages pour les décorer et remplacer le comportement de l'objet original ; et l'utilisation de la t statique, qui introduit une syntaxe spécifique pour créer des "aspects", permettant au compilateur de tisser le code lié aux "aspects" pendant la compilation.
- Introduction à Spring MVC
Spring MVC fait partie des produits ultérieurs du Spring Framework, maintenant intégré dans Spring Web Flow. Son support natif des fonctionnalités Spring rend le développement très simple et normalisé. Spring MVC sépare les rôles du contrôleur, des objets modèle, du dispatcher et des objets de traitement, cette séparation permettant une personnalisation plus facile.
- Introduction à MyBatis
MyBatis était à l'origine un projet open source d'apache appelé iBatis. En 2010, le projet a été migré d'apache software foundation vers google code et a été renommé MyBatis. MyBatis est un framework de persistance basé sur Java. Le framework de persistance fourni par iBATIS comprend SQL Maps et Data Access Objects (DAO). MyBatis élimine presque tout le code JDBC, la configuration manuelle des paramètres et la récupération des ensembles de résultats. MyBatis utilise une configuration simple en XML ou des annotations pour le mapping, transformant les interfaces et les POJOs (Plain Old Java Objects, objets Java ordinaires) en enregistrements de base de données. On peut comprendre MyBatis comme un framework qui vous aide à gérer les opérations CRUD (Create, Read, Update, Delete) sur les données.
Analyse du système
Analyse de faisabilité
À travers une enquête et une analyse préliminaires des objectifs de mise en œuvre de cette plateforme de sécurité éducative, nous proposons des solutions de faisabilité et les démontrons une par une. Nous analysons principalement la faisabilité technique, économique et opérationnelle.
Analyse de faisabilité technique
Cette plateforme de sécurité éducative utilise le framework SSM, Java comme langage de développement, et est basée sur une architecture B/S de type WEB.
(1) Java fournit des performances stables, une excellente évolutivité, un développement plus rapide, une gestion simplifiée, un langage et des services entièrement nouveaux. Le système effectue la majeure partie des travaux triviaux non importants pour l'utilisateur.
(2) Le développement de systèmes basés sur le mode B/S est de plus en plus mature.
(3) Comme on le sait, Java est un langage de développement orienté objet. Les programmeurs peuvent utiliser facilement sur la plateforme Eclipse certaines solutions déjà connues.
Par conséquent, la plateforme de sécurité éducative est très faisable sur le plan technique, et les développeurs maîtrisent les technologies de développement nécessaires, ce qui rend le développement de ce système techniquement réalisable.
Analyse de faisabilité économique
Les logiciels utilisés pour cette plateforme de sécurité éducative sont tous open source, ce qui permet de réduire considérablement les efforts et les ressources, et donc les coûts de développement. De plus, les exigences de configuration matérielle sont très faibles, même les ordinateurs obsolètes peuvent répondre aux besoins. Par conséquent, ce système est tout à fait réalisable sur le plan économique, et donc économiquement très viable.
Analyse de faisabilité opérationnelle
L'interface de cette plateforme de sécurité éducative est simple et facile à utiliser. Tout utilisateur ayant une expérience de base en informatique peut y accéder et l'utiliser. Ce système présente les caractéristiques d'une facilité d'utilisation, d'une gestion simplifiée et d'une bonne interactivité, ce qui le rend très simple à utiliser. Par conséquent, il est très réalisable sur le plan opérationnel.
En conclusion, les objectifs de développement de ce système sont clairs, très réalisables sur les plans technique, économique et opérationnel, avec un investissement minimal, des fonctionnalités complètes et une gestion pratique. Par conséquent, le développement du système est tout à fait réalisable.
Analyse des performances du système
Sécurité du système
Cette plateforme de sécurité éducative doit contrôler strictement les droits d'administration, avec les exigences suivantes :
(1) Pour gérer la plateforme de sécurité éducative, il faut d'abord se connecter au système avec un nom d'utilisateur et un mot de passe. Les utilisateurs sans autorisation ne peuvent se connecter au système de quelque manière que ce soit ni consulter aucune information ou donnée du système, garantissant ainsi la sécurité, la fiabilité et l'exactitude du système.
(2) Dans la mise en œuvre concrète, des autorisations différentes sont définies. Les utilisateurs connectés au système avec différents niveaux d'autorisation ne peuvent pas effectuer d'opérations hors de leur niveau.
Intégrité des données
(1) Toutes les informations enregistrées doivent être complètes, le contenu des informations enregistrées ne peut pas être vide.
(2) Les liens entre les différentes données doivent rester corrects.
(3) Les mêmes données dans différents enregistrements doivent rester cohérentes.
Analyse de l'interface système
Actuellement, la conception d'interface est devenue un indicateur clé pour évaluer la qualité d'un logiciel. Une bonne interface utilisateur peut augmenter la confiance et l'intérêt des utilisateurs pour l'utilisation du système, améliorant ainsi l'efficacité. La technologie JSP utilise le langage Java comme langage de script, fournissant une interface pour les unités de bibliothèque Java côté serveur servant les applications HTTP. Elle permet de créer facilement des pages dynamiques. L'interface client fait référence à l'interface d'interaction entre le système logiciel et l'utilisateur, couvrant souvent les formats d'interface d'entrée, de sortie et de dialogue homme-machine.
- Conception de sortie
La sortie est le traitement par l'ordinateur des informations d'entrée de base, générant des informations efficaces de haute qualité avec un format approprié, fournies aux gestionnaires pour utilisation. C'est la responsabilité et l'objectif principaux de la conception de sortie.
Le processus de développement du système est le contraire du processus de mise en œuvre, allant de la conception de sortie à la conception d'entrée plutôt que de la conception d'entrée à la conception de sortie. Cela est dû au fait que les tableaux de sortie sont directement liés aux utilisateurs, et que la conception devrait viser à s'assurer que les utilisateurs peuvent utiliser facilement les tableaux de sortie et refléter rapidement les informations utiles des différents départements. Le principe de la conception de sortie est de prendre en compte les besoins de tous les niveaux de gestion tout en restant concise, sans fournir aux des informations superflues.
- Conception d'entrée
La collecte et la saisie des données d'entrée sont assez fastidieuses, nécessitant beaucoup de main-d'œuvre et un équipement adéquat, et sont souvent sources d'erreurs. Une fois les données saisies dans le système incorrectement, les erreurs sont amplifiées par le traitement. Par conséquent, l'exactitude des données d'entrée est déterminante pour les performances du système global.
La conception d'entrée repose sur les principes suivants :
- La quantité d'entrée doit être maintenue au minimum nécessaire pour répondre aux exigences de traitement. Moins il y a d'entrée, moins il y a d'erreurs et moins de temps est consacré à la préparation des données.
- Il faut rendre la préparation et le processus d'entrée aussi pratiques que possible, réduisant ainsi le taux d'erreurs.
- Il faut vérifier le plus tôt possible les données d'entrée (le plus près possible du point d'origine des données), afin de permettre une correction plus rapide des erreurs.
- Les données d'entrée doivent être enregistrées dès que possible sous la forme requise pour leur traitement, afin d'éviter les erreurs pouvant survenir lors de la transcription des données d'un support à un autre.
Flux et logique du système
[Diagramme de flux de connexion]
[Diagramme de flux de modification de mot de passe]
Conception générale du système
Aperçu
Ce système adopte une structure B/S (Browser/Server, architecture navigateur/serveur) et un modèle basé sur les services Web, une structure modèle adaptée aux environnements Internet. Tant que les utilisateurs peuvent se connecter à Internet, ils peuvent l'utiliser à tout moment et en tout lieu. Le schéma de fonctionnement du système est illustré à la figure 4-1 :
[Schéma de fonctionnement du système]
Structure du système
Ce système est un système web basé sur l'architecture B/S. La structure fonctionnelle de l'administrateur est conçue comme suit :
[Structure fonctionnelle de l'administrateur]
Ce système est un système web basé sur l'architecture B/S. La structure fonctionnelle de l'utilisateur est conçue comme suit :
[Structure fonctionnelle de l'utilisateur]
Conception de la base de données
Entités de la base de données
L'objectif de la conception conceptuelle est de concevoir un schéma conceptuel de système de base de données qui reflète les besoins en informations d'une organisation ou d'un département. Le schéma conceptuel du système de base de données est indépendant de la structure logique du système de base de données, indépendant du système de gestion de base de données (SGBD), et indépendant du système informatique.
La méthode de conception du schéma conceptuel consiste, sur la base de l'analyse des besoins, à représenter les données et leurs relations à l'aide d'un modèle de données conceptuel (par exemple, modèle E-R), concevant ainsi un schéma conceptuel de système de base de données qui reflète les besoins en informations et en traitement des utilisateurs. L'objectif de la conception conceptuelle est de décrire avec précision le schéma d'informations du domaine d'application, de supporter diverses applications des utilisateurs, ce qui facilite à la fois la conversion en schéma logique du système de base de données et la compréhension par les utilisateurs. Le schéma conceptuel du système de base de données est un modèle de données orienté vers le monde réel et ne peut pas être utilisé directement pour l'implémentation du système de base de données. À ce stade, les utilisateurs peuvent participer et évaluer la conception du système de base de données, ce qui favorise l'adéquation entre la conception et les besoins des utilisateurs. Dans la conception du schéma conceptuel, la méthode du modèle E-R est la plus courante. Le diagramme E-R de ce système est illustré ci-dessous :
(1) Le diagramme des attributs d'entité des informations d'enregistrement d'examen est le suivant :
[Diagramme des attributs d'entité des informations d'enregistrement d'examen]
(2) Le diagramme des attributs d'entité des informations de question est illustré à la figure 4.13 :
[Diagramme des attributs d'entité des informations de question]
(3) Le diagramme des attributs d'entité des informations de questionnaire est illustré à la figure 4.14 :
[Diagramme des attributs d'entité des informations de questionnaire]
Tables de la base de données
La plateforme de sécurité éducative nécessite une base de données backend. Voici les détails des différentes tables de la base de données :
Table 4.1 Adresses
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| userid | bigint(20) | Non | ID utilisateur | |
| address | varchar(200) | Non | Adresse | |
| name | varchar(200) | Non | Destinataire | |
| phone | varchar(200) | Non | Téléphone | |
| isdefault | varchar(200) | Non | Adresse par défaut [Oui/Non] |
Table 4.2 Catégories de cours de sécurité
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| leibie | varchar(200) | Oui | NULL | Catégorie |
Table 4.3 Apprentissage des cours de sécurité
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| kechengmingcheng | varchar(200) | Oui | NULL | Nom du cours |
| leibie | varchar(200) | Oui | NULL | Catégorie |
| ziyuanlaiyuan | varchar(200) | Oui | NULL | Source de ressources |
| shangjiashijian | date | Oui | NULL | Date de mise en ligne |
| shipin | varchar(200) | Oui | NULL | Vidéo |
| fengmian | varchar(200) | Oui | NULL | Couverture |
| kechengjieshao | longtext | Oui | NULL | Description du cours |
| thumbsupnum | int(11) | Oui | 0 | J'aime |
| crazilynum | int(11) | Oui | 0 | J'aime pas |
| clicktime | datetime | Oui | NULL | Dernier clic |
Table 4.4 Panier d'achat
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| tablename | varchar(200) | Oui | jifenshangcheng | Nom de la table de produit |
| userid | bigint(20) | Non | ID utilisateur | |
| goodid | bigint(20) | Non | ID produit | |
| goodname | varchar(200) | Oui | NULL | Nom du produit |
| picture | varchar(200) | Oui | NULL | Image |
| buynumber | int(11) | Non | Quantité à acheter | |
| price | float | Oui | NULL | Prix unitaire |
| discountprice | float | Oui | NULL | Prix membre |
Table 4.5 Commentaires sur l'apprentissage des cours de sécurité
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| refid | bigint(20) | Non | ID de table associée | |
| userid | bigint(20) | Non | ID utilisateur | |
| nickname | varchar(200) | Oui | NULL | Nom d'utilisateur |
| content | longtext | Non | Contenu du commentaire | |
| reply | longtext | Oui | NULL | Réponse |
Table 4.6 Questionnaire
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| name | varchar(200) | Non | Nom du questionnaire | |
| time | int(11) | Non | Durée de l'examen (minutes) | |
| status | int(11) | Non | 0 | Statut du questionnaire |
Table 4.7 Questions
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| paperid | bigint(20) | Non | ID du questionnaire associé (clé étrangère) | |
| papername | varchar(200) | Non | Nom du questionnaire | |
| questionname | varchar(200) | Non | Nom de la question | |
| options | longtext | Oui | NULL | Options, chaîne JSON |
| score | bigint(20) | Oui | 0 | Points |
| answer | varchar(200) | Oui | NULL | Réponse correcte |
| analysis | longtext | Oui | NULL | Analyse de la réponse |
| type | bigint(20) | Oui | 0 | Type de question, 0 : choix unique, 1 : choix multiple, 2 : vrai/faux, 3 : question à trou (non prise en compte pour les questions à trou multiples) |
| sequence | bigint(20) | Oui | 100 | Ordre de la question, plus la valeur est élevée, plus la question est en avant |
Table 4.8 Enregistrements d'examen
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| userid | bigint(20) | Non | ID utilisateur | |
| username | varchar(200) | Oui | NULL | Nom d'utilisateur |
| paperid | bigint(20) | Non | ID du questionnaire (clé étrangère) | |
| papername | varchar(200) | Non | Nom du questionnaire | |
| questionid | bigint(20) | Non | ID de la question (clé étrangère) | |
| questionname | varchar(200) | Non | Nom de la question | |
| options | longtext | Oui | NULL | Options, chaîne JSON |
| score | bigint(20) | Oui | 0 | Points |
| answer | varchar(200) | Oui | NULL | Réponse correcte |
| analysis | longtext | Oui | NULL | Analyse de la réponse |
| myscore | bigint(20) | Non | 0 | Points obtenus |
| myanswer | varchar(200) | Oui | NULL | Réponse du candidat |
Table 4.9 Boutique de points
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| shangpinmingcheng | varchar(200) | Oui | NULL | Nom du produit |
| leibie | varchar(200) | Oui | NULL | Catégorie |
| pinpai | varchar(200) | Oui | NULL | Marque |
| shengchanchangjia | varchar(200) | Oui | NULL | Fabricant |
| shengchandizhi | varchar(200) | Oui | NULL | Adresse de production |
| tupian | varchar(200) | Oui | NULL | Image |
| shangpinjieshao | longtext | Oui | NULL | Description du produit |
| jifen | int(11) | Oui | -1 | Points |
| price | float | Non | Prix | |
| onelimittimes | int(11) | Oui | -1 | Limite par personne |
| alllimittimes | int(11) | Oui | -1 | Stock |
Table 4.10 Actualités
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| title | varchar(200) | Non | Titre | |
| introduction | longtext | Oui | NULL | Résumé |
| picture | varchar(200) | Non | Image | |
| content | longtext | Non | Contenu |
Table 4.11 Commande
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| orderid | varchar(200) | Non | Numéro de commande | |
| tablename | varchar(200) | Oui | jifenshangcheng | Nom de la table de produit |
| userid | bigint(20) | Non | ID utilisateur | |
| goodid | bigint(20) | Non | ID produit | |
| goodname | varchar(200) | Oui | NULL | Nom du produit |
| picture | varchar(200) | Oui | NULL | Image du produit |
| buynumber | int(11) | Non | Quantité achetée | |
| price | float | Non | 0 | Prix/points |
| discountprice | float | Oui | 0 | Prix réduit |
| total | float | Non | 0 | Prix total/points totaux |
| discounttotal | float | Oui | 0 | Prix total réduit |
| type | int(11) | Oui | 1 | Type de paiement |
| status | varchar(200) | Oui | NULL | Statut |
| address | varchar(200) | Oui | NULL | Adresse |
| tel | varchar(200) | Oui | NULL | Téléphone |
| consignee | varchar(200) | Oui | NULL | Destinataire |
Table 4.12 Catégories de produits
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| leibie | varchar(200) | Oui | NULL | Catégorie |
Table 4.13 Favoris
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| userid | bigint(20) | Non | ID utilisateur | |
| refid | bigint(20) | Oui | NULL | ID favori |
| tablename | varchar(200) | Oui | NULL | Nom de la table |
| name | varchar(200) | Non | Nom du favori | |
| picture | varchar(200) | Non | Image du favori |
Table 4.14 Administrateur
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| username | varchar(100) | Non | Nom d'utilisateur | |
| password | varchar(100) | Non | Mot de passe | |
| role | varchar(100) | Oui | Administrateur | Rôle |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure d'ajout |
Table 4.15 Utilisateur
| Champ | Type | Nul | Défaut | Commentaire |
|---|---|---|---|---|
| id (primaire) | bigint(20) | Non | Clé primaire | |
| addtime | timestamp | Non | CURRENT_TIMESTAMP | Heure de création |
| zhanghao | varchar(200) | Non | Compte | |
| mima | varchar(200) | Non | Mot de passe | |
| xingming | varchar(200) | Oui | NULL | Nom |
| xingbie | varchar(200) | Oui | NULL | Sexe |
| shouji | varchar(200) | Non | Téléphone | |
| youxiang | varchar(200) | Oui | NULL | |
| shenfenzheng | varchar(200) | Non | Numéro d'identité | |
| zhaopian | varchar(200) | Oui | NULL | Photo |
| jifen | float | Oui | 0 | Points |
| money | float | Oui | 0 | Solde |
Mise en œuvre détaillée du système
Mise en œuvre du module administrateur
Gestion des informations utilisateur
L'administrateur du système de plateforme de sécurité éducative peut gérer les utilisateurs, effectuant des opérations d'ajout, de modification, de suppression et de recherche sur les informations utilisateur. L'interface spécifique est présentée à la figure 5.1.
[Interface de gestion des informations utilisateur]
Gestion de l'apprentissage des cours de sécurité
L'administrateur du système peut consulter, ajouter, modifier, supprimer et rechercher les informations d'apprentissage des cours de sécurité. L'interface spécifique est présentée à la figure 5.2.
[Interface de gestion des informations d'apprentissage des cours de sécurité]
Mise en œuvre du module utilisateur
Enregistrements d'examen
Après s'être connecté, l'utilisateur peut consulter les informations d'enregistrement d'examen. L'interface est présentée ci-dessous :
[Interface d'enregistrement d'examen]
Informations utilisateur
Après connexion, l'utilisateur peut cliquer sur la liste des questionnaires sur la page d'accueil pour voir les informations du questionnaire, sélectionner les informations du questionnaire pour passer l'examen. L'interface est présentée ci-dessous :
[Interface d'information du questionnaire]
Gestion des informations d'examen
L'utilisateur peut cliquer sur les informations du questionnaire pour passer l'examen. L'interface est présentée ci-dessous :
[Interface d'examen]
ExampaperController.java
package com.controller;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.ExampaperEntity;
import com.entity.view.ExampaperView;
import com.service.ExampaperService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
/**
* Contrôleur pour l'entité Questionnaire
* Backend API
* @author
* @email
* @date 2021-04-12 18:09:26
*/
@RestController
@RequestMapping("/questionnaire")
public class QuestionnaireController {
@Autowired
private QuestionnaireService questionnaireService;
/**
* Liste backend
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, QuestionnaireEntity questionnaire,
HttpServletRequest request) {
EntityWrapper<QuestionnaireEntity> ew = new EntityWrapper<QuestionnaireEntity>();
PageUtils page = questionnaireService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, questionnaire), params), params));
return R.ok().put("data", page);
}
/**
* Liste frontend
*/
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, QuestionnaireEntity questionnaire, HttpServletRequest request){
EntityWrapper<QuestionnaireEntity> ew = new EntityWrapper<QuestionnaireEntity>();
PageUtils page = questionnaireService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, questionnaire), params), params));
return R.ok().put("data", page);
}
/**
* Liste
*/
@RequestMapping("/lists")
public R list( QuestionnaireEntity questionnaire){
EntityWrapper<QuestionnaireEntity> ew = new EntityWrapper<QuestionnaireEntity>();
ew.allEq(MPUtil.allEQMapPre( questionnaire, "questionnaire"));
return R.ok().put("data", questionnaireService.selectListView(ew));
}
/**
* Recherche
*/
@RequestMapping("/query")
public R query(QuestionnaireEntity questionnaire){
EntityWrapper< QuestionnaireEntity> ew = new EntityWrapper< QuestionnaireEntity>();
ew.allEq(MPUtil.allEQMapPre( questionnaire, "questionnaire"));
QuestionnaireView questionnaireView = questionnaireService.selectView(ew);
return R.ok("Recherche du questionnaire réussie").put("data", questionnaireView);
}
/**
* Détails backend
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
QuestionnaireEntity questionnaire = questionnaireService.selectById(id);
return R.ok().put("data", questionnaire);
}
/**
* Détails frontend
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
QuestionnaireEntity questionnaire = questionnaireService.selectById(id);
return R.ok().put("data", questionnaire);
}
/**
* Sauvegarde backend
*/
@RequestMapping("/save")
public R save(@RequestBody QuestionnaireEntity questionnaire, HttpServletRequest request){
questionnaire.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(questionnaire);
questionnaireService.insert(questionnaire);
return R.ok();
}
/**
* Sauvegarde frontend
*/
@RequestMapping("/add")
public R add(@RequestBody QuestionnaireEntity questionnaire, HttpServletRequest request){
questionnaire.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(questionnaire);
questionnaireService.insert(questionnaire);
return R.ok();
}
/**
* Modification
*/
@RequestMapping("/update")
public R update(@RequestBody QuestionnaireEntity questionnaire, HttpServletRequest request){
//ValidatorUtils.validateEntity(questionnaire);
questionnaireService.updateById(questionnaire);//Mise à jour complète
return R.ok();
}
/**
* Suppression
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
questionnaireService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
* API de rappel
*/
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName);
map.put("type", type);
if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
Wrapper<QuestionnaireEntity> wrapper = new EntityWrapper<QuestionnaireEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = questionnaireService.selectCount(wrapper);
return R.ok().put("count", count);
}
}
ApprenantCoursSecuriteServiceImpl.java
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ApprenantCoursSecuriteDao;
import com.entity.ApprenantCoursSecuriteEntity;
import com.service.ApprenantCoursSecuriteService;
import com.entity.vo.ApprenantCoursSecuriteVO;
import com.entity.view.ApprenantCoursSecuriteView;
@Service("apprenantCoursSecuriteService")
public class ApprenantCoursSecuriteServiceImpl extends ServiceImpl<ApprenantCoursSecuriteDao, ApprenantCoursSecuriteEntity> implements ApprenantCoursSecuriteService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<ApprenantCoursSecuriteEntity> page = this.selectPage(
new Query<ApprenantCoursSecuriteEntity>(params).getPage(),
new EntityWrapper<ApprenantCoursSecuriteEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ApprenantCoursSecuriteEntity> wrapper) {
Page<ApprenantCoursSecuriteView> page =new Query<ApprenantCoursSecuriteView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<ApprenantCoursSecuriteVO> selectListVO(Wrapper<ApprenantCoursSecuriteEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
@Override
public ApprenantCoursSecuriteVO selectVO(Wrapper<ApprenantCoursSecuriteEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<ApprenantCoursSecuriteView> selectListView(Wrapper<ApprenantCoursSecuriteEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public ApprenantCoursSecuriteView selectView(Wrapper<ApprenantCoursSecuriteEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
}
QuestionnaireServiceImpl.java
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.QuestionnaireDao;
import com.entity.QuestionnaireEntity;
import com.service.QuestionnaireService;
import com.entity.vo.QuestionnaireVO;
import com.entity.view.QuestionnaireView;
@Service("questionnaireService")
public class QuestionnaireServiceImpl extends ServiceImpl<QuestionnaireDao, QuestionnaireEntity> implements QuestionnaireService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<QuestionnaireEntity> page = this.selectPage(
new Query<QuestionnaireEntity>(params).getPage(),
new EntityWrapper<QuestionnaireEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<QuestionnaireEntity> wrapper) {
Page<QuestionnaireView> page =new Query<QuestionnaireView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<QuestionnaireVO> selectListVO(Wrapper<QuestionnaireEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
@Override
public QuestionnaireVO selectVO(Wrapper<QuestionnaireEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<QuestionnaireView> selectListView(Wrapper<QuestionnaireEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public QuestionnaireView selectView(Wrapper<QuestionnaireEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
}
accueil.vue
<template>
<div class="contenu">
<div class="texte texte-principale">Bienvenue sur {{this.$project.projectName}}</div>
</div>
</template>
<script>
import router from '@/router/router-statique'
export default {
monte(){
this.initialiser();
},
methodes:{
initialiser(){
if(this.$storage.get('Token')){
this.$http({
url: `${this.$storage.get('sessionTable')}/session`,
methode: "get"
}).then(({ donnees }) => {
if (donnees && donnees.code != 0) {
router.push({ name: 'connexion' })
}
});
}else{
router.push({ name: 'connexion' })
}
}
}
};
</script>
<style lang="scss" scoped>
.contenu {
display: flex;
align-items: center;
flex-direction: column;
width: 100%;
height: 100%;
min-height: 500px;
text-align: center;
.texte-principale{
font-size: 38px;
font-weight: bold;
margin-top: 15%;
}
.texte {
font-size: 24px;
font-weight: bold;
color: #333;
}
}
</style>
Déclaration
Ce blog est destiné à des fins académiques et éducatives larges, y compris mais sans s'y limiter l'apprentissage personnel, la conception de développement et la conception de produits. À titre indicatif uniquement, destiné à fournir aux lecteurs une compréhension approfondie et des matériaux de recherche académique.