Javaweb implementa o código da instância da função de registro de login do usuário (com base no modo servlet+jsp+javabean)

Abaixo, apresentaremos o código de exemplo do Javaweb para implementar a função de login e registro de usuários por meio de imagens e textos. Vamos dar uma olhada.

1. Introdução ao Servlet+JSP+Javabean Development Model (MVC)

Servlet+JSP+Javabean Modo (MVC) é adequado para o desenvolvimento de aplicativos da Web complexos. Nesse modo, os servlets são responsáveis ​​pelo processamento de solicitações de usuário, o JSP é responsável pela exibição de dados e o Javabean é responsável por encapsular dados. O programa Modo Servlet+JSP+Javabean possui níveis claros entre os módulos, e o desenvolvimento da Web é recomendado para usar esse modo.

Aqui, usamos o programa de registro de login de usuários mais usado para explicar o modelo de desenvolvimento de servlet+jsp+javabean. Através deste programa de registro de login de usuário, casos abrangentes, conectamos os pontos de conhecimento de XML, XPath, Servlet e JSP que aprendemos antes.

2. Crie um projeto da web com a arquitetura MVC

Crie um novo projeto WebMVCFramework no Myeclipse, importe o pacote de desenvolvimento (pacote JAR) exigido pelo projeto e crie os pacotes exigidos pelo projeto. No desenvolvimento de Java, o nível de arquitetura é refletido na forma de um pacote

Uma boa arquitetura do projeto Javaweb deve ter os 11 pacotes acima, o que o deixa claro e as responsabilidades entre cada camada clara. Ao criar uma arquitetura do projeto Javaweb, crie os pacotes na ordem de 1 a 11 acima: Domínio → Dao → Dao.impl → Serviço → Service.impl → Web.Controller → Web.ui → Web.Filter → Web.Listener → Util → Junit.Test. Depois que o nível do pacote for criado, a arquitetura do projeto será determinada. Obviamente, no desenvolvimento real do projeto, pode não ser completamente baseado em

Como mencionado acima, criamos uma hierarquia de pacotes, mas com base na situação real do projeto, também podemos precisar criá -lo.

Sua bolsa, isso depende da necessidade do projeto.

No diretório SRC (diretório de categoria), crie um arquivo xml (db.xml) para salvar dados do usuário (db.xml)

Crie um diretório de páginas no diretório Web-Inf. O diretório do Páges armazena algumas páginas JSP protegidas do sistema (não permitindo que os usuários acessem diretamente através de endereços URL). Se os usuários desejam acessar essas páginas JSP protegidas, eles só poderão usar o servlet no pacote me.gacl.web.ui

O projeto criado é mostrado na figura a seguir (Figura 1):

Figura 1

3. Escrita de código da arquitetura hierárquica

O código da arquitetura hierárquica também é escrito na ordem da [camada do modelo de domínio (domínio)] → [camada de acesso a dados (dao, dao.impl)] → [camada de processamento de negócios (serviço, serviço.impl)] → [camada de expressão (web.controller, web.ui, [web.filter, ut)] → [) → (Junit.test)].

3.1. Desenvolver camada de domínio

Crie uma classe de usuário sob o pacote me.gacl.domain

O código específico da classe de usuário é o seguinte:

 pacote me.gacl.Domain; importar java.io.Serializable; importar java.util.date;/*** @author gacl*entidade do usuário classe*/public class User em email/string string {private private private string string uRialVersionUid = -l; // usuário userring string string; // private private string string; Aniversário do usuário Data privada aniversário; public string getId () {return id;} public void setId (string id) {this.id = id;} public string getUserName () {return userName;} public void setUserPeTPw (string userName) {this.username = username;} public string getUserPd () {) {this {this.userpwd = userpwd;} public string getEmail () {retorna email;} public void setEmail (string email) {this.email = email;} public date getBirthday () {aniversário;} public void setBirthday (data de aniversário) {this.birthday =;};

3.2. Desenvolva a camada de acesso a dados (Dao, Dao.impl)

Crie uma classe de interface iuserdao no pacote me.gacl.dao. Para classes de interface de desenvolvimento, estou acostumado a usar a letra I como o prefixo da classe, para que você possa ver rapidamente que a classe atual é uma interface, o que também é um bom hábito de desenvolvimento. Observando o nome da classe, você pode facilmente distinguir se é uma interface ou uma classe de implementação específica.

O código específico da interface iuserdao é o seguinte:

 pacote me.gacl.dao; importar me.gacl.domain.user; interface pública IUSERDAO {/*** Encontre o usuário com base no nome do usuário e na senha* @param userName* @param userpwd* @return o usuário encontrado*/usuário find (string userName, string userpwd); ***; Nome* @param nome de usuário* @return the user encontrado*/usuário find (string userName);}

Para a definição do método na interface, isso pode analisar apenas quais métodos precisam ser definidos com base nos negócios específicos. No entanto, por mais complexo que seja o negócio, ele não pode ser separado da operação básica do CRUD (adição, exclusão, modificação e consulta). A camada DAO interage diretamente com o banco de dados; portanto, a interface da camada DAO geralmente possui quatro métodos relacionados para adicionar, exclusão, modificação e consulta.

Crie uma classe Userdaoimpl sob o pacote me.gacl.dao.impl

A classe UserdaoImpl é uma classe de implementação específica da interface iuserdao. Para o método de nomeação da classe de implementação da interface, estou acostumado a nomeá -lo na forma de "nome da interface (remova o prefixo I) + implic" ou "Nome da interface + Impl": iuserdao (interface) → userdaoImpl (classe de implementação) ou iuserdao (interface) → iUerdaoImpl (implementação) ou iuserdao (interface) → iUserdaoIMPL (implementação) ou iuserdao. Este também é um hábito de programação pessoal. A maioria do código que vejo geralmente nomeia a classe de implementação específica da interface em uma dessas duas formas. De qualquer forma, você precisa ver qual classe de implementação correspondente à interface está rapidamente.

O código específico da classe UserdaOIMPL é o seguinte:

 pacote me.gacl.dao.impl; importar java.text.simpledEformat; importar org.domj.document; importar org.domj.element; importar me.gacl.dao.userDao; importar me.gacl.domain.user; import.gacl.util.xmLutils; gacl*/public class UserdaoImpl implementa IUSERDAO {@OverridePublic User Find (String UserName, String userpwd) {try {document document = xmlutils.getDocument (); // use a expressão xpath para manipular xml nodEseSelement e = (element) document.selectSingLenNenNodLenEnode para manipular xml/userSelement e = (elemento). @Userpwd = '"+userpwd+"'] "); if (e == null) {return null;} usuário usuário = novo User (); user.setId (e.attributeValue ("id")); user.setEmail (e.attributeValue ("email")); user.setUserpwd (e.attributeValue ("userPwd"); User.attrEname (e.attributeValue ("Username");); SimpledateFormat ("AAAA-MM-DD"); User.SetBirthday (SDF.Parse (nascimento)); Return User;} Catch (Exceção e) {Throw New RunTimeException (e);}}@suplefresswarnings ("deprecation")@substituirpublic void (usuário (usuário) {{{Try document.getrootelement (); elemento user_node = root.addElement ("usuário"); // Crie o nó do usuário e pendure -o para rootuser_node.setAttributeValue ("id", user.getId ()); user_node.setAttributeValue ("nome de usuário", user.getUserName ();); userTeReTr_Node.SetTrributeValue ("userPwd" ,getUSerPwd (); user.getEmail ()); simpledateFormat sdf = new SimpleDateFormat ("yyyy-mm-dd"); user_node.setAttributeValue ("aniversário", sdf.format (user.PeTBirthday ()); xmlutils.writexml (document);} catch (excepction) {); LINDO (Nome de usuário da String) {try {document document = xmlutils.getDocument (); elemento e = (elemento) document.selectsinglenode ("// user [@username = '"+userName+"']"); User (); user.setId (e.attributeValue ("id")); user.setEmail (e.attributeValue ("email")); user.setUserpwd (e.attributeValue ("userPwd"); User.attrEname (e.attributeValue ("Username");); SimpledateFormat ("AAAA-MM-DD"); User.SetBirthday (SDF.Parse (nascimento)); Return User;} Catch (Exceção e) {Throw New RunTimeException (e);}}}

3.3. Camada de serviço de desenvolvimento (a camada de serviço fornece todos os serviços de negócios para a camada da web)

Crie a classe de interface iUserService no pacote me.gacl.service

O código específico da interface iuserService é o seguinte:

 pacote me.gacl.service; importar me.gacl.Domain.User; importar me.gacl.exception.UseRexistException; interface pública IUSERSERVICE {/*** Forneça serviço de registro* @param useRexistException; userexistexception*/void RegisterIr (usuário) userexistException; @return*/User LoginUser (Nome de usuário da String, String userPwd);}

Criar UserServiceImpl Class no pacote me.gacl.service.impl

A classe UserServiceImpl é uma classe de implementação específica da interface iuserService. O código específico é o seguinte:

 pacote me.gacl.service.impl; importar me.gacl.dao.iuserdao; importar me.gacl.dao.impl.userdaoimpl; importar me.gacl.domain.UserSerSerSeRSeRSeRSeRSeRSeRSECSEMERSUSTER.IMERSUSTER.IMERSERSUSTER.IMERSERSUSTER.IMERSERSIDER.IMERSERSIDER.IMERSERSIDER.ius.ius.ius.ius ME.gacl.exception.usexistException; Iuserdao userdao = new userdaoImpl ();@substituir o userexistexception {if (userdao.find (user.getUserName)! UserexistException ("O nome de usuário registrado já existe !!!");} userdao.add (usuário);}@substituir Loginuser do usuário do usuário (string userName, string userpwd) {return userdao.find (nome de usuário, userpwd);}}}}}}}}

3.4. Desenvolva a camada da web

3.4.1. Desenvolver função de registro

1. Escreva um RegisteruServlet sob o pacote me.gacl.web.ui para fornecer uma interface de registro para usuários

Depois de receber a solicitação do usuário, o RegisterVerttlet salta para Register.jsp

O Código de RegisteruServlet é o seguinte:

 pacote me.gacl.web.ui; importar java.io.ioException; importar javax.servlet.servletexception; importar javax.servlet.http.httpServLet; import javax.servlet.htttp.htttsletletrequest; GACL* servlet que fornece aos usuários interface do usuário registrada* O RegisteruServlet é responsável por produzir a interface de registro para usuários* Quando um usuário acessa o registrouiserServlet, ele salta para a página Register.jsp no Web-Inf/Pages Directory*/Public Class RegisterLeTletLends HTTPSletLe Servletexception, ioexception {request.getRequestDispatcher ("/web-inf/páginas/registr.jsp"). Forward (solicitação, resposta);} public void DoPost (httpServleTrequest Solicy, httpServLeondResponse resposta) lança servirxception}

2. Escreva um usuário registrado na página JSP Register.jsp no/web-inf/páginas/diretório

Qualquer página JSP localizada no diretório Web-Inf não pode ser acessada diretamente através do endereço URL.

Durante o desenvolvimento, se houver alguns recursos da Web confidenciais no projeto que não desejam ser acessados ​​diretamente pelo mundo exterior, você pode considerar colocar esses recursos da Web sensíveis no diretório Web-Inf, para que o mundo exterior possa ser proibido de acessar diretamente através do URL.

O código da página Register.jsp é o seguinte:

 <%@ Page Language = "Java" PageEncoding = "Utf-"%> <! Doctype html> <html> <head> <titter> Registro do usuário </ititure> </ad Head> <Body style = "text-align: Center;"> <form ação = "$ {pageContext.request.Contetpath: Method = "Post"> <table> <tr> <td> nome de usuário </td> <td> <input type = "text" name = "userrame"> </td> </tr> <tr> <td> senha </td> <td> <input Type = "senha" name = "userp"> </td> </td> <td> <td> type = "senha" name = "confirmpwd"> </td> </tr> <tr> <td> email </td> <td> <input type = "text" name = "email"> </td> <tr> <tr> <td> aniversário </td> <td> <input type = "text" name = "" " type = "reset" value = "clear"> </td> <td> <input type = "submit" value = "registring"> </td> </tr> </tabela> </form> </body> </html>

<Form Action = "$ {PageContext.request.ContextPath}/servlet/RegisterServlet" Method = "post"> em registro.jsp indica que o formulário é enviado e entregue ao serviço Register para processamento

3. Escreva um serviço de registro para lidar com o registro do usuário sob o pacote me.gacl.web.controller

RegisterServlet atende às seguintes responsabilidades:

1. Receba os dados do formulário enviados pelo cliente ao servidor.

2. Verifique a legalidade dos dados do formulário. Se a verificação falhar, volte para o registro.jsp e ecoe a mensagem de erro.

3. Se a verificação for passada, ligue para a camada de serviço para registrar o usuário no banco de dados.

Para facilitar o registro do registro para receber dados do formulário e verificação do formulário, projetei um registroFormBean para verificação dos dados do formulário de registro e, em seguida, escrevi a classe de ferramentas Webutils para encapsular os dados do formulário enviados pelo cliente no formbean.

Crie um registroFormBean para verificar os dados do formulário de registro sob o pacote me.gacl.web.formbean

O Código RegisterFormBean é o seguinte:

 pacote me.gacl.web.formBean; importar java.util.hashmap; importar java.util.map; importar org.apache.commons.beanutils.locale.converters.dateleconverter;/*** O registro de registro encapsulado é usado para receber o valor do formulário do formulário do formulário do formulário do formulário. Nome do formulário Item de entrada no registro.jsp* As responsabilidades do registroFormBean não são apenas responsáveis ​​por receber o valor do item de entrada do formulário no registro.jsp, mas também serve como a legalidade do valor do formulário Item* @Author Gacl **/public Class RegisterBean {// O Item. Nome de usuário de String private = "TIPO // <input type =" senha "name =" userpwd "/> private string userpwd; // <input type =" senha "name =" confirmpwd "> private string; aniversário;/*** A mensagem de erro ao usuário quando a verificação falha*/mapa privado <string, string> erros = new hashmap <string, string> (); mapa public <string, string> geterrors () {return errors;}* ** IMATROTERRORS (MAPA METHOLIGER <, String> Errors) {this.errors; nome de usuário; O nome de usuário não pode estar vazio e, se for - letra abcdabcd * private string userpwd; A senha não pode estar vazia e, se for - o número * String privada confirmpwd; A senha deve ser a mesma que o e -mail de duas vezes * String privada; Pode estar vazio, não vazio se for um aniversário legal de caixa de correio* Private String; Pode estar vazio, não vazio, se for uma data legal*/public boolean validate () {boolean isok = true; if (this.username == null || this.username.trim (). Equals ("" ")) {isok = false. errors.put (" nome de uso "," o nome de uso não pode ser! (! this.username.matches ("[a-za-z] {,}")) {isok = false; errors.put ("nome de usuário", "o nome de usuário deve ser uma letra do -bit !!");}} se (this.userpwd == null || this.Userpwd.Trim. false; errors.put ("userpwd", "a senha não pode estar vazia !!");} else {if (! this.userpwd.matches ("// d {,}")) {isok = false; errors.put ("userpwd", "a senha deve ser uma série de -bits !! As senhas devem ser as mesmas quando as duas vezes são (this.confirmpwd! = Null) {if (! This.confirmpwd.equals (this.userpwd)) {isok = false; errors.put ("confirmpwd", "as senhas são inconsistentes quando as duas vezes não são null !! Pode estar vazio, não nulo. Se for um email legal se (this.Email! = Null &&! This.email.trim (). Equals ("")) {if (! This.mail.matches ("// w+@// w+(// w+)+")) {isok = false.put.put ("e -mail} //) Pode estar vazio, não vazio, se for uma data legal se (this.birthday! = Null &&! This.birthday.trim (). Equals ("")) {try {datelocaleConverter convert = new Datelocaleconverter (); convers.Convert (this.birthday); "Catch (EXCUTCALECK) {EXCUTCALCALECOKEK (); DATE !! ");}} retornar Isok;} public String getUserName () {retornar nome de usuário;} public void SetUserName (String UserName) {this.username = username;} public string getUserpwd () {return userpwd;} public void setUserpwd (stringpwd) {userpwd;} public vazio getConfirmpwd () {return confirmpwd;} public void setConfirmpwd (string confirmpwd) {this.confirmpwd = confirmpwd;} public string getemail () {return email;} public void setEmail (string email) {this.email = email;} string string; {this.birthday = aniversário;}}

Crie uma classe de ferramentas webutils no pacote me.gacl.util. A função desta classe de ferramentas é encapsular os dados do formulário enviados pelo cliente no formbean

 pacote me.gacl.util; importar java.util.enumeration; importar java.util.uuid; importar javax.servlet.http.httpServletRequest; import org.apache.commons.beanutils.BeanS;/*** @author gacl*encanta {/*** Converta o objeto Solicitação em um objeto T* @param request* @param clazz* @return*/public static <t> t requestBean (httpServletRequest Request, class <t> clazz) {tente {t bean = clazz.newinstance (); enumeração <string> e = secut.get.TeMernames (); while (e.hasMoreElements ()) {string name = (string) e.NextElement (); String value = request.getParameter (nome); beanutils.setProperty (bean, nome, valor);} retornar (**l) captura (Exceção e) {throw runtimeException (e);/}}/*** generate uuid* Uuid.randomuuid (). ToString ();}}

Por fim, vamos dar uma olhada no Código de Serviço Register completo responsável pelo manuseio do registro do usuário:

 pacote me.gacl.web.controller; importar java.io.ioException; importar java.util.date; importar javax.servlet.servletexception; importar javax.servlet.http.httpSlet; import javax.servlet.http.httServlet; javax.servlet.http.HttpServletResponse;import org.apache.commons.beanutils.BeanUtils;import org.apache.commons.beanutils.ConvertUtils;import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;import me.gacl.domain.User;import me.gacl.exception.UseRexistException; importar me.gacl.service.iusserService; importar me.gacl.service.impl.userServiceImpl; importar me.gacl.util.webutils; importe me.gacl.web.formbean.registormbean; RegisterServlet estende httpServlet {public void Doget (solicitação httpServletRequest, resposta httpServletResponse) lança servletexception, ioexception {// encapsulate os dados do formulário enviado pelo cliente, o recados registrFormFormBeanBean = webutils.requestBean (WebutilEn); Registro if (formBean.validate () == false) {// Se a verificação falhar //, envie o objeto do formulário que encapsula os dados do formulário preenchidos pelo usuário de volta ao formulário no formulário na página Register.jsp para exibir request.SetAttribute ("formBean", formbean); a verificação falha para indicar que existe um problema com um problema com o problema " register.jsprequest.getRequestDispatcher ("/web-inf/páginas/register.jsp"). Forward (solicitação, resposta); return;} usuário user = new user (); try {//convertutils.register(new DateloconECONVERTER (), formborm.class; user.setId (webutils.MakeId ()); // Defina a propriedade ID do usuário IUSERSERVICE SERVIÇO = new UserServiceImpl (); // Ligue para o Serviço de Usuário Registrado fornecido pela Camada de Serviço para obter o Serviço de Registro do Usuário.RegisterUser (Usuário); String message = string.format ("Registrado com sucesso!! Ele pulará automaticamente para a página de login para você em segundos!! <Meta http-equiv = 'refresh' content = '; url =%s'/>", request.getContextPath ()+"/servlet/LogInuiservlet"); request.setAttribute ("message", message); request.getRequestDispatcher ("/message.jsp"). forward (request, resposta);} "userException e) {FormBean.GererrorRors (). existe !! "); request.setAttribute (" formBean ", formBean); request.getRequestDispatcher ("/web-inf/páginas/register.jsp "). Forward (solicitação, resposta);} catch (Exceção e) {e.printstacktrace (); // Registre a exceção na solicitação de segundo plano.

Se a verificação dos dados do formulário preenchidos falharem quando o usuário se registrar, o servidor armazenará um objeto FormBean com a mensagem de erro e formar dados no objeto Solicitação e o enviará de volta para a página Register.jsp. Portanto, precisamos retirar o objeto FormBean no objeto Solicitação da página Register.jsp e, em seguida, reaplicar os dados do formulário preenchidos pelo usuário no item de formulário correspondente e também exibir a mensagem imediata quando ocorre um erro no formulário, para que o usuário saiba que os dados são ilegais para preencher!

Modificar a página Register.jsp, o código é o seguinte:

 <%@ Page Language = "Java" PageEncoding = "Utf-"%> <! Doctype html> <html> <head> <titter> Registro do usuário </ititure> </ad Head> <Body style = "text-align: Center;"> <form ação = "$ {pageContext.request.Contetpath: Method = "Post"> <tabela> <tr> <td> nome de usuário </td> <td> <%-use a expressão EL $ {} para extrair dados de formulário encapsulados no objeto FormBean armazenado no objeto de solicitação (FormBean.Username) e mensagem de erro (FormBean.errors.ername)-%> <input) value = "$ {formbean.username}"> $ {formbean.errors.username} </td> </tr> <tr> <td> senha </td> <td> <input type = "senha" name = "userpwd" value = "$ {formbean.userpwd}"> $ {formbean.errors.userpwd} </td> </tr> <tr> <td> confirm senha </td> <td> <input type = "senha" name = "confirmpwd" value = "$ {formbean.confirmpwd}"> $ {formbean.errors.confirmpwd} </td> </tr> <tr> <td> email </td> <td> <input type = "text" name = "email" value = "$ {formBean.email}"> $ {formbean.errors.email} </td> </tr> <tr> <td> aniversário </td> <td> <input type = "text" name = "aniversário" value = "$ {formbean.birthday}"> $ {formbean.errors.birthday} </td> </tr> <tr> <td> <input type = "reset" value = "clear"> </td> <td> <input type = "submit"/"register> </td> </td> </td>

Neste ponto, a função de registro do usuário foi desenvolvida!

Os seguintes testes a função de registro de usuário desenvolvida:

Digite o endereço da URL: http: // localhost: 8080/webmvcframework/servlet/RegisteruServlet para acessar a página Register.jsp, e o efeito da operação é o seguinte:

Se o item de formulário inserido não cumprir as regras de verificação, ele não poderá ser registrado. O efeito de operação é o seguinte:

3.4.2. Desenvolver função de login

1. Escreva um LogInuServlet no pacote me.gacl.web.ui para fornecer aos usuários uma interface de login.

Depois que o LogInuServlet recebe a solicitação do usuário, ele salta para login.jsp

O Código de Loginuiservlet é o seguinte:

 package me.gacl.web.UI;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.httpServletResponse;/*** @author gacl* O LogInuiservlet é responsável por emitir a interface de login para usuários* Quando o usuário acessa o LoginuiserServlet, ele pula para a página Login.jsp na web-in/Pages Directory*/public Class) Doget (httpServletRequest Solicy, httpServletResponse resposta) lança servletexception, ioexception {request.getRequestDispatcher ("/web-inf/páginas/login.jsp"). {Doget (solicitação, resposta);}}

2. Escreva a página Login de Login.jsp do usuário em/web-inf/páginas/diretório

O código da página login.jsp é o seguinte:

 <%@ página linguagem = "java" PageEncoding = "utf-"%> <! name = "Nome de usuário"> <br/> Senha: <input type = "senha" name = "senha"> <br/> <input type = "submit" value = "login"> </morm> </body> </html>

O <Form Action = "$ {PageContext.Request.ContextPath}/Servlet/LogInservlet" Method = "Post"> em login.jsp indica que o formulário é enviado e entregue ao Loginservlet para processamento.

3. Escreva um LogInservlet para lidar com o login de usuários no pacote me.gacl.web.controller

O código de LogInservlet é o seguinte:

 pacote me.gacl.web.controller; importar java.io.ioException; importar javax.servlet.servleTexception; importar javax.servlet.http.httpServlet; import jAVAX.Servlet.htttp.httpSletLestlestt; me.gacl.domain.User;import me.gacl.service.IUserService;import me.gacl.service.impl.UserServiceImpl;/*** servlet handles user login* @author gacl**/public class LoginServlet extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response)throws Servletexception, ioexception {// Obtenha o nome de usuário de login preenchido pelo usuário string userName = request.getParameter ("nome de usuário"); // obtenha a senha de login preenchida pelo serviceIrtIMPRICEMP (stringIrtIMP); senha); if (user == null) {string message = string.format ("Desculpe, o nome de usuário ou a senha está incorreto !! Por favor, faça o login novamente! Você automaticamente pulará para a página de login em segundos !! <meta http-equiv = 'refresch' content = '; url =%s' ", request.getContextPath ()+"/servlet/loginuiservlet "); request.setAttribute (" message ", message); request.getRequestDispather ("/message.jsp "). request.getSession (). SetAttribute ("Usuário", usuário); string message = string.format ("Parabéns: %s, Login é bem-sucedido! Esta página vai pular para a página inicial em segundos!! user.getUserName (), request.getContextPath ()+"/index.jsp"); request.setAttribute ("message", message); request.getRequestDispatcher ("/message.jsp"). Forward (request, resposta);} public void doPost (HTTPSETLEETLEETRECTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREXTREstRletrsLestr); {Doget (solicitação, resposta);}}

Neste ponto, a função de login do usuário foi concluída.

Abaixo, teste a função de login do usuário desenvolvido, digite o endereço da URL: http: // localhost: 8080/webmvcframework/servlet/logInUervlet para acessar a página Login.jsp, digite o nome de usuário e a senha corretos para fazer login, o efeito da operação é o seguinte:

Se o nome de usuário e a senha inseridos estiverem incorretos, o login não poderá ser conectado com sucesso e o efeito da operação é o seguinte:

3.4.3. Desenvolva a função de cancelamento

Escreva um logoutServlet para lidar com o Logout do Usuário no pacote me.gacl.web.controller

O código de logoutServlet é o seguinte:

 pacote me.gacl.web.controller; importar java.io.ioException; importar java.text.messageFormat; importar javax.servlet.servletexception; import javax.servlet.http.httpslet; import javax.servlet.port.http.httP.TtP. javax.servlet.http.HttpServletResponse;public class LogoutServlet extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//Remove the user object stored in the session to implement the logout function request.getSession (). Removeattribute ("Usuário"); // Como a sequência contém citações únicas, haverá problemas ao usar o método messageFormat.Format para unir a string nesse caso //MessageFormat.Format Método Remofformat.Format A Mensagem de Scrod.Formats Remefformat.Format RemonsFformAformat. <meta http-equiv = 'refresh' content = '; url = {}'/> ", request.getContextPath ()+"/servlet/loginuiservlet "); system.out.println (tempstr); // resultado de saída: logout com sucesso! ! Ele irá automaticamente pular para a página de login para você em segundos! ! <meta http-equiv = atualização 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, resposta);}}

用户登录成功后，会将登录的用户信息存储在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. Construa um ambiente de desenvolvimento

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