quinta-feira, 7 de novembro de 2013

Convertendo um array para Vetor em Java



Fala galeraaaaaa! Andei meu sumido por motivos pessoais de GWT na minha vida, mas, graças a ele, me deparei com a seguinte situação hoje:

Tinha uma lista de objetos no qual queria mostrar em um calendário gráfico do GWT. Até ai tudo bem, mas, na hora de fazer isto, acabei verificando que o bendito calendário só aceitava um CalendarEvent[].

Sabe oque estes colchetes querem dizer? sim isso mesmo um bendito de um Vetor!!!!! 
Com isso, tive que trabalhar em uma solução para resolver este problema. E adivinhem? Descobri!!!! \0/////

Vou mostrar agora à vocês como transformar nosso array de objetos em um vetor. Vamos lá!

Primeiro, vamos explicar oque é um vetor:


Segundo a definição mais clássica da informática, um vetor é uma estrutura de dados homogenia, ou seja, todos os elementos de um vetor são do mesmo tipo. 

A estrutura básica de um vetor é representada por seu nome e um índice, que deve ser utilizado toda a vez que se deseja acessar um determinado elemento dentro de sua estrutura. É importante ressaltar que todo o vetor possui um tamanho fixo, ou seja, não é possível redimensionar um vetor ou adicionar a ele mais elementos do que este pode suportar. Em Java a posição inicial do vetor é definida pelo valor zero.

Declaração do vetor

Para se declarar um vetor, devemos informar ao menos seu nome e o tipo de dado que este irá armazenar. Em Java, este tipo de dado pode ser representado tanto por um tipo primitivo como por uma classe qualquer, lembrando que as regras de herança também são válidas para vetores.

Exemplo:

int[] vetorDeInteiros;
float[] vetorDeFloat;
String[] vetorDeString;
long[] vetorDeLong;


É importante ressaltar que um vetor em Java torna-se um objeto em memória, mesmo que ele seja um vetor de tipos primitivos.

Inicialização de dados do vetor

Uma vez que um vetor torna-se um objeto em memória, sua inicialização é muito semelhante à de um objeto normal. Uma vez que um vetor é uma estrutura de tamanho fixo, esta informação é necessária a sua inicialização.

int[] vetorDeInteiros = new int[4];
float[] vetorDeFloat = new float[5];
String[] vetorDeString = new String[6];


Assim como uma variável comum, também é possível inicializar um vetor que já foi declarado anteriormente, conforme exemplo abaixo:

ExemplosVetores.java
01/**
02 * Classe utilizada para demonstrar o uso de vetor.
03 */
04public class ExemplosVetores {
05  public static void main(String[] args) {
06    int[] vetor;
07    vetor = new int[4];
08  }
09}

Assim como um objeto, um vetor deve ser inicializado antes de ser utilizado. Uma chamada a um índice de um vetor não inicializado gera uma exceção.


Existe outra forma de se inicializar vetores já com valores em cada uma de suas posições, para isto basta utilizar chaves da seguinte maneira:

ExemplosVetores.java
01/**
02 * Classe utilizada para demonstrar o uso de vetor.
03 */
04public class ExemplosVetores {
05  public static void main(String[] args) {
06    int vetor[] = {2, 5, 4, 8, 5};
07  }
08}

Note que esta forma de inicialização é bastante prática, porêm não deixa clara a quantidade de elementos que há no vetor obrigando o assim que você conte a quantidade de elementos para saber o tamanho do vetor.


Acesso aos elementos do vetor

Consideremos o código do exemplo anterior, a representação do seu vetor se daria da seguinte forma:

índice=
0
1
2
3
4
vetor = 
2
5
4
8
5


Logo, para acessar os valores de cada uma das posições deste vetor você deve utilizar o seu índice correspondente dentro de colchetes, assim como segue: 

ExemplosVetores.java
01/**
02 * Classe utilizada para demonstrar o uso de vetor.
03 */
04public class ExemplosVetores {
05  public static void main(String[] args) {
06    int vetor[] = {2, 5, 4, 8, 5};
07 System.out.println("Elemento do indice 2 = " + vetor[2]);
08 System.out.println("Elemento do indice 4 = " + vetor[4]);
09  }
10}

Com isso teríamos a seguinte saída em tela:

C:\>javac ExemplosVetores.java
C:\>java ExemplosVetores
Elemento do indice 2 = 4
Elemento do indice 4 = 5


Lembre-se que o primeiro índice do vetor é sempre zero, logo, seu último elemento é sempre igual ao tamanho do vetor menos um.


Se você já trabalhou com vetores, mesmo que apenas na faculdade, deve saber que com eles não conseguimos manipular os dados incluindo ou excluindo, só conseguimos criar (e destruir).
ExemplosVetores.java
01Ex.: String[] meuVetor = new String[] {“A”, “B”, “C”, “D”, “E”};

Neste exemplo, criamos um vetor com 5 posições, até aqui tudo bem, podemos solicitar cada posição do vetor com a chamada meuVetor[n],  trocando “n” pela posição do vetor, é claro, no nosso caso de 0 a 4.
Mas e se for necessário, em tempo de execução, adicionar algum valor ao vetor? Não é possível fazer ummeuVetor.add(), então como fazer?
Simples! Basta trabalhar com Array, List ou Collection e jogar esse vetor no lixo!
Mas e se a aplicação nos forçar a trabalhar com vetor, caso contrário seria necessário refazer todo o código?
Simples! Basta trabalhar com Array e converter para Vetor!
Como?
Vejamos o exemplo, em javanês:
ExemplosVetores.java
01
ArrayList<String> meuArray new ArrayList<String>();
String[] meuVetor null;
for(int i = 0; i < 10; i++){
meuArray.add(“POSICAO: “ + i);
}
meuVetor meuArray.toArray(new String[meuArray.size()]);

Explicando!
A primeira e segunda linha não tem segredo, ali estão sendo criadas nossas variáveis base, um ArrayList meuArray e um vetor String[] meuVetor.
O laço “for” também não tem muita complicação, de 0 até 9 ele está inserindo valores no Array.
Na ultima linha que a mágica acontece, vamos por partes:
Primeiro, estamos fazendo meuVetor = meuArray.toArray() este método (toArray) é da própria linguagem Java, e serve exatamente para isso que precisamos, ele prepara um Array para ser convertido em Vetor, mas este método sozinho não faz muita coisa, então precisamos informar o tipo de vetor que estamos querendo, no caso é um vetor de String, então dentro do toArray basta informar new String[n]. Mas que “n”? para criar um Vetor, precisamos informar a quantidade de posições que ele terá, e para conseguir esta façanha, basta invocar o método size() domeu Array, que devolve o tamanho do array, justamente o que precisamos para iniciar o Vetor!
É isso ai galera! Espero que tenha ajudado, e até a próxima. Abraços!!!
Bruno Rafael.

quarta-feira, 11 de setembro de 2013

Aplicação completa com JSP e Banco de Dados- Parte I





Fala galera!!!! \0/ . Devido o grande sucesso do post sobre JSF e JSP, venho aqui mostrar à vocês uma aplicação em JSP com banco de dados. Vamos à brincadeira que daqui à pouco tenho que voltar a mexer em um chat maldito que anda tirando meu sono. Lets go!

1.Escolhendo e configurando o Bando de Dados

Primeiramente você precisa escolher o banco de dados e como exemplo vamos utilizar o MySQL.

Caso você não o tenha, faça o download no site http://dev.mysql.com/downloads, é muito simples de instalar e de usar.


Após instalado, para executar o MySQL utilize o executável WinMySQLAdmin.exe localizado na pasta C:\mysql\bin, em seguida aparecerá o icone de semaforo na barra de tarefas próximo ao relógio.


Após instalado e funcionando é necessário configura-lo, para isso, digite para Host Name ?localhost?e para User Name e Password ?root?, para rodar na máquina local.


Em seguida é necessário criar a base de dados e a tabela, você pode utilizar qualquer programa de manipulação, vamos utilizar o MySQL Control Center, disponível também no site Mysql http://dev.mysql.com/downloads/other/mysqlcc.html.


Como exemplo crie uma base de dados com o nome ?teste? e em seguida vamos criar uma tabela chamada pessoa com as colunas nome, idade e sexo.


Agora estamos prontos pra utilizar nossa base de dados.



2.Configurando o servidor para rodar o JSP

JSP (Java Server Pages) são códigos que quando combinados com tags HTML produzem páginas dinâmicas, que são processadas pelo servidor.


Como servidor, podemos utilizar o Jakarta-Tomcat que pode ser encontrado no site http://jakarta.apache.org/tomcat/ou o Jboss com Tomcat encontrado no site http://www.jboss.org/downloads/index. Caso não tiver, basta instalá-lo.



Então, o primero passo é configurar o servidor para podermos executar essas páginas dinâmicas.



Caso tenha escolhido o Tomcat, é necessário inicia-lo executando o arquivo C:\Tomcat 5.0\bin\startup.bat, onde abrirá uma janela mostrando a inicialização, demora um pouco, mas depois você já pode executar seus arquivos JSP, para isso grave seus arquivos JSP dentro do caminho C:\Tomcat 5.0\webapps\ROOT\ , e execute os mesmos através do browser digitando o caminho http://localhost:8080/ , por exemplo, caso crie um arquivo teste.jsp, o mesmo seria gravado no caminho C:\Tomcat 5.0\webapps\ROOT\teste.jsp e depois seria executado no browser através do endereço http://localhost:8080/teste.jsp, e quando quiser encerrar o Tomcat execute o arquivo C:\Tomcat 5.0\bin\shutdown.bat.



Caso tenha escolhido o Jboss, é bem parecido com o Tomcat, pois o Jboss tem o Tomcat integrado e da mesma forma é necessário inicializar o servidor através do arquivo C:\jboss-3.0.8_tomcat-4.1.24\bin\run.bat, então cria uma pasta dentro do caminho C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\ com a extensão .war. Por exemplo, caso queira criar uma pasta teste, ficaria da seguinte forma, C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war e aqui dentro ficarão nossos arquivos JSP.



Vamos utilizar o Jboss para nossa implementação e vamos fazer um exemplo simples para testar o servidor, crie a pasta teste.war e em seguida crie uma página simples e salve dentro da pasta teste.war.


Então inicie o servidor e em seguida digite o endereço http://localhost:8080/teste/teste.jsp no browser. Aqui a pasta teste não precisa vir acompanhado da extensão .war.
Note que os códigos JSP estão entre <% e %>, e se tudo der certo você verá a mensagem do código JSP na tela.


Para encerrar o Jboss execute o C:\jboss-3.0.8_tomcat-4.1.24\bin\shutdown.bat
Caso você esteja tendo algum problema tente encerrar o jboss ou tomcat e inicializa-lo novamente.

3. Acessando o MySQL através do JSP utilizando o servidor Jboss com Tomcat integrado.

Agora vamos testar a conexão com o Banco MySQL através do JSP. Inicialmente precisamos baixar o driver do MySQL, que é um arquivo .jar disponível no site http://dev.mysql.com/downloads/e copia-lo na pasta C:\jboss-3.0.8_tomcat-4.1.24\server\default\lib.


Vamos desenvolver uma página pra testar a conexão com o banco MySQL e salvar com o nome testeConexao.jsp na pasta C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war criada anteriormente.



 <%@ page contentType="text/html"%>   
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">   
 <html>   
 <head>   
 <title>Teste JSP</title>   
 </head>   
 <body>   
   <%out.println("Teste efetuado com sucesso");%>   
 </body>   
 </html>  




Então inicia o MySQL, em seguida inicia o servidor Jboss e executa no browser o endereço http://localhost:8080/teste/testeConexao.jsp. Caso funcione aparecerá na tela a mensagem ?Conexão efetuada com sucesso?.


4. Utilizando JSP para acessar Javabeans

Javabeans nada mais é do que arquivos Java acessados através de páginas dinâmicas, ou seja, através do JSP. Nosso propósito será acessar um Javabeans para fazer toda a manipulação do banco, mas antes vamos testar um exemplo simples.
Inicialmente vamos fazer uma aplicação em java seguindo algumas convenções, ?get? para obter dados e ?set? para atribuir dados. Para isso podemos utilizar qualquer editor, inclusive o bloco de notas.



package testeBean;  
  
public class TesteBean {  
     
   String txt = "";  
     
   public void setTexto(String texto){  
      txt = texto;  
   }  
     
   public String getTexto(){  
      return txt;  
   }     
}  




Então dentro da pasta teste.war criamos uma pasta chamada WEB-INF, que é onde serão procurados todos os JavaBenas e dentro da pasta WEB-INF será criada a pasta classes e a pasta lib. Na pasta classes poderemos gravar os arquivos com extensão .class e na pasta lib podemos gravar os arquivos com extensão .jar. Sempre salve os Javabeans dentro de pacotes para evitar transtornos.

Vamos criar um arquivo .jar desse exemplo e salva-la como testeBean.jar na pasta lib, ficando da seguitne maneira C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war\WEB-INF\lib\testeBean.jar ou caso preferir pode gravar o pacote testeBean todo dentro da pasta classes C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war\WEB-INF\classes\testeBean\TesteBean.class.

Agora dentro da pasta teste.war iremos criar o arquivo JSP que irá chamar o Javabeans. Salve o mesmo como testeBean.jsp.



<jsp:useBean id="testeObj" class="testeBean.TesteBean">  
<jsp:setProperty name="testeObj" property="texto" value="Testando..."/>  
</jsp:useBean>  
  
<html>  
   <head>  
      <title>Teste Jsp</title>  
   </head>  
     
   <body>  
      <h1>Teste JSP</h1>  
      <p>A mensagem teste é:  
         <jsp:getProperty name="testeObj" property="texto"/>  
      </p>  
   </body>  
</html>  


O comandocria um objeto ?testeObj? da classe TesteBean. O comandoatravés do objeto ?testeObj? utiliza o setProperty para chamar o método setTexto, que associa o property=?texto? ao setProperty e chama o método setTexto do Javabeans passando como parametro o valor ?Testando...?. O mesmo ocorre para o comandoque chama o método getTexto, imprimindo a variável ?txt? do Javabeans na tela.


Você também pode utilizar o objeto criado para chamar os métodos do Javabeans sem utilizar getProperty, colocando o código JSP entre <% e %>, por exemplo poderiamos chamar o método getTexto da seguinte forma <%=TesteObj.getTexto()%>, utilizando o sinal de = para imprimir na tela, ou mandar imprimir utilizando o código <%out.print(TesteObj.getTexto())%>, já que o método getTexto() retorna uma string.


Então inicia o servidor Jboss e executa no browser o endereço http://localhost:8080/teste/testeBean.jsp. Caso imprimir a mensagem ?Testando...? na tela, a chamada ao Javabeans ocorreu corretametne.


5. Utilizando JSP e Javabeans para acessar o MySQL

Agora vamos aperfeiçoar nosso exemplo de conexão com banco de dados, fazendo com que o Javabeans faça a conexão e o JSP acesse o resultado através do mesmo.
Primeiramente vamos criar um JavaBeans para fazer a conexão, bem parecido com o JSP que fizemos anteriormente.



package conexao;  
  
import java.sql.*;  
  
public class Conexao {  
     
   public Connection con;  
   public Statement stm;  
   private String sit = "";  
   
   public Conexao() {  
  
      try {  
  
         Class.forName("org.gjt.mm.mysql.Driver");  
         con = DriverManager.getConnection("jdbc:mysql://localhost:3306/teste","root","root");  
         stm = con.createStatement();   
  
         sit = "Conexão efetuada com sucesso";  
  
           
      } catch (Exception e) {  
         sit = "não foi possível conectar ao banco" + e.getMessage();  
      }  
   }  
     
   public String getSituacao(){  
      return sit;     
   }  
}  



Então da mesma forma mostrada anteriormente salve o Javabeans como Conexao.jar dentro da pasta teste.war\WEB-INF\lib e crie um arquivo JSP e salve como conexao.jsp dentro da pasta teste.war.



package conexao;  
  
import java.sql.*;  
  
public class Conexao {  
     
   public Connection con;  
   public Statement stm;  
   private String sit = "";  
   
   public Conexao() {  
  
      try {  
  
         Class.forName("org.gjt.mm.mysql.Driver");  
         con = DriverManager.getConnection("jdbc:mysql://localhost:3306/teste","root","root");  
         stm = con.createStatement();   
  
         sit = "Conexão efetuada com sucesso";  
  
           
      } catch (Exception e) {  
         sit = "não foi possível conectar ao banco" + e.getMessage();  
      }  
   }  
     
   public String getSituacao(){  
      return sit;     
   }  
}  


Então inicia o Jboss e executa no browser o endereço http://localhost:8080/teste/conexao.jsp. Caso funcione, estamos prontos para começar desenvolver a aplicação em si.


6. Desenvolvimento da aplicação


Agora você poderá implementar os códigos seguintes. Vamos fazer uma breve explicação sobre cada um, cabendo a você analisar o código para entender suas funções.


Conexao.java

Vamos aperfeiçoar ainda mais o Javabeans anterior fazendo com que ele seja responsável por toda manipulação no banco de dados e salva-lo como Conexao.jar na pasta lib.



package conexao;  
  
import java.sql.*;  
  
public class Conexao {  
     
   public Connection con;  
   public Statement stm;  
   public ResultSet res = null;  
   private String nome = null;  
   private int idade = 0;  
   private String sexo = null;  
  
   public Conexao() {  
  
      try {  
  
         Class.forName("org.gjt.mm.mysql.Driver");  
         con =  
            DriverManager.getConnection(  
              "jdbc:mysql://localhost:3306/teste",  
              "root",  
              "root");  
         stm = con.createStatement();   
           
      } catch (Exception e) {  
         System.out.println("não foi possível conectar ao banco" + e.getMessage());  
      }  
   }  
     
   public void setNome(String nome){  
      this.nome = nome;  
   }  
        
   public void setIdade(int idade){  
      this.idade = idade;  
   }  
  
   public void setSexo(String sexo){  
      this.sexo = sexo;  
   }  
  
   public String getNome(){  
      return nome;  
   }  
  
   public int getIdade(){  
      return idade;  
   }  
        
   public String getSexo(){  
      return sexo;  
   }  
  
   public void inserirDados(){  
     
      try {  
         String query = "insert into pessoa(nome,idade,sexo) values(\""+nome+"\","+idade+",\""+sexo+"\")";  
         stm.executeUpdate(query);  
  
      }catch (SQLException e){System.out.println("Erro na inserção:" + e.getMessage());}  
        
   }  
  
   public boolean alterarDados(){  
        
      boolean testa = false;  
     
      try {  
         String query = "update pessoa "+  
                     "set idade = " + idade + ", "+  
                     "sexo = \"" + sexo + "\" " +  
                     "where nome = \"" + nome + "\"";  
  
         int linhas = stm.executeUpdate(query);  
           
         if (linhas > 0)  
            testa = true;  
         else  
            testa = false;  
  
      }catch (SQLException e){System.out.println("Erro na inserção:" + e.getMessage());}  
        
      return testa;  
   }  
     
   public boolean excluirDados(){  
     
    boolean testa = false;  
     
      try {  
         String query = "delete from pessoa where nome='" + nome+"'";  
         int linhas = stm.executeUpdate(query);  
           
         if (linhas > 0)  
            testa = true;  
         else  
            testa = false;  
  
      }catch (SQLException e){System.out.println("Erro na exclusão:" + e.getMessage());}  
        
      return testa;  
   }  
     
   public boolean consultarDados(){  
        
      boolean testa = false;  
           
      try {  
         String query = "select * from pessoa where nome='" + nome+"'";  
         res = stm.executeQuery(query);  
           
         if (res.next()){testa = true;}  
         else{testa = false;}  
           
      }catch (SQLException e){System.out.println("Erro na inserção:" + e.getMessage());}  
        
      return testa;  
   }     
  
   public void setConsulta() {  
        
      try {  
         res = stm.executeQuery("select * from pessoa");  
      }   
      catch (SQLException e){  
         e.printStackTrace();  
      }  
  
   }  
  
   public ResultSet getResultado() {  
      return res;  
   }  
}  




Onde o método construtor será responsável pela conexão ao banco, ou seja, toda vez que for instanciado um objeto dessa classe, o construtor será chamado primeiro e o banco será conectado.

Foram criadas três variáveis privadas nome, idade e sexo, que serão acessadas através dos métodos get e set.
O método inserirDados() é responsável pela inserção no banco, onde será passado como valores as três variáveis privadas.

O método alterarDados() é responsável por atualizar os dados levando em consideração a variável nome, testando se foi encontrado algum registro, retornando assim true ou false.

O método excluirDados(), da mesma forma que o alterarDados(), exclui os dados levando em consideração a variável nome, testando se encontrou algum registro.

O método consultaDados() apenas consulta os dados do banco, também testando se encontrou algum registro.
O método setConsulta() executa uma consulta comum. E o método getResultado() retorna o objeto ResultSet contendo todos os registros do banco.


pessoa.jsp


Agora criaremos um arquivo JSP principal, contendo os campos e botões para inserção, consulta, alteração e exclusão. Chamaremos de pessoa.jsp.

<%@ page contentType="text/html"%>  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  
<html>  
<head>  
<title>Tabela Pessoa</title>  
  
  
<script>  
  
function enviar(par){  
     
   if (par == 'cadastrar'){  
     
      if (document.cadastro.nomeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo nome';  
      }else if (document.cadastro.idadeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo idade';  
      }else if (document.cadastro.sexoField.value == ''){  
         document.cadastro.statusField.value = 'Escolha o sexo da pessoa';  
      }else {  
         document.cadastro.action='cadastrar.jsp';  
         document.cadastro.submit();  
      }  
  
   } else if (par == 'consultar'){  
  
      if (document.cadastro.nomeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo nome';  
      }else {  
         document.cadastro.action='consultar.jsp';  
         document.cadastro.submit();  
      }  
  
   } else if (par == 'alterar'){  
  
      if (document.cadastro.nomeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo nome';  
      }else if (document.cadastro.idadeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo idade';        
      }else if (document.cadastro.sexoField.value == ''){  
         document.cadastro.statusField.value = 'Escolha o sexo da pessoa';  
      }else {  
         document.cadastro.action='alterar.jsp';  
         document.cadastro.submit();  
      }  
   } else if (par == 'excluir'){  
  
      if (document.cadastro.nomeField.value == ''){  
         document.cadastro.statusField.value = 'Preencha o campo nome';  
      }else {  
         document.cadastro.action='excluir.jsp';  
         document.cadastro.submit();  
      }  
   } else if (par == 'listar'){  
      document.cadastro.action='listar.jsp';  
      document.cadastro.submit();  
   }  
}  
  
</script>  
  
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">  
<style type="text/css">  
<!--  
.style3 {   font-size: 28px;  
   font-weight: bold;  
}  
-->  
</style>  
</head>  
  
<%  
String nome = request.getParameter("nome");  
String idade = request.getParameter("idade");  
String sexo = request.getParameter("sexo");  
String status = request.getParameter("status");  
%>  
  
<body>  
<form name="cadastro" method="get">  
  
<table width="472" border="0">  
  <tr>  
    <td width="458" height="70" bgcolor="#6699FF"><p align="left" class="style3"> Cadastro pessoa </p>  
    </td>  
  </tr>  
  <tr>  
    <td height="177" bgcolor="#6699FF"><p> <strong>Nome :</strong>  
       <input name="nomeField" type="text" id="nomeField" size="46" value="<%=(nome==null)?"":nome%>"> </p>  
         <p> <strong>Idade :</strong>  
       <input name="idadeField" type="text" id="idadeField" size="10" value="<%=(idade==null)?"":idade%>">  
               <strong>Sexo:</strong>   
  
        <input name="sexoField" type="text" id="sexoField" size="6" value="<%=(sexo==null)?"":sexo%>">  
          
  
         </p>      
   </td>  
  </tr>  
  <tr>  
    <td height="101" bgcolor="#6699FF"><p>   
        <input type="button" onClick="enviar('cadastrar')" name="bt1" value="cadastrar">  
        <input type="button" onClick="enviar('consultar')" name="bt2" value="consultar">  
        <input type="button" onClick="enviar('alterar')" name="bt3" value="alterar">  
        <input type="button" onClick="enviar('excluir')" name="bt4" value="excluir">  
        <input type="button" onClick="enviar('listar')" name="bt5" value="listar">  
      </p>  
      <p> <strong>Status:  
   <input name="statusField" disabled type="text" id="statusField" size="46" value="<%=(status==null)?"":status%>">  
      </strong></p>  
   </td>  
  </tr>  
</table>  
</form>  
</body>  
</html>  




Essa página é uma tela simples com alguns textFields e botões. Os botões utilizam o método onclick para chamar a função enviar(par) escrita em javascript, onde de acordo com cada botão pressionado, é chamado uma página diferente, e aproveitamos também para testar se o campos estão vazios de acordo com cada solicitação.
Note que há um trecho JSP <% String nome = request.getParameter("nome"); %>, que será usado para recuperar os parametros de outras páginas, onde serão melhor visiveis mais a frente.


cadastrar.jsp


Quando pressionamos o botão cadastrar, é necessário que todos os campos em pessoa.jsp estejam preenchidos, então é chamado a página cadastrar.jsp

<%@ page contentType="text/html" language="java" import="java.sql.*"%>  
<jsp:useBean id="con" class="conexao2.Conexao"/>  
  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
<html>  
<head>  
<title>Cadastrar</title>  
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">  
</head>  
  
<body>  
<form name="form1" method="post" action="pessoa.jsp">  
  
<p><strong>Tabela Pessoa </strong></p>  
<table border=1 cellspacing=0 cellpadding=0 >  
  
   <tr>  
    <td width=200><strong>  
      Nome  
   </strong></td>      
   <td width=50><strong>  
      Idade  
   </strong></td>      
   <td width=30><strong>  
      Sexo  
   </strong></td>  
   </tr>  
  
  
<%      
   try {  
  
      con.setNome(request.getParameter("nomeField"));  
      con.setIdade(Integer.parseInt(request.getParameter("idadeField")));  
      con.setSexo(request.getParameter("sexoField"));  
      con.inserirDados();  
                 
      con.setConsulta();  
      ResultSet temp = con.getResultado();  
      temp.next();  
        
      if(request.getParameter("nomeField").equals(temp.getString("nome")))  
         response.sendRedirect("http://localhost:8080/teste/pessoa.jsp?status=Registro já existente");  
        
      do{  
      %>  
      <tr>  
          <td width=200>  
               <%out.print(temp.getString("nome"));%>  
         </td>  
          <td width=50>  
               <%out.print(temp.getString("idade"));%>  
         </td>  
          <td width=30>  
               <%out.print(temp.getString("sexo"));%>  
         </td>  
      </tr>  
      <%}while (temp.next());  
     
   }catch (Exception e) {  
      e.printStackTrace();  
   }  
     
%>  
</table>  
  <p> </p>  
  <p>  
    <input type="submit" name="Submit" value="voltar">  
</p>    
<p><strong>Status:  
    <input name="statusField" disabled type="text" id="statusField" size="36" value="<%=request.getParameter("nomeField")%> foi cadastrado com sucesso">  
      </strong></p>  
</form>  
</body>  
</html>




É isso galera! Na parte 2 vamos fazer algumas consultas de dados e o final de nossa aplicação! 
Abraços!

Bruno Rafael.
.


sexta-feira, 6 de setembro de 2013

Um pouco sobre JSP e JSF


Salve galera! Tenho andado meio sumido aqui do blog pois ando meio enrolado com uns projetos da empresa (Maldito GWT) que vem me dado um pouco de dor de cabeça, e requerendo um pouco mais de meu tempo. Neste post venho mostrar para vocês um pouco sobre estas duas tecnologias JSP e JSF. Muitos ainda ficam em dúvida sobre qual utilizar em seu desenvolvimento Web, e, até mesmo desconhecem sobre as duas.

Então vamos lá.

O que é uma página JSP?


página JSP é um documento de texto que contém dois tipos de texto: dados estáticos, que podem ser expressas em qualquer formato baseado em texto (como HTML , SVG , WML e XML ), e elementos JSP, que construir conteúdo dinâmico.

A extensão de arquivo recomendado para o arquivo de origem de uma página JSP é . jsp . A página pode ser composta de um arquivo de topo que inclui outros arquivos que contêm uma página JSP completo ou um fragmento de uma página JSP. A extensão recomendada para o arquivo de origem de um fragmento de uma página JSP é . jspf .
Os elementos JSP em uma página JSP pode ser expressa em duas sintaxes, padrão e XML, embora um determinado arquivo só pode usar uma sintaxe. Uma página JSP em sintaxe XML é um documento XML e pode ser manipulado por ferramentas e APIs para documentos XML. 

Um simples JSP Exemplo da página


A página da web é uma forma que permite que você selecione um idioma e exibe a data de uma forma adequada para o local.
Figura 5-1 localizada Data Form



O código-fonte para este exemplo abaixo. A página JSP, index.jsp , aparece abaixo, é uma mistura típica de estática marcação HTML e elementos JSP. Se você desenvolveu páginas web, você provavelmente está familiarizado com as demonstrações documento HTML estrutura ( <head> , <body> , e assim por diante) e as demonstrações HTML que criar um formulário ( <form> ) e um menu ( <select> ).

As linhas em negrito no código exemplo, conter os seguintes tipos de construções JSP:
  • A diretiva de página ( <% @ page ...%> ) define o tipo de conteúdo retornado pela página.

  • Tag biblioteca directivas ( <% @ taglib ...%> ) a importação de bibliotecas de tags personalizados.

  • jsp: useBean é um elemento padrão que cria um objeto que contém uma coleção de locales e inicializa um identificador que aponta para esse objeto.

  • JSP expressão expressões linguísticas ( $ {} ) recuperar o valor de propriedades do objeto. Os valores são usados ​​para definir os valores dos atributos de tags personalizados e criar conteúdo dinâmico.

  • Tag feitos sob encomenda como uma variável ( c: set ), iterar sobre uma coleção de nomes de locale ( c: forEach ), e inserir condicionalmente texto HTML na resposta ( c: if , c: escolher , c: quando , c: de outra forma ).

  • jsp: setProperty é outro elemento padrão que define o valor de uma propriedade do objeto.

  • A função ( f: igual ) testa a igualdade de um atributo eo item atual de uma coleção. (A built-in == operador geralmente é usado para testar a igualdade.)
Aqui é a página JSP:
<% @ page contentType = "text / html; charset = UTF-8"%>
<% @ taglib uri = "http://java.sun.com/jsp/jstl/core
"
         prefix = "c"%>
<% @ taglib uri = prefixo "/ funções" = "f"%>
<html>
<head> Datas <title> localizadas </ title> </ head>
<body bgcolor="white">
< jsp: useBean id = scope "locales" = "application"
    class = "mypkg.MyLocales" />

<form name="localeForm" action="index.jsp" method="post">
< c: set var = valor "selectedLocaleString" = " $ {param.locale} "/>
< c: set var = "selectedflag"
     value = " $ {! selectedLocaleString vazio} "/>
<b> Local: </ b>
<selecione name=locale>
< c: forEach var = itens "localeString" = " $ {} locales.localeNames ">
< c: choose >
    < c: quando test = " $ {} selectedflag ">
        < c: choose >
            < c: quando 
                 test = " $ {f: equals (selectedLocaleString, localeString)} ">
                <option selecionada> localeString $ {} </ option>
            </ C: quando>
            <c:otherwise>
                <option> localeString $ {} </ option>
            </ C: caso contrário>
        </ C: choose>
    </ C: quando>
    < c: caso contrário >
        <option> localeString $ {} </ option>
    </ C: caso contrário>
</ C: choose>
</ C: forEach>
</ Select>
<input type="submit" name="Submit" value="Get Date">
</ Form>

< c: if test = "$ {} selectedflag">
    < jsp: setProperty name = "locales"
        property = "selectedLocaleString"
        value = " $ {selectedLocaleString} "/>
    < jsp: useBean id = classe "date" = "mypkg.MyDate" />
    < jsp: setProperty propriedade name = "data" = "locale"
        value = " $ {locales.selectedLocale} "/>
    <b> Data: </ b> $ {Date.Date} </ c: if>
</ Body>
</ Html>

Tecnologia JavaServer Faces

Tecnologia JavaServer Faces é um framework de componentes de interface de usuário do lado do servidor para aplicações web baseadas em tecnologia Java.
Os principais componentes da tecnologia JavaServer Faces são como se segue:
  • Uma API para representar componentes de interface do usuário e gerenciamento de seu estado, manipulação de eventos, validação do lado do servidor, e conversão de dados, definição de navegação de página, apoiando a internacionalização e acessibilidade, e fornecendo extensibilidade para todos esses recursos
  • Dois JSP para expressar componentes de interface do usuário dentro de uma página JSP e para componentes de cabeamento de objetos do lado do servidor
O modelo de programação bem definida e bibliotecas de tags aliviar significativamente o peso da construção e manutenção de aplicações web com interfaces de usuário do lado do servidor. Com o mínimo de esforço, você pode
  • Soltar componentes em uma página, adicionando tags de componentes
  • Eventos e componente gerado para o código do aplicativo do lado do servidor
  • Vincular componentes de interface do usuário em uma página de dados do lado do servidor
  • Construir uma interface com componentes reutilizáveis ​​e extensíveis
  • Salvar e restaurar o estado UI além da vida de solicitações do servidor

    JavaServer Faces Tecnologia Interface de Usuário

    Como mostrado na figura, a interface do usuário que você criar com a tecnologia JavaServer Faces (representado por myUI no gráfico) é executado no servidor e torna volta para o cliente.
    Figura 10-1 A interface do usuário é executado no servidor
    O diagrama mostra um navegador acessando a página myform.jsp usando uma solicitação HTTP eo servidor enviar o tornou o código HTML usando uma resposta HTTP.]
    A página JSP, myform.jsp , é uma página JavaServer Faces , que é uma página JSP que inclui marcas JavaServer Faces. Ela expressa os componentes da interface de usuário usando tags personalizadas definidas pela tecnologia JavaServer Faces. A interface do usuário para a aplicação web (representado por myUIna figura) gerencia os objetos referenciados pela página JSP. Esses objetos incluem:
    • Os objetos componentes de interface do usuário que são mapeados para as tags na página JSP
    • Ouvintes algum evento, validadores e conversores que estão registrados nos componentes
    • Os componentes JavaBeans que encapsulam os dados e funcionalidades específicas de aplicação dos componentes

    JavaServer Faces Benefícios Tecnologia

    Uma das maiores vantagens da tecnologia JavaServer Faces é que ele oferece uma clara separação entre o comportamento e apresentação. Aplicações web construída utilizando tecnologia JSP alcançar esta separação em parte. No entanto, uma aplicação JSP não é possível mapear solicitações HTTP para manipulação de eventos específico do componente e nem gerenciar elementos de interface do usuário como objetos stateful no servidor, como uma aplicação JavaServer Faces pode. JavaServer Faces tecnologia permite que você construa aplicações web que implementam a separação mais refinado do comportamento e da apresentação que é tradicionalmente oferecido por arquiteturas de interface do usuário do lado do cliente.
    A separação da lógica de apresentação também permite que cada membro de uma equipe de desenvolvimento de aplicações web para se concentrar em sua parte do processo de desenvolvimento, e fornece um modelo de programação simples para ligar as peças. Por exemplo, os autores de páginas sem conhecimentos de programação pode usar tecnologia JavaServer Faces tags de componentes de interface do usuário para conectar-se a objetos do lado do servidor a partir de uma página web sem escrever qualquer script.
    Outro objetivo importante da tecnologia JavaServer Faces é alavancar conceitos UI-componente e web-tier familiares, sem limitá-lo a uma tecnologia de scripting particular ou linguagem de marcação. Embora a tecnologia JavaServer Faces inclui uma biblioteca de custom tag JSP para representar os componentes em uma página JSP, o JavaServer Faces APIs tecnologia são mergulhados diretamente no topo da API Servlet, como mostrado. Esta camada de APIs permite que vários casos de uso de aplicativos importantes, como o uso de outra tecnologia de apresentação em vez de páginas JSP, criando seus próprios componentes personalizados diretamente das classes de componentes e gerar a saída para vários dispositivos cliente.
    Mais importante ainda, tecnologia JavaServer Faces oferece uma rica arquitetura para o gerenciamento de estado do componente, o processamento de dados de componentes, validando a entrada do usuário e manipulação de eventos

    O que é uma aplicação JavaServer Faces?

    Para a maior parte, uma aplicação JavaServer Faces é como qualquer outra aplicação web Java. Uma aplicação típica JavaServer Faces inclui as seguintes peças:
    • Um conjunto de páginas JSP (embora você não está limitado a usar as páginas JSP como sua tecnologia de apresentação)
    • Um conjunto de feijão de apoio , que são componentes JavaBeans que definem propriedades e funções dos componentes de interface do usuário em uma página
    • Um arquivo de configuração da aplicação de recursos, que define as regras de navegação de página e configura feijão e outros objetos personalizados, como componentes personalizados
    • Um descritor de implementação (a web.xml file)
    • Possivelmente um conjunto de objetos personalizados criados pelo desenvolvedor do aplicativo. Esses objetos podem incluir componentes personalizados, validadores, conversores, ou ouvintes.
    • Um conjunto de tags personalizadas para representar objetos personalizados na página
    A JavaServer Faces aplicativo que inclui páginas JSP também usa as bibliotecas de tags padrão definidos pela tecnologia JavaServer Faces para representar componentes de interface do usuário e outros objetos na página.

    A JavaServer Faces Aplicação Simples

    Os passos gerais envolvidos no desenvolvimento de uma aplicação simples JavaServer Faces a partir da perspectiva de diferentes funções de desenvolvimento. Estas funções são:
    • Página autor, que cria páginas usando as bibliotecas de tags JavaServer Faces.
    • Application Developer, que os programas conversores personalizados, validadores, ouvintes e feijão de apoio.
    • Autor do componente, que cria componentes e prestadores de interface do usuário personalizada.
    • Arquiteto de aplicativos, que configura o aplicativo, incluindo a definição das regras de navegação, configurando objetos personalizados e criação de descritores de implementação.
    Esta aplicação é bastante simples, e por isso não inclui quaisquer componentes personalizados.

    Etapas do Processo de Desenvolvimento

    O desenvolvimento de uma aplicação simples JavaServer Faces geralmente requer as seguintes tarefas:
    • Mapeando o FacesServlet instância.
    • Criando as páginas usando o componente de UI e as marcas principais.
    • Definição de navegação de página no arquivo de recurso de configuração do aplicativo.
    • Desenvolver os grãos de apoio.
    • Adicionando declarações de feijão conseguiu o arquivo de recurso de configuração do aplicativo.
     Ele pede para adivinhar um número entre 0 e 10, inclusive. A segunda página informa se você adivinhou corretamente. O exemplo também verifica a validade de sua entrada. O registro do sistema imprime o número de Duke mostra o que a primeira página parece.
    Captura de tela de Duke pedindo-lhe para adivinhar um número entre 1 e 10, com um campo de texto e um botão Enviar.

    Mapeando o FacesServlet Instância

    Todos os aplicativos JavaServer Faces deve incluir um mapeamento para o FacesServlet instância em seus descritores de implementação. O FacesServlet  aceita solicitações de entrada, passa para o ciclo de vida para o processamento e inicializa recursos. O seguinte trecho do guessNumber exemplo de descritor de implementação realiza o mapeamento para o FacesServlet exemplo:
    <servlet>
        <display-name> FacesServlet </ display-name>
        <servlet-name> FacesServlet </ servlet-name>
        <servlet-class> javax.faces.webapp.FacesServlet
        </ Servlet-class>
        <load-on-startup> 1 </ load-on-startup>
    </ Servlet>
    <servlet-mapping>
        <servlet-name> FacesServlet </ servlet-name>
        <url-pattern> / acho / * </ url-pattern>
    </ Servlet-mapping>
    
    
    O mapeamento para FacesServlet mostrado acima usa um mapeamento de prefixo para identificar uma página JSP como tendo componentes JavaServer Faces.Devido a isso, o URL para a primeira página JSP da aplicação deve incluir o mapeamento. Para conseguir isso, o guessNumber exemplo inclui uma página HTML que tem a URL para a primeira página JSP:
    <a href="guess/greeting.jsp">
    Criando as páginas é de responsabilidade na página do autor. Esta tarefa envolve a colocar para fora os componentes de interface do usuário nas páginas, o mapeamento dos componentes para feijão e adicionar tags que os conversores de registro, validadores, ou ouvintes sobre os componentes.
    Como em qualquer página JSP, você precisa adicionar o código HTML habitual e tags HEAD para a página:
    <HTML Xmlns="http://www.w3.org/1999/xhtml"xml:lang="en">
        <HEAD> <title> Olá </ title> </ head>    
        ...
    </ HTML>
    
    
    Você também vai precisar de uma diretiva de página que especifica o tipo de conteúdo:
    <% @ Page contentType = "application / xhtml + xml"%>
    
    
    Declarando os Tag Libraries
    Para utilizar componentes JavaServer Faces em páginas JSP, você precisa dar o seu páginas de acesso às duas bibliotecas de tags padrão, a biblioteca de tags HTML e componente da biblioteca tag núcleo usando taglib :
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http:.//java.sun.com/jsf/core" = "f"%>
    
    
    A primeira declaração taglib declara a biblioteca de tags HTML componente com um prefixo, h . Todas as tags de componentes na página têm este prefixo. A biblioteca de tag núcleo é declarado com o prefixo f . Todas as tags principais na página de ter este prefixo.
    Adicionando a vista e forma Marcações
    Todas as páginas JavaServer Faces são representados por uma árvore de componentes, chamado de vista . A vista tag representa a raiz do ponto de vista.Todos JavaServer Faces tags de componentes devem estar dentro de uma vista de etiquetas, que é definido na biblioteca marcação núcleo.
    formulário tag representa um componente de formulário de entrada, que permite que o usuário insira alguns dados e enviá-lo para o servidor, geralmente clicando em um botão. Todas as marcas de componentes de interface do usuário que representam componentes editáveis ​​(como campos de texto e menus) devem ser encaixados dentro do formulário tag. No caso de o greeting.jsp página, algumas das etiquetas contidos no formulário são outputText , inputText ,commandButton e mensagem . Você pode especificar um ID para a tag form. Mapas esse ID para o componente UI forma associada no servidor.
    Com a vista e forma de etiquetas adicionadas, a nossa página se parece com isso (menos as tags HTML e HEAD):
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
        </ H: form>
    </ F: view>
    
    
    Adicionando um componente Rótulo
    outputText tag representa um rótulo. O greeting.jsp página tem dois outputText tags. Uma das marcas exibe o número 0. A outra tag exibe o número 10:
        <H: outputText lang = "en_US"
             value = "# {UserNumberBean.minimum}" />
        <h:outputText value="#{UserNumberBean.maximum}"/>
    
    Com a adição dos outputText marcas (junto com algum texto estático), a página de saudação parece com o seguinte:
    
    
    
    
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
        </ H: form>
    </ F: view>
    
    
    Adicionando uma Imagem
    Para exibir imagens em uma página, você pode usar o graphicImage tag. A url atributo da tag especifica o caminho para o arquivo de imagem. Vamos adicionar Duke para a página usando um graphicImage tag:
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
            <h:graphicImage id="waveImg" url="/wave.med.gif" />
        </ H: form>
    </ F: view>
    
    
    Adicionando um campo de texto
    inputText tag representa um componente de campo de texto. No guessNumber exemplo, este campo de texto tem um valor de entrada inteira. A instância dessa tag incluída no greeting.jsp tem três atributos: id , etiqueta e valor .
    <H: inputText id = label "userNo" = "Número do Usuário"
            value = "# {} UserNumberBean.userNumber">
            ...
    </ H: inputText>
    
    
    id atributo corresponde ao ID do objeto componente representado por esta tag. Neste caso, um ID de atributo é necessário porque a mensagem de etiquetas (que é usado para apresentar mensagens de erro de validação) necessita para se referir ao userNo componente.
    etiqueta de nome de atributo especifica a ser utilizada por mensagens de erro referem-se ao componente. Neste exemplo, o rótulo é definida como Número do usuário . Como um exemplo, se um utilizador entrasse 23, a mensagem de erro, que seria exibido é:
    Número de usuários: Erro de validação: o valor é maior que o máximo permitido de 10.
    valor do atributo liga o userNo valor do componente para a propriedade do bean UserNumberBean.userNumber , que detém os dados inseridos no campo de texto. Depois de adicionar o inputText tag, a página de saudação parece com o seguinte:
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
            <h:graphicImage id="waveImg" url="/wave.med.gif" />
            <H: inputText id = label "userNo" = "Número do Usuário"
                value = "# {} UserNumberBean.userNumber">
                ...
            </ H: inputText>
        </ H: form>
    </ F: view>
    
    
    Registrando um Validator em um campo de texto
    Ao incorporar o validateLongRange tag dentro de tag componente de um campo de texto, o autor da página registra um LongRangeValidator para o campo de texto. Este validador verifica se os dados locais do componente está dentro de um determinado intervalo, definido pela validateLongRange da tag mínimo emáximo de atributos.
    No caso da página de saudação, você precisa validar o número que o usuário digita no campo de texto. Então, você adiciona um validateLongRange tag dentro do inputText tag. Depois de adicionar o validateLongRange tag, a página se parece com isso:
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
            <h:graphicImage id="waveImg" url="/wave.med.gif" />
            <H: inputText id = label "userNo" = "Número do Usuário"
                value = "# {} UserNumberBean.userNumber">
                    <F: validateLongRange
                         mínimo = "# {UserNumberBean.minimum}"
                         máximo = "# {UserNumberBean.maximum}" />
            </ H: inputText>
        </ H: form>
    </ F: view>
    
    
    Adicionando uma mensagem personalizada
    JavaServer Faces tecnologia fornece mensagens de erro padrão que aparecem na página quando a conversão ou validação falhar. Em alguns casos, pode ser necessário substituir a mensagem padrão. Por exemplo, se um usuário para digitar uma letra no campo de texto em greeting.jsp , ele ou ela iria ver a seguinte mensagem de erro:
    Número Usuário: 'm' deve ser um número entre -2147483648 e 2147483647 Exemplo: 9346
    Isso é errado, porque o campo realmente só aceita valores de 0 a 10. Para anular essa mensagem, você adiciona um converterMessage atributo no inputText tag. Referências Este atributo a mensagem de erro personalizada:
    <H: inputText id = label "userNo" = "Número do Usuário"
             value = "# {} UserNumberBean.userNumber"
             converterMessage = "# {ErrMsg.userNoConvert}" >
    ...
    </ H: inputText>
    
    
    A expressão que converterMessage usa referências a userNoConvert chave da Mensagem de erro pacote de recursos. O arquiteto aplicativo precisa definir a mensagem no pacote de recursos e configurar o pacote de recursos.
    Adicionando um botão
    commandButton tag representa o botão usado para enviar os dados inseridos no campo de texto. A ação atributo especifica um resultado que ajuda o mecanismo de navegação decidir qual página abrir no próximo. 
    Com a adição do commandButton tag, a página de saudação parece com o seguinte:
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
            <h:graphicImage id="waveImg" url="/wave.med.gif" />
            <H: inputText id = label "userNo" = "Número do Usuário"
                value = "# {} UserNumberBean.userNumber">
                    <F: validateLongRange
                         mínimo = "# {UserNumberBean.minimum}"
                         máximo = "# {UserNumberBean.maximum}" />
            </ H: inputText>
            <H: commandButton id = "submit"
                 action = valor "sucesso" = "Enviar" />
        </ H: form>
    </ F: view>
    
    
    Exibindo mensagens de erro
    mensagem de tag é usada para exibir mensagens de erro na página quando a conversão ou validação de dados falhar depois que o usuário envia o formulário. A mensagem de tag em greeting.jsp exibe uma mensagem de erro se os dados inseridos no campo não está de acordo com as regras especificadas pelo LongRangeValidator implementação, cuja marca é registrado no componente Campo de texto.
    A mensagem de erro é exibida sempre que você coloca a mensagem de tag na página. A mensagem do tag estilo atributo permite que você especifique o estilo de formatação para o texto da mensagem. Sua para atributo refere-se ao componente cujo valor de validação falhou, neste caso, o userNo componente representado pela inputText marcação na greeting.jsp principal.
    Coloque a mensagem de marcação perto do fim da página:
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/html" = "h"%>
    <% @ Taglib uri = prefixo "http://java.sun.com/jsf/core" = "f"%>
    <f:view>
        <h:form id="helloForm1">
            <h2> Hi. Meu nome é Duke. Estou pensando em um número de
             <H: outputText lang = "en_US"
                 value = "# {UserNumberBean.minimum}" /> a
             <h:outputText value="#{UserNumberBean.maximum}"/>.
            Você consegue adivinhar isso? </ H2>
            <h:graphicImage id="waveImg" url="/wave.med.gif" />
            <H: inputText id = label "userNo" = "Número do Usuário"
                value = "# {} UserNumberBean.userNumber"
                converterMessage = "# {ErrMsg.userNoConvert}">
                <F: validateLongRange
                         mínimo = "# {UserNumberBean.minimum}"
                         máximo = "# {UserNumberBean.maximum}" />
            </ H: inputText>
            <H: commandButton id = "submit"
                 action = valor "sucesso" = "Enviar" />
            <H: mensagem ShowSummary = "true" showDetail = "false"
                    style = "color: red;
                     font-family: "New Century Didático ', serif;
                     font-style: oblíqua;
                     text-decoration: overline "
                     id = "errors1"
                     para = "userNo" />
        </ H: form>
    </ F: view>
    
    
    Agora que você terminou a página de saudação. Supondo que você também tem feito o response.jsp página, você pode passar para a definição das regras de navegação da página.

    Definindo a navegação de página

    Definindo página de navegação consiste em determinar qual a página para ir depois que o usuário clica em um botão ou um hiperlink. Navegação para o aplicativo é definido no arquivo de configuração da aplicação de recursos através de um sistema baseado em regras poderoso. Aqui é uma das regras de navegação definidos para o guessNumber exemplo:
    <navigation-rule>
        <from-view-id> / greeting.jsp </ from-view-id>
        <navigation-case>
            <from-outcome> sucesso </ from-outcome>
            <to-view-id> / response.jsp </ to-view-id>
        </ Navigation-case>
    </ Navigation-rule>
    <navigation-rule>
        <from-view-id> / response.jsp </ from-view-id>
        <navigation-case>
            <from-outcome> sucesso </ from-outcome>
            <to-view-id> / greeting.jsp </ to-view-id>
        </ Navigation-case>
    </ Navigation-rule>
    
    
    Esta regra de navegação afirma que quando o botão na página de saudação é clicado a aplicação irá navegar para response.jsp se o sistema de navegação é dado um resultado lógico de sucesso .
    No caso do exemplo Número Guess, o resultado lógico é definido pela acção atributo do UICommand componente que sustenta a forma:
    <H: commandButton id = ação "submit" = "sucesso"
         value = "Submit" />
    
    

    Configurando mensagens de erro

    No caso das mensagens de erro padrão não atender às suas necessidades, você pode criar novos em pacotes de recursos e configurar os pacotes de recursos no seu arquivo de recurso de configuração do aplicativo. O guessNumber exemplo, tem uma mensagem conversor personalizado.
    Esta mensagem é armazenada no pacote de recursos, ApplicationMessages.properties :
    userNoConvert = O valor digitado não é um número.
    O pacote de recursos é configurado no arquivo de configuração do aplicativo:
    <application>
        <resource-bundle>
            <base-name> guessNumber.ApplicationMessages </ base-name>
            <var> Mensagem de erro </ var>
        </ Resource-bundle>
    </ Application>
    
    
    base-name elemento indica o nome completo do pacote de recursos. A var elemento indica o nome pelo qual os autores de páginas referem-se ao pacote de recursos com a linguagem de expressão. Aqui está o inputText tag novamente:
    <H: inputText id = label "userNo" = "Número do Usuário"
        value = "# {} UserNumberBean.userNumber"
            converterMessage = "# {ErrMsg.userNoConvert}">
            ...
    </ H: inputText>
    
    

    Desenvolver o Feijão

    Desenvolvimento de feijão é uma responsabilidade do desenvolvedor do aplicativo. Um típico JavaServer Faces casais aplicação de um bean de apoio a cada página no aplicativo. O bean de apoio define propriedades e métodos que estão associados com os componentes de interface utilizados na página.
    O autor da página se liga o valor de um componente a uma propriedade de bean usando a tag do componente valor do atributo para se referir à propriedade.Lembre-se que o userNo componente nas greeting.jsp referências de página a userNumber propriedade de UserNumberBean :
    <H: inputText id = label "userNo" = "Número do Usuário"
                value = "# {} UserNumberBean.userNumber">
    ...
    </ H: inputText>
    
    
    Aqui está o userNumber propriedade bean de apoio que mapeia os dados para o userNo componente:
    Integer userNumber = null;
    ...
    setUserNumber public void (Integer user_number) {
        userNumber = user_number;
     }
    getUserNumber Integer pública () {
        voltar userNumber;
    }
    getResponse public String () {
        if (userNumber! = null &&
             userNumber.compareTo (randomInt) == 0) {
                voltar! "Yay É isso aí!";
        } Else {
            return "Desculpe", userNumber + + "é incorreto.";
        }
    }

    Adicionando declarações managed bean

    Depois de desenvolver os grãos que apóiam a ser utilizados na aplicação, você precisa configurá-los no arquivo de configuração da aplicação dos recursos de modo que a implementação JavaServer Faces pode criar automaticamente novas instâncias dos grãos sempre que forem necessários. A tarefa de adicionar declarações managed bean no arquivo de configuração da aplicação dos recursos é de responsabilidade do arquiteto de aplicativos. Aqui está uma declaração managed bean para UserNumberBean :
    <managed-bean>
        <managed-bean-name> UserNumberBean </ managed-bean-name>
        <managed-bean-class>
            guessNumber.UserNumberBean
        </ Managed-bean-class>
        <managed-bean-scope> sessão </ managed-bean-scope>
        <managed-property>
            <property-name> mínimo </ property-name>
            <property-class> longo </ classe property>
            <valor> 0 </ value>
        </ Managed-property>
        <managed-property>
            <property-name> máximo </ property-name>
            <property-class> longo </ classe property>
            <valor> 10 </ value>
        </ Managed-property>
    </ Managed-bean>
    
    
    Esta declaração configura UserNumberBean para que seu mínimo propriedade é inicializada a 0, o máximo propriedade é inicializada a 10, e ele é adicionado ao escopo de sessão, quando ele é criado. Então é isso. Espero que tenha ajudado! Abraços e até a próxima!
  • Gostou? Curta nossa página: https://www.facebook.com/Javanamente?bookmark_t=page 
  • Parceiros: Rota Urbana:https://www.facebook.com/RotaUrbana
  • Execute TI: http://www.executeti.com.br/ 
  • TaLegal: http://mastalegal.com.br/

Admin: Bruno

Olá Galera! muito grato por estarem acessando nosso blog. Espero que seja possível transmitir de forma compreensível um pouco de meus conhecimentos em programação, para esta comunidade de desenvolvedores que cresce cada vez mais! Espero que Gostem! Abraço! E meu enorme obrigado à Renato Simões, Átila Soares,Wanderson Quinto, Emerson e a toda galera que sempre ajudou meu sincero obrigado....
Especialmente a Natalia Failache e Rita de Cassia que sempre apoiaram este sonho....

De seu amigo Bruno Rafael.