Controle de comutação JSP real do JBuilder2005 (3)
Autor：Eve Cole
Data da Última Atualização：2009-07-02 17:10:13
Como switch.jsp é especificado como o arquivo JSP de resposta por meio do atributo action no formulário login.jsp, quando o usuário seleciona o usuário de login em login.jsp e insere a senha para enviar o formulário, o cliente enviará uma solicitação HTTP para o servidor e o servidor Ou seja, chame switch.jsp para responder a esta solicitação.
Os dados dos componentes de nome de usuário e senha no formulário serão passados para o switch.jsp do servidor por meio de uma solicitação HTTP. O servidor encapsulará essas informações no objeto de solicitação e as transmitirá ao switch.jsp, para que o switch.jsp possa ser recuperado. através de request.getParameter(String paraName) Obtenha esses dois valores.
String userId = request.getParameter("userId");
String senha = request.getParameter("senha"); |
Imagine se o formulário login.jsp tiver mais de 10 componentes de dados, seu valor deve ser obtido através do número correspondente de métodos request.getParameter() em switch.jsp. Além disso, se os dados não forem do tipo string de campo, mas sim um número inteiro ou de ponto flutuante, uma vez que os valores retornados pelo método request.getParameter() são todos Strings, a conversão de tipo deve ser realizada não apenas. tedioso, mas também sujeito a erros.
JSP permite que você receba dados de formulários da web por meio do Bean de maneira mapeada. O Bean mapeia os dados do formulário de acordo com esta regra: Nome do atributo Bean = nome do componente de dados do formulário, ou seja, todos os campos de dados do formulário com o mesmo nome de atributo Bean são preenchidos automaticamente. o Bean e conclua a conversão do tipo de dados. Por exemplo, existem dois componentes de dados no formulário login.jsp, um é denominado userId e o outro é password. Defina um Bean User.java com o mesmo nome dos atributos userId e password. no formulário. Valor do componente de dados.
Escreva User.java
Vamos primeiro escrever o Bean User.java e criar User.java no projeto. O código é o seguinte:
Listagem de código 7 User.java
1. pacote livraria;
2.
3. Classe pública Usuário
4. {
5. string privada userId;//userId
6. senha de string privada; //senha
7. string privada nome_do_usuário;//nome do usuário
8. string pública getSenha() {
9. retornar senha;
10.}
11. String pública getUserId() {
12. retornar ID do usuário;
13.}
14. public String getNomeUsuário() {
15. retornar nome de usuário;
16.}
17. public void setPassword(String senha) {
18. esta.senha = senha;
19.}
20. public void setUserId(String userId) {
21. this.userId = userId;
vinte e dois. }
23. public void setUserName(String nome_do_usuário) {
24. this.userName=userName;
25.}
26.} |
Além dos dois nomes de atributos userId e password, há também um atributo de nome de usuário userName. O valor deste atributo não é recebido do formulário login.jsp. Quando o nome de usuário e a senha são verificados corretamente, o nome de usuário é obtido dos dados. tabela T_USER e armazenados nestas Propriedades para que possam ser referenciados em outro lugar, salve e compile esta classe.
dica:
Você pode criar rapidamente o código User.java por meio da ferramenta Bean Express do JBuilder. Em circunstâncias normais, você deve criar propriedades do Bean por meio do Bean Express. |
Escrever programa de página
Após criar o Bean de User.java, procedemos à criação do switch.jsp e referenciamos este Bean no switch.jsp.
Inicie o assistente Criar JSP através de Arquivo->Novo..->Web->clique duas vezes no ícone JSP.
1. Especifique o nome switch.jsp
 Figura 10 Especifique o nome de switch.jsp |
Continue pressionando Próximo para ir para a etapa 3 do assistente.
2. Referência User.java Bean
 Figura 11 Especificar Bean referenciado em JSP |
Clique no botão Adicionar Bean... para abrir a caixa de diálogo Selecionar uma Classe. Selecione a classe bookstore.User na caixa de diálogo, conforme mostrado na figura a seguir:
 Figura 12 Selecione a classe como Bean |
Após pressionar OK, retorne à caixa de diálogo na etapa 3 do assistente. Neste momento, há uma linha adicional de registros na lista Bean da caixa de diálogo. Você pode especificar um nome para o Bean na coluna ID e especificar. o escopo do Bean no Escopo, conforme mostrado na figura abaixo:
 Figura 13 Referência a um Bean |
Chamamos o User's Bean de userBean e definimos seu escopo para o domínio da página. O domínio da página é o escopo da página e está disponível no escopo da página atual. Quando o JSP retorna uma resposta ou a solicitação é transferida para outras páginas JSP, ele não está mais disponível.
·Escopo da solicitação: Quando uma solicitação é gerada, ela é válida dentro do escopo até que a resposta seja retornada. Por exemplo, um Bean declarado como escopo da solicitação em a.jsp, quando a.jsp transfere a solicitação para a página b.jsp. Ainda estará disponível no meio do ano.
·Escopo da sessão: Está disponível dentro do ciclo de sessão do usuário. O ciclo da sessão vai desde o momento em que o usuário faz login no sistema até sair do sistema.
·Escopo da aplicação: Este escopo é o mais longo, indicando que o contêiner web é válido até ser iniciado até ser fechado.
Pressione Próximo para ir para a próxima etapa.
3. Definir itens de configuração em execução
Na última etapa do assistente, você pode gerar um item de configuração de tempo de execução para o JSP criado. Embora o assistente defina a criação de um item de configuração de tempo de execução como opção padrão, acho que esse não é um valor padrão razoável. criar um item de configuração de tempo de execução, não crie um item de configuração de execução JSP, conforme mostrado na figura a seguir:
Pressione o botão Concluir para criar o arquivo switch.jsp com o seguinte código:
Listagem de código 8 switch.jsp criado pelo assistente
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2.＜html＞
3. ＜cabeça＞
4. ＜título＞
5. mudar
6. ＜/título＞
7. ＜/cabeça＞
8. ＜jsp:useBean id="userBean" escopo="page" class="bookstore.User" /＞
9.＜jsp:setProperty name="userBean" property="*" /＞
10. ＜corpo bgcolor="#ffffff"＞
11. ＜h1＞
12. JSP gerado pelo JBuilder
13.＜/h1＞
14. ＜/corpo＞
15.＜/html＞ |
A linha 8 é a tag JSP que faz referência ao Bean. A linha 9 preenche os valores dos atributos do Bean com os dados do formulário, ou seja, preenche os parâmetros de solicitação nos atributos do Bean por correspondência de nome e completa a conversão de tipo ao mesmo tempo (apenas). tipos de dados básicos ou A conversão só pode ser concluída se o construtor suportar). Após a execução da linha 9, os atributos userId e senha em userBean serão configurados com os valores de nome de usuário e senha enviados na página login.jsp.
Como switch.jsp é usado apenas para controle e não precisa exibir conteúdo para o cliente, removemos o código HTML em switch.jsp e ajustamos switch.jsp para:
Listagem de código 9 switch.jsp após remover o código HTML estático
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜jsp:useBean id="userBean" escopo="page" class="bookstore.User" /＞
3.＜jsp:setProperty name="userBean" property="*" /＞ |
Forneça um Scriptlet em switch.jsp para enviar o userId e a senha ao banco de dados e compará-los com os usuários na tabela T_USER para ver se são usuários legítimos e redirecionar para páginas diferentes com base nos resultados da verificação. O código final do switch.jsp é assim:
Listagem de código 10 switch.jsp final
1.＜%@page contentType="text/html; charset=GBK"%＞
2. ＜%@page import="livraria.*"%＞
3. ＜%@page import="java.sql.*"%＞
4. ＜jsp:useBean id="userBean" scope="session" class="bookstore.User"/＞
5.＜jsp:setProperty name="userBean" propriedade="*"/＞
6,＜%
7. Conexão conn = nulo;
8. tente {
9. conexão = DBConnection.getConnection();
10. PreparedStatement pStat = conn.prepareStatement(
11. "selecione USER_NAME de T_USER onde USER_ID=? e senha = ?");
12. pStat.setString(1, userBean.getUserId());
13. pStat.setString(2, userBean.getPassword());
14. ResultSet rs = pStat.executeQuery();
15. if (rs.next()) { //A senha está correta
16. userBean.setUserName(rs.getString(1));//Definir nome de usuário
17. session.setAttribute("ses_userBean", userBean);//Coloque userBean no objeto Session
18. %＞＜jsp:forward page="welcome.jsp "＞＜/jsp:forward＞
19. ＜%} else { //Senha errada%＞
20. ＜jsp:forward page="fail.jsp"＞＜/jsp:forward＞
21,＜%
22. }} finalmente {
23. if(conn != null) conn.close();
vinte e quatro. }
25.%＞ |
·Introduza as classes necessárias no código Scriptlet nas linhas 2 a 3.
·As linhas 7 a 14 do código enviam instruções SQL de consulta ao banco de dados e retornam os resultados.
·A linha 15 determina indiretamente se a senha do usuário está correta, verificando o número de registros no conjunto de resultados.
· As linhas 16 a 18 são os códigos de resposta para senhas de usuário corretas. Primeiro, preencha o valor do atributo userBean com o atributo USER_NAME do conjunto de resultados, depois coloque o objeto userBean na Sessão e, finalmente, vá para a página Welcome.jsp.
·Quando o usuário digita uma senha incorreta, não haverá registro no conjunto de resultados. Neste momento, rs.next() retorna falso e o programa passa para a linha 20. O código na linha 20 redireciona a página para a senha incorreta. página de processamento de entrada de senha fail.jsp.
·O código das linhas 22 a 24 é utilizado para fechar a conexão com o banco de dados.
Talvez você tenha descoberto que, embora as linhas 9 a 21 lancem SQLException, não temos um bloco de captura de exceção correspondente. Em um programa Java padrão, isso causará um erro em tempo de compilação, mas em JSP, ele pode ser compilado sequencialmente. é porque a própria página JSP captura todas as exceções lançadas na página.
Suponha que haja um erro na instrução de consulta SQL na linha 11, como o nome da tabela do usuário escrito erroneamente como Usuário (corretamente T_USER). Quando switch.jsp for chamado, uma SQLException será lançada na linha 14 e switch. jsp exibirá A página de informações de rastreamento do rastreamento de pilha de exceções é mostrada abaixo:
 Figura 14 A terrível página de tratamento de erros |
A página de tratamento de erros mostrada na imagem acima pode ser descrita como verde, feroz e muito hostil. Esse tipo de página de relatório de erros pode ser adequada para desenvolvedores porque fornece muitas informações de rastreamento de erros, mas é impossível no final. usuários aceitem esse tipo de página de erro. Uma página de erro rude. JSP permite que você especifique uma página JSP especificamente para lidar com erros por meio de <%@ page errorPage%>, para que os erros possam ser exibidos de uma forma amigável e intuitiva. Na próxima seção, criaremos uma página JSP para tratamento de erros. Após a criação, especificaremos a página JSP de tratamento de erros para switch.jsp.
