JSF 2.0 na prática - Navegação implicíta

Novas características do JSF 2.0 na prática - Navegação implicíta

Depois do primeiro exemplo (primeiro exemplo), vamos tentar explorar as novas características. A primeira delas, a anotação @ManagedBean, já foi usada no primeiro exemplo.

Navegação padrão...

Cansado ou triste por ter que escrever navigation-rules pra coisas muito obvias... O padrão JSF 2 trouxe dos já-bem-conhecidos frameworks a idéia de só ter que criar uma regra de navegação na exceção, nos casos comuns prevalece o "bom senso"...
Bem o seu bom senso pode ser diferente do meu que pode ser diferente do Super Mario que por sua vez também pode ser diferente do Senhor Abravanel. Leia sobre essa regra em http://blog.gilliard.eti.br/2009/05/implicit-navigation-jsf-2/

De volta ao exemplo

Para demonstrar como essa característica funciona na prática, adicione o seguinte componente a nossa página index.xhtml.

[br /][h:commandButton value="Navegação implícita!" action="login"/]

Além disso crie uma página com nome login.xhtml
[?xml version="1.0" encoding="ISO-8859-1" ?]
[!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"]
[html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"]
[head]
[title]ArchSoftyJSF2[/title]
[/head]
[body]
[h:form]
[h:outputText value="Login!"/]
[/h:form]
[/body]
[/html]

Pronto agora quando clicar no botão [Navegação implícita!] a página que será mostrada será a login.xhtml.

Ainda sem o faces-config.xml!

Exemplo simples usando JavaServer Faces 2.0 (BETA1) JSF 2 + Eclipse Galileo + Tomcat 6x

O que necessito?

1. 1. Tomcat: http://tomcat.apache.org/download-60.cgi (ou algo que "rode" a espec. JSP2.5)
2. 2. JSF 2.0 BETA1: https://javaserverfaces.dev.java.net/files/documents/1866/135560/mojarra-2.0.0-Beta1-binary.zip
3. 3. Eclispe Galileo: http://www.eclipse.org/downloads/ (ou Netbeans 6.7, gnome-editor, vi, notepad...)
4. 4. JDK 6.0: http://java.sun.com/javase/downloads/index.jsp

Primeiro passo.

Crie um projeto java web. No caso especifico do Eclipse essa categoria se chama: "Dynamic Web Project", nomei o projeto como desejar, eu usarei o nome "ArchSoftyJSF2"; ainda no Eclipse escolhi como "Target runtime" o Apache Tomcat v6.0 e já cliquei em Finish.

Segundo passo.

Coloque os dois jars - jsf-api.jar e jsf-impl.jar - no classpath da aplicação.

Terceiro passo.

Modifique o arquivo web.xml, adicionando um Servlet.
[servlet]
[servlet-name]Faces Servlet[/servlet-name]
[servlet-class]javax.faces.webapp.FacesServlet[/servlet-class]
[/servlet]

[servlet-mapping]
[servlet-name]Faces Servlet[/servlet-name]
[url-pattern]*.jsf[/url-pattern]
[/servlet-mapping]

Quarto passo.

Crie um arquivo (index.xhtml) com o seguinte conteúdo.

[?xml version="1.0" encoding="ISO-8859-1" ?]
[!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"]
[html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"]
[head]
[title]ArchSoftyJSF2[/title]
[/head]
[body]
[h:form]
[h:outputText value="Alô, Mundão!"/]
[/h:form]
[/body]
[/html]

Quinto passo.

Rode e verá sua primeira aplicação usando Jsf 2.0 funcionando. Claro que se trata de um exemplo bem simples, pra deixar mais interessante vamos adicionar um botão e usar o novo modelo de managed bean (digo modelo no sentido de criação por meio de annotations).


Sexto passo.

Crie uma classe Java:

package presentation;

import javax.faces.bean.ManagedBean;

@ManagedBean(name="primeiroBean")
public class PrimeiroBeanMB {
private String texto;

public String getTexto() {
return texto;
}

public void setTexto(String texto) {
this.texto = texto;
}

public void mudeOTexto(){
texto = "Texto modificado!";
System.out.println(texto);
}
}


Sétimo passo.

Altere o index.xhtml mais precisamente mude o interior de ...

[h:form]
[h:outputText value="Alô, Mundão!"/]
[h:commandButton value="Mudar o texto" action="#{primeiroBean.mudeOTexto}"/]
[h:outputText value="#{primeiroBean.texto}"/]
[/h:form]

Agora é só rodar... Sentiu a ausência do faces-config.xml?

ps: desculpe a preguiça de apenas mudar <<>> por ]

Investimento Certo em Novembro de 2009 Arquitetura e Design de Software - Uma visão sobre a plataforma Java

Em novembro de 2009 você tem um grande investimento para fazer, desta vez não se trata de aplicações na Poupança ou mesmo CDB e sim num livro que a editora Elsevier irá publicar.

O livro intitulado: Arquitetura e Design de Software - Uma visão sobre a plataforma Java (que já possui um site http://www.arquiteturajava.com.br/) foi escrito por "nada mais nada menos" que: Fábio Kung, Guilherme Moreira, Nico Steppat, Paulo Silveira e Sérgio Lopes (Caelum não lhe veio a cabeça?).

"O prefácio de Phillip Calçado já deixa bem claro que não há uma arquitetura de caixinha, e de que cada caso deve ser estudado a fundo."

Não é preciso dizer mais nada...
O draft inicial dos conteúdos:

1. Arquitetura pré-pronta de caixinha? Prefácio de Phillip Calçado
2. Introdução
3. Plataforma Java
   1. Java como plataforma, não como linguagem
   2. Gerenciar memória não é simples
   3. Otimizacao prematura é a raiz de todo mal
   4. Tome cuidado com o ciclo de vida de objetos caros
   5. A comunidade Java - do JCP aos fóruns
   6. A burocracia e o lado ruim das especificações
   7. A linguagem certa para cada tarefa
4. Tópicos de Orientação a Objetos
   1. Evite herança, favoreça composição
   2. Programe voltado a interface, não a implementação
   3. Prefira a imutabilidade
   4. Cuidado com a criação indiscriminada de getters e setters
   5. Modelo anêmico
   6. Domain-Driven Design
   7. O Código e a Linguagem Ubíqua
5. Java avançado
   1. Refletindo seu código
   2. Configurando: anotações e XML
   3. Entendendo o NoSuchMethodError e o ClassLoader hell
   4. Manipulação de bytecode
6. Design
   1. Baixo acoplamento, alta coesão
   2. Inversão de Controle: Cadê a minha chave de fenda?
   3. Fábricas e o mito do baixo acoplamento
   4. O que preciso para ser IoC-based?
7. Arquitetura
   1. Camadas e Camadas: a confusão de tiers e layers
   2. Granularidade correta: Minimize a comunicação entre tiers
   3. Model View Controller
   4. Dois tiers
   5. Tres tiers
   6. N-tiers
   7. Mensageria assíncrona
8. Frameworks e especificações Java EE
   1. Enterprise Java Beans
   2. JavaServer Faces facilita a criação de interfaces?
   3. Considere usar uma ferramente de mapeamento objeto relacional
   4. Logar é melhor que debugar
   5. Evite escrever seu proprio framework
   6. Injeção de dependência
9. SOA - Same Old Architecture?
   1. A burocratização do SOAP vale a pena?
   2. Não escreva XML dentro de XML: não veja XML
   3. Considere um outro protocolo leve
   4. SOA: Same Old Architecture?
10. Web 2.0
11. Segurança

Mais sobre o livro Arquitetura e Design de Software - Uma visão sobre a plataforma Java no site http://www.arquiteturajava.com.br/

Tutorial Jogl - Desenhando em Java com Jogl 2D

Depois te fazer sua primeira tela usando o Jogl agora iremos para parte final desse tutorial.

Para desenharmos no Jogl iremos usar seus eventos. Há uma interface (GLEventListener) que devemos implementar se quisermos desenhar. Uma implementação nula (ou mock) pode ser vista abaixo:

import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;


public class OuvinteJogl implements GLEventListener {
public void init(GLAutoDrawable arg0) {
}

public void display(GLAutoDrawable arg0) {
}

public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
}

public void displayChanged(GLAutoDrawable arg0, boolean arg1, boolean arg2) {
}
}

Se concentre em dois métodos, o init e o display ambos recebem um GLAutoDrawable. Esse GLAutoDrawable será o nosso GLCanvas, assim as mudanças que faremos em GLAutoDrawable irão refletir diretamente no nosso GLCanvas.

Método init

Começemos então pelo método init que irá inicializar nosso desenho.
public void init(GLAutoDrawable drawable) {
int width = 512, height = 256;
GL gl = drawable.getGL();
GLU glu = new GLU();
gl.glClearColor(.0f, .0f, .0f, 1.0f);
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(0.0, width, 0.0, height);
}
Aqui basicamente defini uma resolução (largura x altura). A segunda linha do méotodo é importantissíma veja como extrai o objeto GL (que na verdade é a API da OpenGl) e nele que iremos trabalhar diretamente com "a linguagem opengl". Esse GLU é uma biblioteca que nos ajuda nas tarefas rotineiras do opengl.

Depois de ter o contexto da opengl (gl) o código foi basicamente de inicialazação de um plano 2D (sem profundidade) na resolução dada.

Método display

Agora sim, nesse método que iremos criar o código para desenharmos a tv desintonizada usando o jogl.
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);

gl.glBegin(GL.GL_POINTS);
for (int x = 0; x < y =" 0;">

Simples. Aqui da mesma forma o primeiro passo é adiquirir o contexto da OpenGL (representado pelo objeto GL no java), limpar as cores gl.glClear(GL.GL_COLOR_BUFFER_BIT) e começar a desenhar pontos na tela. A logica é simples percorre-se dois for's uma para x e outro para y, a cada ponto uma cor é setada usando o método random da biblioteca Math (padrão do Java).

Agora pra juntar isso ao nosso JFrame anterior... ?
Simples basta ligar o nosso Listener ao Canvas.

super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
canvas.addGLEventListener(new OuvinteJogl());
add(canvas);

Simples, não?
Execute e veja o resultado!


Mas perai... alguém me enganou! Isso não é animado...
É ai que entra o 3º Componente o FPSAnimator.
Ainda no construtor... escreva após a última linha de código existente nele.

FPSAnimator animator = new FPSAnimator(canvas, 50);
animator.start();

Agora execute e veja. (aquel 50 é o número de fps) Pronto igualzinho aquele tempo que a TV te dava canseira com o Super Nintendo e o Video Cassete.

Links:

1. http://archsofty.blogspot.com/2009/05/jogl-java-bindings-for-opengl-api-with.html
2. http://archsofty.blogspot.com/2009/05/tutorial-jogl-configuracao-do-ambiente.html
3. http://archsofty.blogspot.com/2009/05/tutorial-jogl-desenhando-em-java-com.html

Código Final Completo.
import com.sun.opengl.util.FPSAnimator;
import javax.media.opengl.GLCanvas;
import javax.swing.JFrame;

public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
canvas.addGLEventListener(new OuvinteJogl());
add(canvas);
FPSAnimator animator = new FPSAnimator(canvas, 50);
animator.start();
}
}

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;

public class OuvinteJogl implements GLEventListener {

public void init(GLAutoDrawable drawable) {
int width = 512, height = 256;
GL gl = drawable.getGL();
GLU glu = new GLU();
gl.glClearColor(.0f, .0f, .0f, 1.0f);
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(0.0, width, 0.0, height);
}

public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);

gl.glBegin(GL.GL_POINTS);
for (int x = 0; x < 512; x++) {
for (int y = 0; y < 256; y++) {
gl.glColor3f((float)Math.random(), (float)Math.random(), (float)Math.random());
gl.glVertex2i(x, y);
}
}
gl.glEnd();
}

public void reshape(GLAutoDrawable drawable, int arg1, int arg2, int arg3, int arg4) {
}

public void displayChanged(GLAutoDrawable drawable, boolean arg1, boolean arg2) {
}
}

Tutorial JOGL - Configuração do ambiente

Primeira Parte - Configurando Jogl no Netbeans

O primeiro passo é ir ao site do jogl e baixar a versão correspondente ao seu sistema operacional. No meu exemplo estou usando o Windows portando baixei desse link http://download.java.net/media/jogl/builds/archive/jsr-231-1.1.1/jogl-1.1.1-windows-i586.zip . Dentro do arquivo comprimido haverá uma pasta lib vário arquivos:

• gluegen-rt.dll
• gluegen-rt.jar
• jogl.dll
• jogl.jar
• jogl_awt.dll
• jogl_cg.dll

Note que se você estiver usando linux ao invés de *.dll terá os arquivos *.so.

Como em qualquer outro desenvolvimento uma IDE poderá te ajudar e muito, escolha a sua preferida. Estou usando o NetBeans 6.5. (Que não necessariamente é minha IDE preferida ;) )

Conceitos sobre Jogl

Quando você está criando uma aplicação que irá lançar mão de recursos providos pelo OpenGL há básicamente três componentes que poderão facilitar e muito sua vida. São eles:

GLCanvas (ou GLPanel) - Um componente (que extend de Component do AWT).
GLEventListener - O modelo de listener para os eventos comuns do opengl.
FPSAnimator - Uma classe que irá lhe ajudar a efetivamente fazer seus desenhos (ou jogos) animarem.

Criando um projeto...

Crie um projeto e adicione à ele as bibliotecas (gluegen-rt.jar e jogl.jar), copie também para pasta raiz do projeto todas as *.dll que estavam na pasta lib (do arquivo baixado anteriormente).

Para simplicar bastante as coisas (assim deixando de mais fácil entendimento para todos) iremos criar um JFrame e mostraremos nesse JFrame nossa animação.

O código pode ser visto abaixo:

import javax.swing.JFrame;

public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setSize(514, 258);
}
}

Simples ao extremo. Apenas cria um JFrame atribuindo o tamanho de 514 pixels de comprimento por 258 pixels de altura.

O próximo passo é escrever o componente que irá mostrar a tela opengl dentro desse JFrame. Para tal tarefa apenas escrevemos:

GLCanvas canvas = new GLCanvas();
add(canvas);

Isso, claro, no construtor abaixo de setSize. Agora se executarmos a aplicação teremos algo semelhando a isso abaixo.
















Sua máquina irá mostrar algo diferente, como não definimos nada o "opengl" mostra dados randômicos da sua memoria RAM. O importante neste ponto é a simplicidade do código, com pouco código já se pode ver algo produzido pelo Jogl.

O meu código final para o JFrame ficou assim:

import javax.media.opengl.GLCanvas;
import javax.swing.JFrame;

public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
add(canvas);
}
}

Note que também adicionei um comportamente padrão para quando o usuário clicar no botão X da Janela.

Links:

1. http://archsofty.blogspot.com/2009/05/jogl-java-bindings-for-opengl-api-with.html
2. http://archsofty.blogspot.com/2009/05/tutorial-jogl-configuracao-do-ambiente.html
3. http://archsofty.blogspot.com/2009/05/tutorial-jogl-desenhando-em-java-com.html

Jogl - Java bindings for OpenGL API with OpenGL 1.5 specification

Pretendo nos próximos posts explicar sobre como utilizar a API OpenGL no Java. Especificamente o "framework" Jogl.
Essas primeiras partes abordaram o básico ( não pretendo aprofundar muito nos conceitos, mostrar só a prática mesmo ) e o produto final desse tutorial - se assim posso chamar - será um programa que irá desenhar, em uma tela, pixels com cores randômicas... similar ao efeito de uma tv desintonizada.

Links:

1. http://archsofty.blogspot.com/2009/05/jogl-java-bindings-for-opengl-api-with.html
2. http://archsofty.blogspot.com/2009/05/tutorial-jogl-configuracao-do-ambiente.html
3. http://archsofty.blogspot.com/2009/05/tutorial-jogl-desenhando-em-java-com.html