Javaweb implémente le code d'instance de la fonction d'enregistrement de connexion de l'utilisateur (basé sur le servlet + jsp + mode javabean)

Ci-dessous, nous présenterons l'exemple de code de Javaweb pour implémenter la fonction de connexion et d'enregistrement des utilisateurs via des images et des textes. Jetons un coup d'œil.

1. Introduction au servlet + JSP + Javabean Development Model (MVC)

Servlet + JSP + JavaBean Mode (MVC) convient au développement d'applications Web complexes. Dans ce mode, les servlets sont responsables du traitement des demandes des utilisateurs, JSP est responsable de l'affichage des données et Javabean est responsable de l'encapsulation des données. Le programme de mode servlet + jsp + javabean a des niveaux clairs entre les modules, et le développement Web est recommandé d'utiliser ce mode.

Ici, nous utilisons le programme d'enregistrement de connexion des utilisateurs le plus utilisé pour expliquer le modèle de développement Servlet + JSP + Javabean. Grâce à ce programme d'enregistrement de connexion utilisateur, des cas complets, nous connectons les points de connaissance de XML, XPATH, Servlet et JSP que nous avons appris auparavant.

2. Créez un projet Web avec l'architecture MVC

Créez un nouveau projet WebMVCFramework dans MyEclipse, importez le package de développement (package JAR) requis par le projet et créez les packages requis par le projet. Dans le développement de Java, le niveau d'architecture se reflète sous la forme d'un package

Une bonne architecture de projet Javaweb devrait avoir les 11 packages ci-dessus, ce qui le rend clair et les responsabilités entre chaque couche claire. Lors de la création d'une architecture de projet Javaweb, créez les packages dans l'ordre de 1 à 11 ci-dessus: domaine → Dao → Dao.impl → Service → Service.impl → Web.Controller → Web.Ui → web.filter → web.listener → util → junit.test. Une fois le niveau de package créé, l'architecture du projet sera déterminée. Bien sûr, dans le développement réel du projet, il peut ne pas être complètement basé sur

Comme mentionné ci-dessus, nous créons une hiérarchie de packages, mais sur la base de la situation réelle du projet, nous pouvons également avoir besoin de le créer.

Son sac, cela dépend des besoins du projet.

Dans le cadre du répertoire SRC (répertoire de catégorie), créez un fichier XML (db.xml) pour enregistrer les données utilisateur (db.xml)

Créez un répertoire Pages dans le répertoire Web-Inf. Le répertoire des pages stocke certaines pages JSP protégées du système (ne permettant pas aux utilisateurs d'accéder directement via des adresses URL). Si les utilisateurs souhaitent accéder à ces pages JSP protégées, ils ne peuvent utiliser le servlet que dans le package me.gacl.web.ui

Le projet créé est illustré dans la figure suivante (figure-1):

Figure-1

3. Écriture de code de l'architecture hiérarchique

Le code de l'architecture hiérarchique est également écrit dans l'ordre de [Layer du modèle de domaine (domaine)] → [Layer d'accès aux données (Dao, Dao.impl)] → [Couche de traitement commercial (Service, Service.impl)] → [Expression Layer (Web.Controller, web.ui, web.filter, web.listener)] → [Tool Class (util)] → [Tester.

3.1. Développer la couche de domaine

Créer une classe d'utilisateurs sous le package me.gacl.domain

Le code spécifique de la classe utilisateur est le suivant:

 package me.gacl.domain; importer java.io.serializable; import java.util.date; / *** @author gacl * Entité utilisateur Classe * / public class implémente sérialisable {private static final Long SerialVersionUid = -l; // utilisateur idPrivate Id; // nom de chaîne privée de la chaîne privée; // utilisateur de mot de passe utilisateur UserPwd; Anniversaire de l'utilisateur Date privative anniversaire; public String getID () {return id;} public void setid (String id) {this.id = id;} public String getUsername () {return username;} public void SetUserName (String userName) {this.userName = userny {this.userpwd = userpwd;} public String getEmail () {return e-mail;} public void setEmail (String Email) {this.email = email;} public date getBirthday () {return anniversaire;} public void SetBirthday (date anniversaire) {this.birthday = anniversaire;}}

3.2. Développer la couche d'accès aux données (Dao, dao.impl)

Créez une classe d'interface iUserdao sous le package me.gacl.dao. Pour les classes d'interface de développement, j'ai l'habitude d'utiliser la lettre I comme préfixe de la classe, afin que vous puissiez voir en un coup d'œil que la classe actuelle est une interface, qui est également une bonne habitude de développement. En regardant le nom de classe, vous pouvez facilement distinguer s'il s'agit d'une interface ou d'une classe d'implémentation spécifique.

Le code spécifique de l'interface iUserdao est le suivant:

 package me.gacl.dao; import me.gacl.domain.user; interface publique iUserdao {/ *** Recherchez l'utilisateur en fonction du nom d'utilisateur et du mot de passe * @param username * @param userpwd * @return user Found * / User find (String Userpa nom * @param nom d'utilisateur * @return l'utilisateur trouvé * / utilisateur find (nom d'utilisateur de chaîne);}

Pour la définition de la méthode dans l'interface, cela ne peut analyser que les méthodes doivent être définies en fonction de l'entreprise spécifique. Cependant, peu importe la complexité de l'entreprise, elle ne peut pas être séparée de l'opération CRUD (addition, suppression, modification et requête). La couche DAO interagit directement avec la base de données, de sorte que l'interface de couche DAO a généralement quatre méthodes connexes pour ajouter, suppression, modification et requête.

Créez une classe userdaoimpl sous le package me.gacl.dao.impl

La classe UserDaoimpl est une classe d'implémentation spécifique de l'interface iUserdao. Pour la méthode de dénomination de la classe d'implémentation de l'interface, je suis habitué à le nommer sous la forme de "Nom de l'interface (supprimez le préfixe I) + Imp" ou "Nom d'interface + Implat": iUserdao (interface) → Userdaoimpl (classe d'implémentation) ou iSerdao (interface) → iUserdaoimpl (classe d'implémentation). Il s'agit également d'une habitude de programmation personnelle. La plupart du code que je vois nomme généralement la classe d'implémentation spécifique de l'interface dans l'une de ces deux formes. Quoi qu'il en soit, vous devez être en mesure de voir quelle classe d'implémentation correspondant à l'interface est en un coup d'œil.

Le code spécifique de la classe UserDaoimpl est le suivant:

 package me.gacl.dao.impl; import java.text.simpledateformat; import org.domj.document; import org.domj.element; import me.gacl.dao.iuserdao; import me.gacl.domain.user; import me.gacl.util.xmlutils; / *** Clastique d'implémentation de l'interface * @aot GACL * / classe publique UserDaoimpl implémente iUserDao {@OverRidePublic User find (String Username, String userPwd) {try {document document = xmlutils.getDocument (); // Utilisez l'expression xpath pour manipuler xml nodeelement e = (élément) document.selectSingLenode ("// user [@usueme =" + username " @userpwd = '"+ userpwd +"'] "); if (e == null) {return null;} utilisateur utilisateur = new User (); user.setid (e.AttributeValue ("id")); user.setEmail (e.AttributeValue ("e-mail")); user.SetUserPwd (e.AttributeValue ("userPwd")); user.SetUsername (E.AttributeValue ("userPwame" new SimpledateFormat ("yyyy-mm-dd"); user.setbirthday (sdf.parse (naissance)); user de retour;} catch (exception e) {throw new runtimeException (e);}} @ suppresswarnings ("dépréciation") @ overdePublic Void add (user = user) document.getRootelement (); élément user_node = root.addelement ("utilisateur"); // Créer un nœud utilisateur et le suspendre à rootuser_node.setAttributeValue ("id", user.getId ()); user_node.setAttributeValue ("username", user.geturname ()); user_node.setAttributeValue ("userpwd", user.geserpwd ()); user_node.setAtTraut user.getEmail ()); SimpledateFormat sdf = new SimpledateFormat ("yyyy-mm-dd"); user_node.setAttributeValue ("anniversaire", sdf.format (user.getBirthday ())); xmlutils.writexml (document);} catch (exception e) {throw RuntimeException (e);}} @ OverRidePublic User find (String username) {try {document document = xmLutils.getDocument (); élément e = (élément) document.selectSingLenode ("// user [@Username = '" + username + "']"); if (e == Null) {return null;} utilisateur utilisateur = new User (); user.setid (e.AttributeValue ("id")); user.setEmail (e.AttributeValue ("e-mail")); user.SetUserPwd (e.AttributeValue ("userPwd")); user.SetUsername (E.AttributeValue ("userPwame" new SimpledateFormat ("yyyy-mm-dd"); user.setBirthday (sdf.parse (naissance)); user de retour;} catch (exception e) {lancez new RuntimeException (e);}}}

3.3. Couche de service de développement (la couche de service fournit tous les services commerciaux à la couche Web)

Créez la classe d'interface iUserService dans le package me.gacl.service

Le code spécifique de l'interface iUserService est le suivant:

 Package me.gacl.service; import me.gacl.domain.user; import me.gacl.exception.userexistException; interface publique iUserService {/ *** fournir un service d'enregistrement * @param user * @throws userexistexception * / void registerUser (utilisateur) throws usera @ return * / User LoginUser (String Username, String userpwd);}

Créer une classe UserServiceImpl dans le package me.gacl.service.impl

La classe UserServiceImpl est une classe d'implémentation spécifique de l'interface iUserService. Le code spécifique est le suivant:

 Package me.gacl.service.impl; import me.gacl.dao.iuserdao; import me.gacl.dao.impl.userdaoimpl; import me.gacl.domain.user; import me.gacl.exception.UserExistException; importe me.gacl.service.iuserservice; IUserdao userdao = new UserDaoimpl (); @ OverRidePublic void registre (utilisateur utilisateur) lève UseRexistException {if (userdao.find (user.getUserName ())! = Null) {// Exception vérifiée // Exception non cochée // La raison de lancer une nouvelle exception compilée ici: Je veux que le programme précédent gère cette exception pour faire une invite à une nouvelle exception ici: je veux que le programme précédent gère cette exception pour faire une invite à une exception compilée ici: UseRexistException ("Le nom d'utilisateur enregistré existe déjà !!!");} userdao.add (utilisateur);} @ OverRidePublic User Loginuser (String Username, String userpwd) {return userDao.Find (userName, userpwd);}}}

3.4. Développer la couche Web

3.4.1. Développer la fonction d'enregistrement

1. Écrivez un registrevlet sous le package me.gacl.web.ui pour fournir une interface d'enregistrement aux utilisateurs

Après avoir reçu la demande de l'utilisateur, registrevlet saute pour register.jsp

Le code de registrevlet est le suivant:

 Package me.gacl.web.ui; import java.io.ioexception; import javax.servlet.servletException; import javax.servlet.http.httpservlet; import javax.servlet.http.httpservletRequest; GACL * Servlet qui fournit aux utilisateurs une interface utilisateur enregistrée * RegisterEservlet est responsable de la sortie de l'interface d'enregistrement pour les utilisateurs * Lorsqu'un utilisateur accède au répertoire RegisterUiservlet, il passe à la page registre.jsp dans le répertoire Web-Inf / Pages * / HTTPSERVLETERVLET étend httSservlet {public Void doGee ServletException, ioException {request.getRequestDispatcher ("/ web-inf / pages / registre.jsp").

2. Écrivez un registre de page JSP enregistré par l'utilisateur.

Toute page JSP située dans le répertoire Web-Inf ne peut pas être accessible directement via l'adresse URL.

Pendant le développement, s'il existe des ressources Web sensibles dans le projet qui ne veulent pas être directement accessibles par le monde extérieur, vous pouvez envisager de mettre ces ressources Web sensibles dans le répertoire Web-Inf, afin que le monde extérieur puisse être interdit d'accéder directement à l'URL.

Le code de la page registre.jsp est le suivant:

 <% @ page Language = "Java" pageEncoding = "UTF -"%> <! DocType Html> <Html> <A-Head> <Title> Enregistrement des utilisateurs </TITME> </EAD> <Body Style = "Text-align: Center;"> <form Action = "$ {PageConText" Method = "Post"> <Table> <Tr> <Td> Nom d'utilisateur </td> <td> <Input Type = "Text" Name = "Username"> </ Td> </ Tr> <TR> <TD> PASSUS </TD> <TD> <ENTO TYPE = "Passue" Name = "Userpwd"> </tding = </tr> <td> Mot de passe </ TD> name = "confirmpwd"> </ td> </tr> <tr> <td> e-mail </td> <td> <entrée type = "text" name = "e-mail"> </pd> </tr> <tr> <td> anniversaire </td> <td> <entrée type = "text" name = "anniversaire"> </td> </tr> <tr> <Tr> <Tr> <TDD> Value = "Clear"> </td> <td> <Type de saisie = "Soumide" Value = "Register"> </td> </tr> </pable> </ Form> </ Body> </html>

<formulaire Action = "$ {PageContext.Request.ContextPath} / Servlet / Registerservlet" Method = "Post"> Dans Register.jsp indique que le formulaire est soumis et remis au Registerservlet pour le traitement

3. Écrivez un Registerservlet pour gérer l'enregistrement des utilisateurs dans le cadre du package me.gacl.web.Controller

Registerservlet assume les responsabilités suivantes:

1. Recevez des données de formulaire soumises par le client au serveur.

2. Vérifiez la légalité des données de forme. Si la vérification échoue, sautez en arrière pour register.jsp et faire écho au message d'erreur.

3. Si la vérification est passée, appelez la couche de service pour enregistrer l'utilisateur avec la base de données.

Afin de faciliter le Registerservlet pour recevoir des données de formulaire et des données de formulaire de vérification, j'ai conçu un registreFormBean pour la vérification des données de formulaire d'enregistrement, puis j'ai écrit la classe d'outils WebUtils pour encapsuler les données de formulaire soumises par le client dans le formbean.

Créez un registreformbean pour vérifier les données du formulaire d'enregistrement dans le package me.gacl.web.formbean

Le code RegisterFormbean est le suivant:

 package me.gacl.web.formbean; import java.util.hashmap; import java.util.map; import org.apache.commons.beanutils.locale.converters.datelocaleconverter; / *** le formulaire d'enregistrement de l'utilisateur encapsulé le registre du registre de la forme de la forme dans le formulaire de la forme de la forme. Entrée dans Register.jsp * Les responsabilités du registreformBean sont non seulement responsables de la réception de la valeur de l'élément d'entrée de formulaire dans registre.jsp, mais servent également de légalité de la valeur de l'élément d'entrée de formulaire * @author gacl ** / classe publique RegisterFormBean {// Les propriétés dans le registre-formbean correspondent au nom de l'élément d'entrée de formulaire dans Register.jsp One By One By // <fort type = " name = "username" /> Private String Name username; // <input type = "mot de passe" name = "userpwd" /> private String userpwd; // <entrée type = "mot de passe" name = "confirmpwd" /> private String confirmpwd; // <entrée type = "text" name = "email" /> private String e-mail; // <entrée type = "text" name = "anniversaire" /> private anniversaire; Vérification échoue * / map privée <string, string> errors = new HashMap <String, String> (); public map <string, string> getErrors () {return errors;} public void setErrors (map <string, string> errors) {this.errors = errers;} / ** Méthode valide est responsable de la vérification des éléments d'entrée de formulaire * formulaires d'éléments d'entrée de vérification Règles: * Private String username; Le nom d'utilisateur ne peut pas être vide, et si c'est - Letter ABCDABCD * String privé UserPwd; Le mot de passe ne peut pas être vide, et si c'est le cas - le numéro * STRING PRIVÉ CONFIRMPWD; Le mot de passe doit être le même que l'e-mail de chaîne privée deux fois *; Il peut être vide, pas vide s'il s'agit d'une boîte aux lettres légale * anniversaire de chaîne privée; Il peut être vide, pas vide, s'il s'agit d'une date juridique * / public booléen validate () {boolean isok = true; if (this.username == null || this.username.trim (). Equals ("")) {isok; errors.put ("username", "le nom d'utilisateur ne peut pas être vide! ; false; errers.put ("userpwd", "Le mot de passe ne peut pas être vide !!");} else {if (! this.userpwd.matches ("// d {,}")) {isok = false; errers.put ("userpwd", "le mot de passe doit être un nombre de -bits !!");}} // private String Motway; Les mots de passe doivent être les mêmes lorsque les deux fois sont (this.confirmpwd! = Null) {if (! This.confirmpwd.equals (this.userpwd)) {isok = false; errors.put ("confirmpwd", "les mots de passe sont incohérents lorsque les deux fois ne sont pas nuls !!");}} // Il peut être vide, pas nul. S'il s'agit d'un e-mail légal si (this.email! = Null &&! This.email.trim (). Equals ("")) {if (! This.email.matches ("// w + @ // w + (// w +) +")) {isok = false; errers.put ("e-mail", "la boîte aux lettres n'est pas une boîte aux lettres légale !!");}} // anniversaire privé; Peut être vide, pas vide, si c'est une date légale si (this.birthday! = Null &&! This.birthday.trim (). Equals ("")) {try {datelocaleConverter convert = new DateloCaleConverter (); conver.convert (this.birthday);} catch (exception e) {IsOK = false; errers. Date !! ");}} return isOK;} public String getUsername () {return username;} public void SetUserName (String username) {this.userName = username;} public String getuserpwd () {return userpwd;} public void SetUserPwd (String userpwd) {this.Userpwd = userpwd;} pic getConFirmPwd () {return confirmPwd;} public void SetConFirmPwd (String confirmPwd) {this.confirmpwd = confirmpwd;} public String getEmail () {return email;} public void SetEmail (String Email) {this.email = e-mail;} String public anniversaire) {this.birthday = anniversaire;}}

Créez une classe d'outils Webutils sous le package me.gacl.util. La fonction de cette classe d'outils consiste à résumer les données de formulaire soumises par le client dans le formbean

 Package me.gacl.util; importer java.util.enumeration; import java.util.uuid; import javax.servlet.http.httpservletRequest; import org.apache.commons.beanutils.beanutils; / *** @author gacl * Encapsule les paramètres de demande dans l'objet de demande dans le bean * / public gacl * Encapsulent les paramètres de la demande dans l'objet de demande dans le bean; Convertir l'objet de demande en un objet T * @param request * @param Clazz * @ return * / public static <T> T requestBean (httpServleRequest request, class <T> Clazz) {try {t Bean = Clazz.newInstance (); énumération <string> e = request.getParameTames (); while (e.hasmoreElements ()) {String name = (string) e.nextElement (); string value = request.getParameter (name); beanutils.setProperty (bean, nom, valeur);} return bean;} catch (exception e) UUid.randomuuid (). ToString ();}}

Enfin, jetons un coup d'œil au code complet de Registerservlet responsable de la gestion de l'enregistrement des utilisateurs:

 package me.gacl.web.controller; import java.io.ioexception; import java.util.date; import javax.servlet.servletException; importer javax.servlet.http.httpservlet; import javax.servlet.http.httpservletquest; import javax.servlet.http.httpservletResponse; import org.apache.commons.beanutils.beanutils; import org.apache.commons.beanutils.convertutils. me.gacl.exception.userexistException; import me.gacl.service.iuserService; import me.gacl.service.impl.userserviceImpl; import me.gacl.util.webutils; import me.gacl.web.formbean.egisterformbean; / *** handles de servants étend httpServlet {public void doGet (httpservletRequest request, httpservletResponse réponse) lève ServletException, ioException {// encapsule les données de formulaire soumises par le client dans l'objet registreBean Formbean = webutiles.requestbean (request, registreBean. (formbean.validate () == false) {// Si la vérification échoue // Envoyez l'objet formulaire encapsulant les données de formulaire remplies par l'utilisateur au formulaire de formulaire sur la page registre.jsp pour afficher la demande.setAttribute ("formbean", formbean); // la vérification échoue à indiquer register.jsprequest.getRequestDispatcher ("/ web-inf / pages / registre.jsp"). user.setid (webutils.makeid ()); // Définissez la propriété ID de l'utilisateur iUserService Service = new UserServiceImpl (); // Appelez le service utilisateur enregistré fourni par la couche de service pour réaliser le service d'enregistrement de l'utilisateur.RegisterUser (utilisateur); String Message = String.format ("Enregistré avec succès!! Il passera automatiquement à la page de connexion pour vous en quelques secondes! request.getContextPath () + "/ servlet / LoginUiservlet"); request.setAttribute ("message", message); request.getRequestDispatcher ("/ message.jsp"). existant !! "); request.setAttribute (" formbean ", formbean); request.getRequestDispatcher (" / web-inf / pages / registre.jsp "). // Enregistrer l'exception dans la demande de fond.SetAttribute ("Message", "Désolé, l'inscription a échoué !!"); request.getRequestDispatcher ("/ message.jsp").

Si la vérification des données de formulaire remplie échoue lorsque l'utilisateur s'inscrit, le serveur stockera un objet FormBean avec le message d'erreur et les données du formulaire dans l'objet de demande, puis le renverra à la page registre.jsp. Par conséquent, nous devons retirer l'objet FormBean dans l'objet de demande de la page registre.jsp, puis réappliquer les données de formulaire remplies par l'utilisateur à l'élément de formulaire correspondant, et également afficher le message d'invite lorsqu'une erreur se produit sur le formulaire de formulaire, afin que l'utilisateur sache quelles données sont illégales pour remplir!

Modifiez la page registre.jsp, le code est le suivant:

 <% @ page Language = "Java" pageEncoding = "UTF -"%> <! DocType Html> <Html> <A-Head> <Title> Enregistrement des utilisateurs </TITME> </EAD> <Body Style = "Text-align: Center;"> <form Action = "$ {PageConText" Method = "Post"> <s tablel> <tr> <td> nom d'utilisateur </td> <td> <% - Utilisez l'expression El $ {} pour extraire les données de formulaire encapsulées dans l'objet FormBean stocké dans l'objet de requête (Formbean.Username) et le message d'erreur (Formbean.errors.Username) -%> <entrée = "text" nom = "username" Value = "$ {formbean.username}"> $ {formbean.errors.username} </td> </tr> <tr> <td> mot de passe </td> <td> <input type = "mot de passe" name = "userpwd" Value = "$ {formbean.userpwd}"> $ {formbean.errors.userpwd} </td> </tr> <tr> <td> confirme le mot de passe </td> <td> <entrée type = "mot de passe" name = "confirmpwd" value = "$ {formbean.confirmpwd}"> $ {formbean.errors.confirmpwd} </td> </tr> <tr> <td> e-mail </td> <td> <entrée type = "text" name = "e-mail" value = "$ {formbean.email}"> $ {formbean.errors.email} </td> </tr> <tr> <td> anniversaire </td> <td> <entrée type = "text" name = "anniversaire" Value = "$ {formbean.birthday}"> $ {formbean.errors.birthday} </td> </tr> <tr> <td> <entrée type = "reset" value = "clear"> </td> <td> <entrée type = "soumider" value = "registre"> </td> </tr> </ Table> </pall> </pable> </pory> </prut> </prut> </prut> </prut> </prut> </prut> </prôle> </prôle>

À ce stade, la fonction d'enregistrement des utilisateurs a été développée!

Le suivant teste la fonction d'enregistrement de l'utilisateur développé:

Entrez l'adresse URL: http: // localhost: 8080 / webmvcframework / servlet / registrevlet pour accéder à la page registre.jsp, et l'effet d'opération est le suivant:

Si l'élément de formulaire entré ne respecte pas les règles de vérification, il ne peut pas être enregistré. L'effet de fonctionnement est le suivant:

3.4.2. Développer la fonction de connexion

1. Écrivez un Loginuiservlet sous le package me.gacl.web.ui pour fournir aux utilisateurs une interface de connexion.

Une fois que LoginUiservlet a reçu la demande de l'utilisateur, il passe à Login.jsp

Le code de LoginUiservlet est le suivant:

 package me.gacl.web.ui; import java.io.ioexception; import javax.servlet.servletException; import javax.servlet.http.httpservlet; import javax.servlet.http.httpservletrequest; javax.servlet.http.httpservletResponse; / *** @author gacl * LoginUiservlet est responsable de la sortie de l'interface de connexion pour les utilisateurs * Lorsque l'utilisateur accède au Loginuiservlet, il saute vers la page Login.jsp dans le répertoire Web-Inf / Pages * / Public Class Loginuisert Extend HTTPServlet {Pages VOID * / Public Class Loginuisert Extend HTTPServlet {Pages VOID * / Public Class Loginuitert DOGET (HttpServletRequest Request, HttpservletResponse Response) lève ServletException, ioException {request.getRequestDispatcher ("/ web-inf / pages / login.jsp"). {doget (demande, réponse);}}

2. Écrivez la page Login Login.jsp de l'utilisateur sous / web-inff / pages / répertoire

Le code de la page Login.jsp est le suivant:

 <% @ Page Language = "Java" Pageencoding = "UTF -"%> <! DocType Html> <Html> <A-Head> <Title> Utilisateur Login </ Title> </ Head> <Body> <Form Action = "$ {PageContext.request.ContextPath} / Servlet / LoginServlet" Method = "Post"> Username: <port type = " name = "username"> <br/> mot de passe: <input type = "mot de passe" name = "mot de passe"> <br/> <input type = "soumi" value = "login"> </ form> </body> </html>

Le <form action = "$ {pageContext.request.contextPath} / servlet / loginServlet" méthode = "post"> dans login.jsp indique que le formulaire est soumis et remis au loginServlet pour le traitement.

3. Écrivez un connexion à connexion pour gérer la connexion des utilisateurs sous le package me.gacl.web.Controller

Le code de LoginServlet est le suivant:

 package me.gacl.web.controller; import java.io.ioexception; import javax.servlet.servletException; import javax.servlet.http.httpservlet; import javax.servlet.http.httpleserReRester; me.gacl.domain.user; import me.gacl.service.iuserService; import me.gacl.service.impl.userserviceImpl; / *** handles servlet Login * @author gacl ** / public class liginServlet étend httServlet {public vider doget ServletException, ioException {// Obtenez le nom d'utilisateur de connexion rempli par le nom d'utilisateur d'utilisateur Username = request.getParameter ("username"); // Obtenez le mot de passe de connexion rempli par la chaîne d'utilisateurs Motword = request.getParAmter ("Password"); iUserService Service = UserserviceImpll (); // LoginUser = Service.LoginUser (UserName, Mot de passe); if (user == null) {String Message = String.Format ("Désolé, le nom d'utilisateur ou le mot de passe est incorrect !! Veuillez vous connecter à nouveau! Vous passerez automatiquement à la page de connexion en quelques secondes !! <meta http-equiv = 'refresh' content = '; url =% s' ", request.getContextPath () +" / servlet / loginuiservlet "); request.setAttribute (" message ", message); request.getRequestDispatcher (" / message.jsp "). request.getSession (). setAttribute ("utilisateur", utilisateur); String Message = String.Format ("Félicitations:% S, la connexion est réussie! Cette page passera à la page d'accueil en quelques secondes! user.getUserName (), request.getContextPath () + "/ index.jsp"); request.setAttribute ("message", message); request.getRequestDispatcher ("/ message.jsp"). réponse);}}

À ce stade, la fonction de connexion de l'utilisateur est terminée.

Ci-dessous, testez la fonction de connexion de l'utilisateur développé, entrez l'adresse URL: http: // localhost: 8080 / webmvcframework / servlet / Loginuiservlet Pour accéder à la page Login.jsp, entrez le nom d'utilisateur et le mot de passe corrects pour se connecter, l'effet de fonctionnement est le suivant:

Si le nom d'utilisateur et le mot de passe entrés sont incorrects, la connexion ne peut pas être connectée avec succès et l'effet de fonctionnement est le suivant:

3.4.3. Développer la fonction d'annulation

Écrivez une connexion à déconnexion pour gérer la déconnexion des utilisateurs sous le package me.gacl.web.Controller

Le code de la connexion est le suivant:

 package me.gacl.web.controller; import java.io.ioexception; import java.text.messageFormat; import javax.servlet.servletException; import javax.servlet.httpservletservlet; import javax.servlet.http.httpservlet javax.servlet.http.httpservletResponse; public class LogoServlet étend httpservlet {public void doget (httpservletRequest request, httpservletResponse réponse) lance le servletException, ioException {// supprimer l'objet utilisateur stocké dans la session pour implémenter la fonction de logout, ioexception {// request.getSession (). RemoveAtTribut ("utilisateur"); // Parce que la chaîne contient des devis uniques, il y aura des problèmes lors de l'utilisation de la méthode MessageFormat.Format pour épisser la chaîne et ne remplira pas le contenu dans la page de chaîne de liaison TEMPSTR = SUPPRIMATINE! <meta http-equiv = 'rafhes' contenu = '; url = {}' /> ", request.getContextPath () +" / servlet / LoginUiservlet "); System.out.println (TEMPSTR); // Résultat de sortie: Déconnexion avec succès! ! Il passera automatiquement à la page de connexion en quelques secondes! ! <meta http-equiv = rafraîchir Content =; url = {} /> System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- content='';url={}''/>","index.jsp") can return normally * <meta http-equiv=''refresh'' content='';url=index.jsp'/>*/String tempStr = MessageFormat.format("Login successfully!! It will automatically jump to the login page in seconds!! <meta http-equiv=''refresh'' content='';url={}''/>", request.getContextPath()+"/servlet/LoginUIServlet");/*** Output result: *Login successfully! ! It will automatically jump to the login page for you in seconds! ! * <meta http-equiv='refresh' content=';url=/webmvcframework/servlet/LoginUIServlet'//System.out.println(tempStr);String message = String.format("Logout successfully!! Automatically jump to the login page in seconds!! <meta http-equiv='refresh' content=';url=%s'/>", request.getContextPath()+"/servlet/LoginUIServlet");request.setAttribute("message",message);request.getRequestDispatcher("/message.jsp").forward(request, response);}public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doGet(request, réponse);}}

用户登录成功后，会将登录的用户信息存储在session中，所以我们要将存储在session中的user删除掉，这样就可以实现用户注销了。

用户登录成功后就会跳转到index.jsp页面，在index.jsp页面中放一个【退出登陆】按钮，当点击【退出登陆】按钮时，就访问LogoutServlet，将用户注销。

index.jsp的代码如下：

 <%@ page language="java" pageEncoding="UTF-"%><%--为了避免在jsp页面中出现java代码，这里引入jstl标签库，利用jstl标签库提供的标签来做一些逻辑判断处理--%><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><!DOCTYPE HTML><html><head><title>首页</title><script type="text/javascript">function doLogout(){//访问LogoutServlet注销当前登录的用户window.location.href="${pageContext.request.contextPath}/servlet/LogoutServlet";}</script></head><body><h>孤傲苍狼的网站</h><hr/><c:if test="${user==null}"><a href="${pageContext.request.contextPath}/servlet/RegisterUIServlet" target="_blank">注册</a><a href="${pageContext.request.contextPath}/servlet/LoginUIServlet">登陆</a></c:if><c:if test="${user!=null}">欢迎您：${user.userName}<input type="button" value="退出登陆" onclick="doLogout()"></c:if><hr/></body></html>

测试开发好的注销功能，效果如下：

到此，所有的功能都开发完成了，测试也通过了。

四、开发总结

通过这个小例子，可以了解到mvc分层架构的项目搭建，在平时的项目开发中，也都是按照如下的顺序来进行开发的：

1. Construisez un environnement de développement

1.1 创建web项目

1.2 导入项目所需的开发包

1.3 创建程序的包名，在java中是以包来体现项目的分层架构的

2、开发domain

把一张要操作的表当成一个VO类(VO类只定义属性以及属性对应的get和set方法，没有涉及到具体业务的操作方法)，VO表示的是值对象，通俗地说，就是把表中的每一条记录当成一个对象，表中的每一个字段就作为这个对象的属性。每往表中插入一条记录，就相当于是把一个VO类的实例对象插入到数据表中，对数据表进行操作时，都是直接把一个VO类的对象写入到表中，一个VO类对象就是一条记录。每一个VO对象可以表示一张表中的一行记录，VO类的名称要和表的名称一致或者对应。

3、开发dao

3.1 DAO操作接口：每一个DAO操作接口规定了，一张表在一个项目中的具体操作方法，此接口的名称最好按照如下格式编写：“I表名称Dao”。

├DAO接口里面的所有方法按照以下的命名编写：

├更新数据库：doXxx()

├查询数据库：findXxx()或getXxx()

3.2 DAO操作接口的实现类：实现类中完成具体的增删改查操作

├此实现类完成的只是数据库中最核心的操作，并没有专门处理数据库的打开和关闭，因为这些操作与具体的业务操作无关。

4、开发service(service 对web层提供所有的业务服务)

5、开发web层

以上内容是小编给大家介绍的JavaWeb实现用户登录注册功能实例代码(基于Servlet+JSP+JavaBean模式)，希望对大家有所帮助！