Javaweb implementiert die Funktion Instanzcode für Benutzeranmeldungsregistrierungsfunktion (basierend auf dem Servlet+JSP+Javaban -Modus)

Im Folgenden werden wir den Beispielcode von Javaweb vorstellen, um die Benutzeranmeldungs- und Registrierungsfunktion über Bilder und Texte zu implementieren. Schauen wir uns an.

1. Einführung in Servlet+JSP+Javaban Development Model (MVC)

Servlet+JSP+Javaban -Modus (MVC) eignet sich für die Entwicklung komplexer Webanwendungen. In diesem Modus sind die Servlets für die Verarbeitung von Benutzeranforderungen verantwortlich, JSP ist für die Datenanzeige verantwortlich und Javabean ist für die Einkapselung von Daten verantwortlich. Das Programm Servlet+JSP+JavaBean -Modus verfügt über klare Ebenen zwischen den Modulen, und die Webentwicklung wird empfohlen, um diesen Modus zu verwenden.

Hier verwenden wir das am häufigsten verwendete Benutzeranmeldungsregistrierungsprogramm, um das Servlet+JSP+JavaBean Development -Modell zu erläutern. Durch dieses Benutzeranmeldungsregistrierungsprogramm verbinden wir die Wissenspunkte von XML, XPath, Servlet und JSP, die wir zuvor gelernt haben.

2. Erstellen Sie ein Webprojekt mit MVC -Architektur

Erstellen Sie ein neues WebMVCFramework -Projekt in MyeClipse, importieren Sie das vom Projekt erforderliche Entwicklungspaket (JAR -Paket) und erstellen Sie die vom Projekt erforderlichen Pakete. In der Java -Entwicklung spiegelt sich die Architekturstufe in Form eines Pakets wider

Eine gute Javaweb -Projektarchitektur sollte die oben genannten 11 Pakete haben, was es klar macht und die Verantwortlichkeiten zwischen jeder Ebene klar sind. Erstellen Sie beim Erstellen einer Javaweb -Projektarchitektur die Pakete in der Reihenfolge von 1 bis 11 oben: Domäne → DAO → DAO.impl → Service → Service.impl → Web.Controller → web.ui → Web.filter → Web.Listener → Utel → jungit.test. Sobald die Paketebene erstellt wurde, wird die Projektarchitektur bestimmt. Natürlich basiert es in der tatsächlichen Projektentwicklung möglicherweise nicht vollständig auf

Wie oben erwähnt, erstellen wir eine Pakethierarchie, aber basierend auf der tatsächlichen Situation des Projekts müssen wir es möglicherweise auch erstellen.

Seine Tasche hängt von den Projektbedürfnissen ab.

Erstellen Sie im SRC -Verzeichnis (Kategorieverzeichnis) eine XML -Datei (DB.xml) zum Speichern von Benutzerdaten (DB.xml)

Erstellen Sie ein Seitenverzeichnis im Web-Inf-Verzeichnis. Das Pages -Verzeichnis speichert einige geschützte JSP -Seiten des Systems (es ermöglichen es den Benutzern, über URL -Adressen direkt zugreifen). Wenn Benutzer auf diese geschützten JSP -Seiten zugreifen möchten, können sie das Servlet nur im Paket me.gacl.web.ui verwenden

Das erstellte Projekt ist in der folgenden Abbildung dargestellt (Abbildung 1):

Abbildung 1

3.. Code -Schreiben der hierarchischen Architektur

Der Code der hierarchischen Architektur ist auch in der Reihenfolge der [Domänenmodellschicht (Domäne)] → [Datenzugriffsschicht (DAO, DAO.IMPL)] → [Business Processing Layer (Service, Service.Impl) → [Ausdrucksschicht (Web.Controller, Web.Ui, Web.Filter, Web.Listener) → → → TOLT.TUR)] geschrieben.

3.1. Domänenschicht entwickeln

Erstellen Sie eine Benutzerklasse unter dem Paket me.gacl.domain

Der spezifische Code der Benutzerklasse lautet wie folgt:

 Paket me.gacl.domain; import Java.io.serializable; import Java.util.date;/*** @Author GaCl*Benutzerentität Klasse*/public class Implementiert serialisierbar {private statische statische statische long long serialversionuid = -l; // user idPrivate String id; User birthday private Date birthday;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 = userName;}public String getUserPwd() {return userPwd;}public void setUserPwd(String userPwd) {this.userPwd = userPwd;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}}

3.2. Entwickeln Sie die Datenzugriffsschicht (DAO, DAO.IMPL)

Erstellen Sie eine IUSERDAO -Schnittstellenklasse unter dem Paket me.gacl.dao. Für Entwicklungsschnittstellenklassen bin ich es gewohnt, den Buchstaben I als Präfix der Klasse zu verwenden, damit Sie auf einen Blick sehen können, dass die aktuelle Klasse eine Schnittstelle ist, die auch eine gute Entwicklungsgewohnheit ist. Wenn Sie sich den Klassennamen ansehen, können Sie leicht unterscheiden, ob es sich um eine Schnittstelle oder eine bestimmte Implementierungsklasse handelt.

Der spezifische Code der IUSERDAO -Schnittstelle lautet wie folgt:

 Paket me.gacl.dao; import me.gacl.domain.user; public interface iuserdao {/*** Finden Sie den Benutzer basierend auf dem Benutzernamen und dem Passwort* @param userername* @param userpwd* @return the User Found*/Benutzerfind (String username, String userpwd). Name* @param userername* @return Der Benutzer gefunden*/Benutzer find (String -Benutzername);}

Für die Methodendefinition in der Schnittstelle kann dies nur analysieren, welche Methoden basierend auf dem spezifischen Unternehmen definiert werden müssen. Unabhängig davon, wie komplex das Unternehmen ist, kann es nicht von dem Basis -CRUD -Betrieb (Addition, Löschung, Änderung und Abfrage) getrennt werden. Die DAO -Ebene interagiert direkt mit der Datenbank, sodass die DAO -Schichtschnittstelle im Allgemeinen vier verwandte Methoden zum Hinzufügen, Löschen, Änderungen und Abfragen enthält.

Erstellen Sie eine userDaoImpl -Klasse unter dem Paket me.gacl.dao.impl

Die UserDaOImpl -Klasse ist eine spezifische Implementierungsklasse der IUSERDAO -Schnittstelle. Für die Benennungsmethode der Implementierungsklasse der Schnittstelle werde ich es gewohnt, sie in Form von "Schnittstellenname (Entfernen Sie das Präfix I) + Impl" oder "Schnittstellenname + Impl": IUSERDAO (Schnittstelle) → UserDaOImpl (Implementierung der Klasse) oder IUSERDAO (Schnittstelle) → IUSERDAIMPL (Implementierung). Dies ist auch eine persönliche Programmiergewohnheit. Der größte Teil des Code, den ich sehe, nennt normalerweise die spezifische Implementierungsklasse der Schnittstelle in einer dieser beiden Formulare. Wie auch immer, Sie müssen in der Lage sein, zu sehen, welche Implementierungsklasse der Schnittstelle entspricht.

Der spezifische Code der UserDaOImpl -Klasse lautet wie folgt:

 Paket me.gacl.dao.impl; import Java.text.SimpledateFormat; import org.domj.document; import org.domj.element; gaCl*/public class userDaoImpl implementiert IUSERDAO {@Overridepublic user find (String -Benutzername, String userpwd) {try {document document = xmlutils.getDocument (); // Verwenden Sie den Ausdruck von XPATH, um XML -Knoten zu manipulieren. @Userpwd = '"+userpwd+"'] "); if (e == null) {return null;} user user = new User (); user.setId (e.attributeValue ("id")); user.setemail (e.attributeValue ("E -Mail"); user.SetUserPWD (e.attributeValue ("userpwd"); user.setusername (e.attributevalue ("username");); sdf = new SimpledateFormat ("yyyy-mm-dd"); user.setBirthday (sdf.parse (birth)); = document.getRootElement (); element user_node = root.addelement ("user"); //Create user node and hang it to rootuser_node.setAttributeValue("id", user.getId());user_node.setAttributeValue("userName", user.getUserName());user_node.setAttributeValue("userPwd", user.getUerpwd ()); user_node.setAttributeValue ("E-Mail", user.getemail (); SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-mm-dd"); user_node.setattributeValue ("Geburtstag",, sdf.format (user.getBirthday ())); xmlutils.writexml (document);} catch (Ausnahme E) {Neue RunTimeException (e);}}@oversidepublic user find (String Benutzername) {try {documents document = xmlutils.GetDocument (); element E = (); document.Selectsinglenode ("// user [@username = '"+userername+"']"); if (e == null) {return null;} user user = new User (); user.setId (e.attributeValue ("id")); user.setemail (e.attributeValue ("E -Mail"); user.SetUserPWD (e.attributeValue ("userpwd"); user.setusername (e.attributevalue ("username");); sdf = new SimpledateFormat ("yyyy-mm-dd"); user.setBirthday (SDF.Parse (Geburt)); Rückgabe des Benutzers;} catch (Ausnahme E) {neue runTimeexception (e);}}}}}}} werfen

3.3. Entwicklungsservice -Schicht (die Serviceschicht bietet alle Geschäftsdienste für die Webschicht)

Erstellen Sie die IUSERService -Schnittstellenklasse im Paket me.gacl.service

Der spezifische Code der IuserService -Schnittstelle lautet wie folgt:

 Paket me.gacl.service; import me.gacl.domain.user; import me.gacl.exception.userexistexception; public interface iuserservice {/*** Registrierungsservice anbieten* @param user* @throws userexistException*/void RegisterUser (Benutzer user) leuchtet userexistexception;/* *** login -service* @Param @Params usexistexception;! @return*/user Loginuser (String -Benutzername, String userPWD);}

Create UserServiceImpl -Klasse im Paket me.gacl.service.impl

Die UserServiceImpl -Klasse ist eine spezifische Implementierungsklasse der IUSERService -Schnittstelle. Der spezifische Code lautet wie folgt:

 Paket me.gacl.service.impl; import me.gacl.dao.iuserdao; import me.gacl.dao.impl.userdaoImpl; import mir.gakl.domain.userwahreIreservice.iusserservice.iusserservice.iusserservice; IUSERDAO userDao = new UserDaOImpl ();@oversidepublic void RegisterUser (Benutzerbenutzer) löscht userexistException {if (userDao.find (user.getUnername ())! UsexistException ("Der registrierte Benutzername existiert bereits !!!");} userDao.add (Benutzer);}@oversidepublic User Loginuser (String -Benutzername, String Userpwd) {return userDao.find (Benutzername, UserPwd);}}}}}}

3.4. Entwickeln Sie die Webschicht

3.4.1. Registrierungsfunktion entwickeln

1. Schreiben Sie ein Registeruiservlet unter das Paket me.gacl.web.ui, um eine Registrierungsschnittstelle für Benutzer bereitzustellen

Nach dem Empfang der Benutzeranforderung springt registeruiservlet zu registrieren.jsp

Der Code von RegisteruIServlet lautet wie folgt:

 Paket me.gacl.web.ui; import Java.io.ioxception; import Javax.servlet.servletException; import Javax.servlet.http.httpServlet; importieren javax.servlet.http.httpletrequest; GaCl* Servlet, das den Benutzern eine registrierte Benutzeroberfläche bietet IOException {Request.GetRequestDispatcher ("/webinf/pages/register.jsp"). Forward (Request, Antwort);} public void dopost (httpServletRequest-Anforderung, httpServletResponse-Antwort) Throws ServletException, IOException {{DOWGE (Anfrage, Antwort);}}}}}}}}}}}}}}}

2. Schreiben Sie einen von Benutzer registrierten JSP-Seitenregister.jsp im/web-inf/Seiten/Verzeichnis

Jede JSP-Seite im Web-Inf-Verzeichnis kann nicht direkt über die URL-Adresse zugegriffen werden.

Wenn das Projekt während der Entwicklung einige sensible Webressourcen enthält, auf die nicht direkt von der Außenwelt zugegriffen werden soll, können Sie in Betracht ziehen, diese sensiblen Webressourcen in das Web-INF-Verzeichnis zu setzen, damit die Außenwelt verboten werden kann, direkt über die URL zuzugreifen.

Der Code der Seite "Register.jsp" lautet wie folgt:

 <%@ page Language = "java" pageCoding = "utf-"%> <! docType html> <html> <kopf> <titels> Benutzerregistrierung </title> </head> <body style = "text-align: center;"> <Form Action = "$ {pageContext.request.ContextPath}/Servicleds/RegiSters.Rect.request.ContextPath}/Service/DEVIERSVISTERLET" method="post"><table><tr><td>Username</td><td><input type="text" name="userName"></td></tr><tr><td>Password</td><td><input type="password" name="userPwd"></td></tr><td>Confirm password</td><td><input type="password" name = "cräfEPWD"> </td> </tr> <tr> <td> E -Mail </td> <td> <Eingabe type = "text" name = "E -Mail"> </td> </tr> <tr> <td> Geburtstag </td> <td> <eingabe type = "name" name = "birthing value = "clear"> </td> <td> <Eingabe type = "surug" value = "register"> </td> </tr> </table> </form> </body> </html>

<form action = "$ {pageContext.request.contextPath}/Servlet/RegiesterServlet" method = "post"> In Register.jsp gibt an, dass das Formular zur Verarbeitung übermittelt und an den Regierservlet übergeben wird

3. schreiben

RegisterServlet dient den folgenden Aufgaben:

1. Empfangen von Formulardaten, die vom Client an den Server übermittelt wurden.

2. Überprüfen Sie die Legalität der Formulardaten. Wenn die Überprüfung fehlschlägt, springen Sie zurück zu Register.jsp und spiegeln Sie die Fehlermeldung an.

3. Wenn die Überprüfung bestanden wird, rufen Sie die Serviceschicht an, um den Benutzer mit der Datenbank zu registrieren.

Um das RegisterServlet zu erleichtern, um Formaten und Verifizierungsformulardaten zu erhalten, habe ich eine Registerformbean zur Überprüfung der Registrierungsformulardaten entwickelt und dann die Webutils -Toolklasse geschrieben, um die vom Client in die Formbeansatz übermittelten Formulardaten zu verkapulieren.

Erstellen Sie eine Registerformbean zur Überprüfung der Registrierungsformulardaten unter dem Paket me.gacl.web.Formbean

Der RegisterformBean -Code lautet wie folgt:

 Paket me.gacl.web.formbean; import Java.util.hashMap; import java.util.map; org.apache.commons.beanutils.locale Element in Register.jsp* Die Verantwortlichkeiten der Registerformbean sind nicht nur für den Wert des Werts des Formulareingangselements in Register.jsp verantwortlich, sondern dienen auch als Legalität des Werts des Formulareingangselements* @Author GaCl **/öffentliche Klasse RegisterformBean {// Die Eigenschaften in der Registerformbean entsprechen dem Namen der Form. private String -Benutzername; // <Eingabe type = "password" name = "userpwd"/> private String userpwd; // <Eingabe type = "password" name = "bestätigenPwd"/> private String bestätigenpwd; // <eingabetyps = "Text" Name "name =" E -Mail "/> private Zeichenfolge E -Mail; // <eingabe -type". Karte <String, String> Fehler = new Hashmap <String, String> (); public map <String, String> getRrors () {Rückgabefehler;} public void setErrors (MAP <String> Fehler> Fehler) {this.Erors = Fehler;}/** Validierungsmethode ist verantwortlich für die Überprüfung der Formelemente der Form, die die Eingabe von Eingabe von Formularen eingeben. Der Benutzername kann nicht leer sein und wenn es sich um einen Buchstaben ABCDABCD * private String userPWD handelt; Das Passwort kann nicht leer sein und wenn es sich um die Nummer * private Zeichenfolge bestätigenPWD; Das Passwort muss mit der zweimaligen * privaten String -E -Mail übereinstimmen. Es kann leer und nicht leer sein, wenn es sich um einen juristischen Postfach* privaten String -Geburtstag handelt. Es kann leer und nicht leer sein, wenn es ein rechtliches Datum ist*/public boolean validate () {boolean isok = true; if (this.username == null || this.username.trim (). Equals ("")) {isok = false; Fehler.put ("username", der Username, der nicht leer ist!! ");););););"). . false; fehler.put ("userpwd", "Das Passwort kann nicht leer sein !!");} else {if (! this.userpwd.matches ("// d {,}")) {isok = false; fehler.put ("userpwd", "Das Passwort muss eine Nummer von -bits sein !!")}}} // private String -Passwort; Die Passwörter müssen gleich sein, wenn die zweimal (this.confirmpwd! Es kann leer sein, nicht null. Wenn es sich um eine legale E -Mail handelt, wenn (this.email! Kann leer und nicht leer sein, wenn es sich um ein rechtliches Datum handelt, wenn (this.birthday! = Null &&! This.birthday.trim (). Equals ("") {try {datelocalConverter convert = new DatelocalConverter (); convert. 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;}public String getConfirmPwd() {return confirmPwd;}public void setConfirmPwd(String confirmPwd) {this.confirmPwd = confirmPwd;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public String getBirthday() {return birthday;}public void setBirthday(String birthday) {this.birthday = birthday;}}

Erstellen Sie eine Webutils -Toolklasse unter dem Paket me.gacl.util. Die Funktion dieser Toolklasse besteht darin, die vom Client in die Formbean über eingereichten Formulardaten zu verkörpern

 Paket me.gacl.util; import Java.util.enumeration; import Java.util.uuid; import Javax.servlet.http.httpServletRequest; import org. {/*** Konvertieren Sie das Anforderungsobjekt in ein T -Objekt* @Param Request* @param clazz* @return*/public static <T> t RequestBean (httpServletRequest -Anfrage, Klasse <T> clazz) {try {t bean = clazz.Newinstance (); while(e.hasMoreElements()){String name = (String) e.nextElement();String value = request.getParameter(name);BeanUtils.setProperty(bean, name, value);}return bean;}catch (Exception e) {throw new RuntimeException(e);}}/*** Generate UUID* @return*/public static String makeId(){return UUid.randomuuid (). ToString ();}}

Schauen wir uns schließlich den vollständigen RegisterServlet an, der für die Behandlung der Benutzerregistrierung verantwortlich ist:

 Paket me.gacl.web.controller; import java.io.ioxception; import java.util.date; import javax.servlet.servletException; import javax.servlet.http.httpsert; import Javax.Servlet.http.httpletrequest, import.http.httpletrequest, import.http.httpletrequest, import.http.httpletrequest, import. javax.servlet.http.httpServletResponse; import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.ConvertUtils; import org.apache.commons.beanutils.Converters.Datelocaleconoconoconoconoconverter; me.gacl.exception.userexistException; import me.gacl.service.iusserservice; import me.gacl.service.impl.userserviceImpl; import me.gacl.util.webutils; erweitert HttpServlet {public void dodget (httpServletRequest -Anforderung, HttpServletResponse -Antwort), die ServletException, IOException {// die vom Client eingereichten Formdaten in die vom Client eingereichte RegisterformBean Registerformbean Formbean = Webutils. (formbean.validate () == false) {// Wenn die Überprüfung fehlschlägt // Das Formular Objekt senden Sie die vom Benutzer gefüllten Formulardaten zurück zum Formularformular auf der Seite register.jsp für die Anzeigeanforderung. register.jsprequest.getRequestDispatcher ("/web-inf/pages/register.jsp"). Forward (Anfrage, Antwort); return;} user user = new user (); try {//convertUtils.register(New DataLocalConverter (), Datum.ClASS.ClASS); user.setId (webutils.makeid ()); // Setzen Sie die ID -Eigenschaft des Benutzers IUSERService Service = new UserServiceImpl (); // Rufen Sie den von der Service Layer bereitgestellten registrierten Benutzerdienst an, um den Benutzerregistrierungsdienst zu erreichen. RegisterUser (Benutzer). String message = string.format ("erfolgreich registriert!! Es wird automatisch zur Anmeldeseite für Sie in Sekunden! request.getContextPath ()+"/servlet/loginuiservlet"); request.setAttribute ("message", message); request.getRequestDispatcher ("/message.jsp"). Forward (Request, Antwort);} catch (UseSerexiste E) {formbean.getRors (). existiert !! "); request.setAttribute (" formbean ", formbean); request.getRequestDispatcher ("/web-inf/pages/register.jsp "). Forward (Request, Antwort);} catch (Ausnahme E) {E.printstacktrace (); // Ausnahme in der Hintergrundanforderung aufzeichnen.

Wenn die gefüllte Überprüfung der Formulardaten, wenn der Benutzer registriert wird, fehlschlägt, speichert der Server ein FormBean -Objekt mit Fehlermeldung und Formulardaten in das Anforderungsobjekt und sendet es dann an die Seite "Register.jsp" zurück. Daher müssen wir das Formbeanschlag im Anforderungsobjekt von der Seite register.jsp ausnehmen und dann die vom Benutzer ausgefüllten Formulardaten in das entsprechende Formularelement erneut auftragen und die Eingabeaufforderung zur Meldung anzeigen, wenn ein Fehler im Formularformular auftritt, so dass der Benutzer weiß, welche Daten illegal sind, um auszufüllen!

Ändern Sie die Seite "Register.jsp", der Code lautet wie folgt:

 <%@ page Language = "java" pageCoding = "utf-"%> <! docType html> <html> <kopf> <titels> Benutzerregistrierung </title> </head> <body style = "text-align: center;"> <Form Action = "$ {pageContext.request.ContextPath}/Servicleds/RegiSters.Rect.request.ContextPath}/Service/DEVIERSVISTERLET" method = "post"> <table> <tr> <td> Benutzername </td> <td> <%-Verwenden Sie den El-Ausdruck $ {}, um Formulardaten zu extrahieren, die im Formenobjekt, das im Anforderungsobjekt (formbean.username) und Fehlermeldung (formbean.Errors.Unername)-%> <Eingabe type), gespeichert ist. value = "$ {formbean.username}"> $ {formbean.Erors.username} </td> </tr> <tr> <td> Passwort </td> <td> <Eingabe type = "password" name = "userpwd" value = "$ {formbean.userpwd}"> $ {formbean.Erors.userpwd} </td> </tr> <tr> <td> Passwort bestätigen </td> <td> <Eingabe type = "Passwort" Name "name =" bestätigen value = "$ {formbean.confirmpwd}"> $ {formbean.erors.confirmpwd} </td> </tr> <tr> <td> E -Mail </td> <td> <Eingabe type = "text" name = "E -Mail" " value = "$ {formbean.email}"> $ {formbean.errors.email} </td> </tr> <tr> <td> Geburtstag </td> <td> <Eingabe type = "text" name = "birthday" " value="${formbean.birthday}">${formbean.errors.birthday}</td></tr><tr><td><input type="reset" value="Clear"></td><td><input type="submit" value="Register"></td></tr></table></form></body></html>

Zu diesem Zeitpunkt wurde die Benutzerregistrierungsfunktion entwickelt!

Die folgenden Tests Die entwickelte Benutzerregistrierungsfunktion:

Geben Sie die URL -Adresse ein: http: // localhost: 8080/webmvcframework/servlet/registeruiservlet, um auf die Seite register.jsp zuzugreifen, und der Betriebseffekt lautet wie folgt:

Wenn das eingegebene Formularelement nicht den Bestätigungsregeln entspricht, kann es nicht registriert werden. Der Betriebseffekt ist wie folgt:

3.4.2. Anmeldefunktion entwickeln

1. Schreiben Sie ein Loginuiservlet unter das Paket me.gacl.web.ui, um den Benutzern eine Login -Oberfläche zu bieten.

Nachdem das LoginuIServlet die Benutzeranforderung empfangen hat, springt es auf Login.jsp zu

Der Code von Loginuiservlet lautet wie folgt:

 Paket me.gacl.web.ui; import Java.io.ioxception; import javax.servlet.servletException; import javax.servlet.http.httpserd; import Javax.servlet.http.httpletrequest; javax.servlet.http.httpServletResponse;/*** @Author gacl* loginuiservlet ist dafür verantwortlich, die Anmeldeschnittstelle für Benutzer auszugeben DOGGE (httpServletRequest-Anforderung, HttpServletResponse-Antwort) löst ServletException, IOException {request.getRequestDispatcher aus ("/web-inf/pages/login.jsp"). Forward (Request, Antwort); {DOGGE (Anfrage, Antwort);}}

2. Schreiben Sie die Benutzeranmeldungs-Seite der Benutzeranmeldung unter/web-inf/Seiten/Verzeichnis

Der Code der Seite Login.jsp ist wie folgt:

 <%@ page Language = "java" pageCoding = "utf-"%> <! docType html> <html> <kopf> <title> Benutzeranmeldung </title> </head> <body> <Form action = "$ {pageContext.request.Contextpath}/servlet/loginServlet" methode "post" username: name = "userername"> <br/> Passwort: <Eingabe type = "password" name = "password"> <br/> <Eingabe type = "value =" login "> </form> </body> </html>

Die <form action = "$ {pageContext.request.ContextPath}/Servlet/loginServlet" method = "post"> in login.jsp gibt an, dass das Formular zur Verarbeitung übermittelt und an den LoginServlet übergeben wird.

3. schreiben

Der Code von LoginServlet lautet wie folgt:

 Paket me.gacl.web.controller; import Java.io.ioxception; import Javax.servlet.servletException; import Javax.servlet.http.httpserd; me.gacl.domain.user; import me.gacl.service.iusserservice; import me.gacl.service.impl.userservice; ServletException, iOException {// den vom Benutzer String username = agetParameter ("Benutzername") ausgefüllten Anmeldebendame ("Benutzername"); // Das von der Benutzer String -Passwort = Anrequenz.GetParameter ("Passwort"); Passwort); if (user == null) {string message = string.format ("sorry, der Benutzername oder das Passwort ist falsch !! Bitte melden Sie sich erneut an! Sie werden automatisch in Sekunden zur Anmeldeseite springen !! <meta http-äquiv = 'aktualisiert' content = '; url =%s' ", request.getContextPath ()+"/servlet/loginuiservlet "); request.setatTribute (" message ", message); Anforderung request.getSession (). setAttribute ("user", user); String message = string.format ("Herzlichen Glückwunsch: %s, Login ist erfolgreich! Diese Seite wird in Sekunden zur Homepage springen! user.getUserName(),request.getContextPath()+"/index.jsp");request.setAttribute("message",message);request.getRequestDispatcher("/message.jsp").forward(request, response);}public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {DOGGE (Anfrage, Antwort);}}

Zu diesem Zeitpunkt wurde die Benutzeranmeldungsfunktion abgeschlossen.

Testen Sie nachstehend die entwickelte Benutzeranmeldungsfunktion und geben Sie die URL -Adresse ein: http: // localhost: 8080/webmvcframework/servlet/loginuiservlet, um auf die Seite Login.jsp zuzugreifen, geben Sie den richtigen Benutzernamen und das Kennwort ein, um sich anzumelden. Der Betriebseffekt lautet wie folgt:

Wenn der eingegebene Benutzername und das eingegebene Kennwort falsch sind, kann die Anmeldung nicht erfolgreich angemeldet werden, und der Betriebseffekt lautet wie folgt:

3.4.3. Entwickeln Sie die Abbrechenfunktion

Schreiben Sie einen LogoutServlet zum Abwickeln des Benutzers unter dem Paket me.gacl.web.Controller

Der Code von LogoutServlet lautet wie folgt:

 Paket me.gacl.web.controller; import java.io.ioxception; import java.text.messageFormat; import Javax.servlet.servletException; import Javax.servlet.http.httpserd; import Javax.servlet.http.http. javax.servlet.http.httpServletResponse; öffentliche Klasse logoutServlet erweitert HttpServlet (public void dodget request.getSession (). removeTtribute ("user"); // Da die Zeichenfolge einzelne Zitate enthält, gibt es Probleme, wenn die messageFormat.Format -Methode verwendet wird, um die Zeichenfolge in diesem Fall zu spleißen //MessageFormat.Format -Methode nur die einzelne Zitate in der Zeichenfolge und füllt den Inhalt nicht in den angegebenen Platzversandvertempel. <meta http-äquiv = 'aktualisieren' content = '; url = {}'/> ", request.getContextPath ()+"/servlet/loginuiservlet "); ! Es wird automatisch zur Anmeldeseite für Sie in Sekundensprung springen! ! <meta http-äquiv = Aktualisierung 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, Antwort);}}

用户登录成功后，会将登录的用户信息存储在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、搭建开发环境

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模式)，希望对大家有所帮助！