Rodrigo Aguas

Após termos nosso projeto JavaServer Faces criado no eclipse, iremos configurar o facelets no mesmo. O facelets é um framework de templating feito específicamente para projetos JSF. Ele se integra de tal forma com o cicl0 de vida do jsf que resulta numa melhora da performance significativa em comparação ao uso de JSP. Além disso, o facelets funciona em todos os web containers amplamente conhecidos, não impondo restrição alguma ao projeto.

1. Faça o download do facelets na versão 1.1.15, pois a versão 1.2 não é estável (e parece que não ficará tão cedo);
2. Extraia o arquivo “jsf-facelets.jar” para dentro da pasta “WebContent\WEB-INF\lib” do seu projeto JSF. Como estamos utilizando o JBoss nesse exemplo, não é necessário extrair também os outros arquivos JAR da pasta lib do facelets, pois são dependências de bibliotecas que já existem no JBoss;
3. Não basta apenas acrescentarmos a biblioteca do facelets em nosso projeto, devemos configurar algumas outras coisas para que o JSF se integre ao facelets. Acrescente as seguintes linhas ao arquivo faces-config.xml (encontrado em “WebContent\WEB-INF”):

   <application>
   <view-handler>com.sun.facelets.FaceletViewHandler</view-handler>
   </application>

4. E no mesmo local devemos incluir as seguintes linhas ao arquivo Web.xml:

   <context-param>
   <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
   <param-value>.htm</param-value>
   </context-param>

   <context-param>
   <param-name>facelets.DEVELOPMENT</param-name>
   <param-value>true</param-value>
   </context-param>

   <context-param>
   <param-name>facelets.SKIP_COMMENTS</param-name>
   <param-value>true</param-value>
   </context-param>

   <context-param>
   <param-name>com.sun.faces.validateXml</param-name>
   <param-value>true</param-value>
   </context-param>

   No primeiro parâmetro, indicamos que os arquivos físicos que utilizaremos para a apresentação tem extensão .htm.
   Dessa forma, quando o facelets receber uma requisição ao endereço “bemvindo.jsf” buscará pelo arquivo “bemvindo.htm”.
   Na prática, não importa a extensão escolhida, costuma-se deixar htm ou html apenas por questões históricas.

   O segundo parâmetro indica ao facelets que estamos em ambiente de desenvolvimento, dessa forma ele exibe possíveis erros em uma tela amigável ao desenvolvedor, mas que não deve ser exibida futuramente ao usuário final.

   O terceiro parâmetro determina ao facelets que os comentários nos códigos HTML devem ser tratados como comentários. Pois o facelets por padrão não ignora comentários () nos arquivos de apresentação.

   O quarto parâmetro faz com que o facelets valide o código html das telas, só permitindo que seja utilizado XHTML.

Pronto! Dessa forma o facelets já está pronto para ser executado em seu projeto.

Este tutorial explicará como criar um projeto Java para web utilizando JavaServer Faces (JSF) no Eclipse. É um passo-a-passo de todas as configurações necessárias para ter um projeto pronto para iniciar o desenvolvimento de sistemas web.

Os softwares utilizados serão o ambiente de desenvolvimento integrado Eclipse e o servidor de aplicação JBoss. Basearei as explicações nas versões mais recentes desses softwares no momento em que escrevo este tutorial, que são Eclipse Galileo SR1 e JBoss 5.1.0.GA, mas facilmente as explicações aqui lidas podem ser adaptadas às outras versões. A instalação dos mesmos não será tratada neste tutorial, então instale-os antes de prosseguir na leitura.

Então vamos à criação do projeto no Eclipse:

1. Clique com o botão direito do mouse no interior da view “Project Explorer”;
2. Vá na opção “New”;
3. Clique em “Dynamic Web Project”, uma janela se abrir;
   
4. Dê um nome para o projeto no campo “Project Name”;
5. Na caixa “Target runtime”, clique no botão “New”, abrirá uma outra janela para configuração do servidor no Eclipse;
6. Selecione na pasta “JBoss” a versão “JBoss v5.0″;
   
7. Clique no botão “Next”;
8. Clique no botão “Browser” e selecione o local onde foi instalado o JBoss em seu computador;
   
9. Clique em “Finish” e voltaremos para a janela de criação do projeto;
10. Confirme do campo “Dynamic web module version” estar selecionada a opção “2.5″;
11. Em “Configuration”, selecione a opção “JavaServer Faces v1.2 Project”;
    
12. Clique no botão “Next”, abrirá uma tela que não faremos nenhuma alteração;
13. Clique no botão “Next” novamente;
    
14. Confirme do marcador “Generate web.xml deployment descriptor” estar selecionado;
    
15. Clique no botão “Next” mais uma vez;
    
16. Clique no botão “Finish”para efetivamente criar o projeto;
    

Pronto! Você está com seu projeto web criado.  No próximo tutorial ensinarei a instalar o Facelets, pois aplicações sérias em JSF usam Facelets! Não percam!

Abraço!

Já escrevi sobre a criação de relacionamentos no MySQL anteriormente, então não serei repetitivo em falar sobre as mesmas coisas, mas aconselho a leitura do artigo anterior para os que não tiverem intimidade com relacionamentos de banco de dados.

Neste me concentrarei em mostrar a criação de relacionamentos utilizando apenas comandos SQL, não que isso dispense a utilização de uma interface com o banco de dados para a execução dos mesmos. Para isso, podemos utilizar além do próprio MySQL Query Browser, o phpMyAdmin ou outro programa de sua preferência que permita a execução de códigos SQL na base de dados.

Basearei minhas explicações em exemplos para a criação de um banco de dados para uma “biblioteca” (inventado apenas para nos servir de exemplo, então longe de ser completo o suficiente para uma aplicação real). Iniciaremos, criando a tabela de autores, contendo o nome do mesmo e um identificador:


create table autor (
id int,
nome varchar
)

No código anterior contemplamos apenas a estrutura da tabela, ignorando a definição da chave primária e dos campos que não aceitam valores nulos. Então, colocaremos o id como chave primária (primary key, ou apenas pk) e auto incrementada, para que o seu valor seja gerado pelo próprio MySQL. Além disso, o campo nome passa a não aceitar valores nulos, pois o padrão é que qualquer coluna aceite valores nulos. Existem outras sintaxes para esse comando, mas mostrarei apenas a que considero mais simples (mas não possibilita a criação de chaves compostas).


create table autor (
id int not null auto_increment primary key,
nome varchar not null
)

Então, nossa tabela de autores está pronta. Criaremos agora a tabela de livros. Para simplificar, considerarei que um livro será escrito por apenas um autor, assim teremos que cada livro fará referência a exato um registro da tabela de autores. Armazenaremos, além do autor, apenas ISBN, título e edição do livro.


create table livro (
id int not null auto_increment primary key,
isbn int not null,
titulo varchar not null,
edicao int not null
)


Já que o ISBN é um identificador único para as edições dos livros, poderíamos utilizá-lo como chave primária, mas não faremos isso, apenas não aceitaremos valores repetidos no ISBN, para isso utilizaremos unique nessa coluna. Além disso, temos ainda que criar uma coluna para o relacionamento com a tabela de autores e constraint de chave estrangeira (foreign key, ou apenas fk).


create table livro (
id int not null auto_increment primary key,
isbn int not null unique,
titulo varchar not null,
edicao int not null,
autor int not null
constraint fk_autor foreign key (id) references autor(id) on delete restrict on update restrict
)
engine = InnoDB


Não comentei sobre a última linha do comando, ela determina o tipo de tabela que o MySQL criará. É necessário acrescentá-la por causa da foreign key, que não é suportada por qualquer tipo de tabela.

A criação das tabelas de autor e livro já foram suficientes para mostrar o básico da sintaxe de criação de tabela e já temos um (mini) banco de dados funcionando. Existem muitos detalhes que não foram comentados nesse artigo, quem quiser pode encontrá-los na documentação do MySQL.

Espero ter respondido aos pedidos feitos nos comentários do outro artigo. Abraços!