Originalmente o sistema operacional Google Android tinha como objetivo (pelo menos oficialmente) de ser utilizado em telefones celulares. Com o mercado crescente dos netbooks, muito tem se falado da possibilidade de rodar esse sistema em computadores pessoais.  Lendo essa notícia fiquei sabendo do projeto LiveAndroid, que tem como objetivo disponibilizar uma versão do Android que rode em computadores x86 sem precisar instalar nada. Apesar de eu já conhecer o sistema através do emulador disponibilizado na SDK, resolvi baixar a imagem de CD e testar em meu computador.

Abaixo o vídeo que gravei do Android rodando virtualizado sobre o Ubuntu usando o VirtualBox:

Esse sistema operacional não é (e nem sei se será) apropriado para a utilização em desktops ou laptops, mas tem grande potencial no mercado de netbooks. Inclusive no dia que estou escrevendo este post, saiu no BR-Linux.org a notícia “Empresa chinesa adapta Android para netbooks“. Abaixo o vídeo demonstrando essa versão adaptada:

Apesar da Google ter anúnciado o Chrome OS, acredito que o Android ainda vai conquistar muito espaço. Isso é muito interessante para o Linux, que tem mais uma grande empresa o apoiando, e para os programadores Java. Mesmo que esse sistema não possua uma máquina virtual Java padrão, essa é a linguagem utilizada no desenvolvimento de seus softwares.

Se você quiser testar o Android aí também, abaixo estão os passos a serem seguidos (baseado no arquivo readmefirst.txt do projeto):

1. Acesse o site do projeto LiveAndroid: http://code.google.com/p/live-android
2. Vá em downloads e baixe os arquivos liveandroidv0.2.iso.001 e liveandroidv0.2.iso.002
3. É necessários juntar os 2 arquivos em um único:
   1. No Linux: digite na linha de comando “cat liveandroidv0.2.iso.001 liveandroidv0.2.iso.002 > liveandroidv0.2.iso”
   2. No Windows: baixe o HJ-Split e utilize a função “join” para juntar os arquivos
4. Grave a imagem em um disco ou utilize uma máquina virtual para rodá-la

O Jboss Tools é um conjunto de plugins que facilita a vida de quem trabalha com Seam, JSF, (X)HTML, Hibernate, JBoss AS, Drools, jBPM, entre outros. A versão estável do JBoss Tools 3 foi lançada essa semana e é necessária para quem quer utilizar estes plugins no Eclipse 3.4 (ou 3.5)¹, já que as versões 2.x rodam somente no 3.3 ou inferior.

É importante notar que antes você precisa ter instalado os plugins padrões para Java EE no Eclipse, caso não tenha baixe a versão “Eclipse 3.5 IDE for Java EE Developers”¹ aqui.

A instalação do JBoss Tools é muito simples e pode ser realizada pelo próprio update do Eclipse. Bem, vamos lá:

Eclipse Galileo 3.5¹

1. Vá em “Help” e “Install New Software…”
2. Clique em “Add…” para adicionar um novo site
3. Na tela coloque em “JBoss Tools” (ou outro nome que preferir) e “http://download.jboss.org/jbosstools/updates/development” na url e clique em “OK”
4. Expanda esse novo site, vá em “JBoss Tools 3.1.0 …” e selecione os plugins que deseja instalar
5. Clique em “Next” e siga os procedimentos

Instalação do Jboss Tools 3 no Eclipse 3.5

Eclipse Ganymede 3.4

1. Vá em “Help” e “Software Updates…”
2. Na aba “Available Software” clique em “Add Site…”
3. Coloque a url “http://download.jboss.org/jbosstools/updates/development” e clique em “OK”
4. Expanda esse novo site, vá em “JBoss Tools 3.0.0 …” e selecione os plugins que deseja instalar
5. Clique em “Install…” e siga os procedimentos

As imagens abaixo mostram os plugins Seam Tools (com editor visual de JSF/XHTML aberto) e Hibernate Tools funcionando:

Mais informações em: http://www.jboss.org/tools

¹Atualização em 10/08/2009: Adicionei os procedimentos para a instalação no Eclipse 3.5 / Galileo

Encontrei este link onde é possível baixar um guia rápido de referência do JBoss Seam. Está disponível no site DZone Refcardz (que aliás, tem outros ótimos guias de referência) e foi escrito por Jacob Orshalick. Achei muito interessante, pois tem um resumo de grande parte das funcionalidades deste framework, como bijection, contextual components, seam-gen, conversation management e segurança.

Fica aí a dica pra quem usa ou está estudando o Seam!

Ah, e se você ainda não leu eu escrevi um pequeno artigo de como criar um cadastro básico no JBoss Seam aqui.

Atualmente para tirar um melhor proveito dos processadores com múltiplos núcleos, é necessário que os desenvolvedores se preocupem com a execução de tarefas em paralelo. Para facilitar nisso, foi adicionado o pacote chamado java.util.concurrent no Java 5. Neste post vou apresentar através de alguns exemplos algumas facilidades que as classes deste pacote provêem.

Exemplo 1: Execução assíncrona

Download do Exemplo

Este primeiro exemplo, baseado neste exercício, consiste no cálculo do valor do PI otimizado para rodar em vários núcleos separando-o em várias tarefas. Este valor pode ser calculado aproximadamente pela série de Gregory utilizando a seguinte fórmula:

Ou seja, teremos o seguinte nas primeiras iterações: PI/4 = 1 – 1/3 + 1/5 – 1/7 + …

Quanto mais iterações, mais preciso o valor fica. Veja esse link: http://www.eveandersson.com/pi/gregory-leibniz

O código abaixo realiza o cálculo do somatório recebendo o valor inicial (k) e o final (n). Veja que nossa classe implementa a interface Callable através do método call(), o qual retorna o tipo Double como resultado do somatório.

import java.util.concurrent.Callable;

public class CalculoPI implements Callable<Double> {

    private int inicio;
    private int fim;

    public CalculoPI(int inicio, int fim) {
        this.inicio = inicio;
        this.fim = fim;
    }

    public Double call() throws Exception {
        double valor = 0.0;

        for (int i=inicio; i <= fim; i++) {
            valor += Math.pow(-1.0, i + 1) / (2.0 * (double)i - 1.0);
        }

        return valor;
    }
}

Para separarmos este cálculo em várias tarefas concorrentes podemos definir os valores iniciais e finais de cada uma delas. Veja o código a seguir:

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //cria um pool de threads para realizar o cálculo
        ExecutorService es = Executors.newCachedThreadPool();

        //separa o cálculo em 4 partes definindo o valor de n inicial e final para cada uma
        Future<Double> parte1 =  es.submit(new CalculoPI(1,100000000));
        Future<Double> parte2 = es.submit(new CalculoPI(100000001,200000000));
        Future<Double> parte3 = es.submit(new CalculoPI(200000001,300000000));
        Future<Double> parte4 = es.submit(new CalculoPI(400000001,500000000));

        //junta os valores cálculados das 4 partes e multiplica por 4
        double pi = 4.0 * (parte1.get() + parte2.get() + parte3.get() + parte4.get());

        es.shutdown();

        System.out.println("Valor calculado de PI é " + pi);
    }
}

Aqui foram utilizadas 500.000.000 iterações, as quais são dividas em 4 partes. Inicialmente, foi criado um pool de threads através de Executors.newCachedThreadPool() que retorna um objeto ThreadPoolExcutor configurado para criar novas threads assim que necessário e reaproveitar as já existentes que estejam disponíveis. Você pode também utilizar métodos como Executors.newFixedThreadPool(int) para criar um pool com número fixo de threads ou criar um objeto do tipo ThreadPoolExcutor explicitamente definindo seus parâmetros no construtor. Em seguida, as partes dos cálculos foram submetidas para execução de forma assíncrona, ou seja, ao chamar submit() não vamos aguardar o cálculo finalizar porque ele será executado em paralelo.

Quando um serviço é submetido, é retornado um objeto Future. É através dele que pegamos o resultado do cálculo na linha 19 chamando seu método get(). Este método é bloqueante, ou seja, ao chamá-lo é necessário aguardar o final da execução da tarefa.

Exemplo 2: Produtor/Consumidor com BlockingQueue

Download do Exemplo

Implementar esse algoritmo usando apenas blocos de código com synchronized e os métodos wait() e notify()/notifyAll() muitas vezes é trabalhoso. Para facilitar isso, podemos utilizar a collection BlockingQueue. Veja abaixo como fica simples o código:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    public static void main(String[] args) {
         //cria fila bloqueante com 10 lugares disponíveis
         BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(10);

         //cria e inicia thread para o produtor
         new Thread(new Produtor(queue)).start();

         //cria e inicia thread para o consumidor
         new Thread(new Consumidor(queue)).start();
     }
}

import java.util.concurrent.BlockingQueue;

public class Produtor implements Runnable {

     private BlockingQueue<Integer> queue;

     public Produtor(BlockingQueue<Integer> queue) {
         this.queue = queue;
     }

     public void run() {
         int i=0;

         try {
             while(true) {
                 /*adiciona valor na fila imediatamente se houver espaço,
                   caso contrario aguarda até que o espaço fique disponível*/
                 queue.put(i++);

                 Thread.sleep(500);
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}

import java.util.concurrent.BlockingQueue;

public class Consumidor implements Runnable {

     private BlockingQueue<Integer> queue;

     public Consumidor(BlockingQueue<Integer> queue) {
         this.queue = queue;
     }

     public void run() {
         try {
             while(true) {
                 /*se houver valor retira ele da fila, senão fica bloqueado
                  até que um valor seja adicionado */
                 int valor = queue.take();

                 System.out.println(valor);
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}

Conforme pode ser visto nos comentários no código, o método put() adiciona valor na fila imediatamente se houver espaço, caso contrario aguarda até que o espaço fique disponível. No consumidor, o método take() é chamado e, se houver algum valor disponível ele é retirado, senão fica bloqueado até que um valor seja adicionado.

Na próxima parte deste artigo irei apresentar algumas outras ferramentas deste pacote, como o uso de locks e semáforos.

Para realizarmos o mapeamento de um atributo “Enumerated type” de uma entidade podemos utilizar a annotation @Enumerated da JPA / Hibernate. O código abaixo é um exemplo de um enum:

public enum Sexo {
     M("Masculino"),
     F("Feminino");

     private String descricao;

     private Sexo(String descricao) {
          this.descricao = descricao;
     }

     public String getDescricao() {
           return descricao;
     }
 }

Abaixo o código da entidade:

@Entity
public class Pessoa {

     //...

     @Enumerated(EnumType.STRING)
     @Column(name = "sexo", nullable = false, length = 1, columnDefinition="char(1)")
     private Sexo sexo;

     //...
}

Para sua utilização na classe Pessoa adicionamos a annotation @Enumerated com o parâmetro EnumType.STRING. Isso foi feito neste exemplo com o objetivo de gravar o valor em uma coluna do tipo “char(1)” no banco de dados. Por padrão, esse valor é EnumType.ORDINAL fazendo com que o atributo enum seja salvo em um “int”.

Este artigo apresenta como fazer um cadastro simples com o JBoss Seam integrando JSF, JPA e componentes POJO. O objetivo é mostrar a principal aplicação deste framework através da explicação de seus conceitos básicos. Para isso, criei um exemplo prático de cadastro de contatos que é utilizado nas explicações.

Abaixo as tecnologias utilizadas no exemplo:

• JBoss Seam
• JSF
• Facelets
• Ajax4JSF
• Richfaces
• JPA

Introdução

Para quem já trabalhou com JSF e EJB 3.0 juntos sabe que é preciso programar uma camada muitas vezes repetitiva ao criar, por exemplo, um cadastro. Isso ocorre porque é necessário que uma página JSF esteja interligada com um Managed Bean e este por sua vez realize as chamadas propriamente ditas a um Session Bean, já que estes possuem a limitação de não se comunicarem com a camada web e nem compartilharem o mesmo contexto de requisição, sessão ou aplicação.

Com o objetivo de facilitar essa integração foi desenvolvido o JBoss Seam que faz o trabalho “sujo” na integração entre JSF e EJB. Além disso, possui uma série de vantagens no desenvolvimento de aplicações Web 2.0. Como seu modelo foi bem aceito, foi criada a JSR Web Beans para torná-lo um padrão que em breve estará disponível na plataforma Java EE.

Configurações para utilizar o Seam

Não pretendo abordar neste artigo as configurações necessárias para utilizar o Seam, já que isso pode ser facilmente encontrado na internet. Além disso, existe uma ferramenta chamada seam-gen que acompanaha o Seam que, entre outras coisas, automatiza as configurações de um novo projeto. O plugin Seam do JBoss Tools para o Eclipse (veja aqui como instalá-lo) também ajuda na hora do desenvolvimento. No tópico “Referências” no final deste artigo você encontra alguns links que explicam como utilizá-los.

Exemplo prático

Download do Projeto

Existem alguns conceitos que precisam ser compreendidos para desenvolver um projeto com o Seam, mas acho mais fácil mostrá-los através de um exemplo prático. Para isso descreverei como implementar um cadastro básico de contatos utilizando o Seam. Abaixo as imagens de como nosso cadastro ficará ao final desses passos:

Passo 1: Criando nossa entidade

Para o nosso exemplo utilizaremos JPA realizando o mapeamento objeto-relacional. Como se trata de um exemplo simples, coloquei apenas o nome e o e-mail do contato na entidade. Também ocultei algumas coisas como getters e setters que podem ser vistas no código completo.

Contato.java:

@Entity //1
@Name("contato") //2
public class Contato implements Serializable {

    @Id @GeneratedValue //3
    private Long id;

    @Column(length=50, nullable=false) //4
    private String nome;

    @Column(length=50, nullable=false)
    private String email;

    //getters, setters, hashcode, equals, etc...

}

Explicações do código (cada número se refere ao número comentado no código):

1. Declara que a classe representa uma entidade do banco de dados.
2. Define que a entidade também é um componente do Seam, ou seja, poderá ser manipulado automaticamente por ele.
3. Define o campo identificador da entidade e que este deve possuir um valor gerado automático (auto-incremento, por exemplo).
4. Mesmo sem colocar a anotação @Column um atributo é definido como uma coluna da tabela por padrão, porém neste caso desejamos definir seu tamanho máximo e que não pode ser um valor nulo.

Passo 2: Criando o componente de negócio

Neste componente é onde estão presentes as regras de negócio. O próprio Seam se responsabiliza em integrar nosso componente com a camada de visão (JSF). O interessante é que este componente pode ser puramente Seam ou também um Session Bean EJB 3.0. No primeiro caso sua aplicação precisa apenas de um Web Container (.war) como o Tomcat ou Jetty para ser implantada. Já no caso de se usar um Session Bean obviamente é necessário um container Java EE completo (.ear).

A vantagem de utilizar Session Beans é que o container  provê todas as funcionalidades do Java EE para você, como controle transacional (JTA) dos recursos e gerenciamento da segurança e escalabilidade dos componentes de negócio.

Entretanto, em um projeto mais simples pode-se utilizar componentes Seam puros, já que este framework traz algumas funcionalidades que encontramos em um container Java EE. Além disso, é simples converter uma aplicação para utilizar EJB 3.0 posteriormente.

Como o objetivo aqui é apresentar uma visão do funcionamento do Seam optei por não utilizar EJB (em um futuro post pretendo explicar como ficaria o exemplo com essa opção).

Abaixo o código na nossa Action:

ContatoAction.java:

@Name("contatoAction") //1
@Scope(ScopeType.CONVERSATION) //2
public class ContatoAction {

   @In //3
   private EntityManager entityManager; //4

   @DataModel //5
   private List<Contato> contatos;

   @DataModelSelection //6
   @Out(required=false) //7
   private Contato contato;

   @Factory("contatos") //8
   @SuppressWarnings("unchecked") //9
   public void listarContatos() {
      //seleciona todos os contatos
      contatos = entityManager.createQuery("select c from Contato c").getResultList();
   }

   @Begin //10
   public String novoContato() {
      contato = new Contato();

      return "novoContato"; //12
   }

   @Begin //10
   public String editarContato() {
      //atualiza os dadis do contato para fazer a edição
      entityManager.refresh(contato);

      return "editarContato"; //12
   }

   public String removerContato() {
      //remove o contato
      entityManager.remove(contato);

      return "contatoRemovido"; //12
   }

   @End //11
   public String salvarContato() {
      //se não tem id é porque deve ser inserido, caso contrário alterado
      if (contato.getId() == null) {
         entityManager.persist(contato);
      } else {
         entityManager.merge(contato);
      }

     return "contatoSalvo";
   }
}

Explicações do código (cada número se refere ao número comentado no código):

1. Define que é um componente Seam com o nome “contatoAction”.
2. O Seam se responsabiliza de armazenar no contexto web seus componentes. Para isso eles precisam ter um escopo definido entre os seguintes:
   • STATELESS: O componente não mantém nenhum tipo de estado, ou seja, sua instância não será armazenada no contexto web.
   • EVENT (request): A instância do componentes é mantido no contexto durante a requisição JSF.
   • PAGE: Associa a instância do componente com uma página renderizada armazenando ela na árvore de componentes JSF.
   • CONVERSATION: Mantém a instância durante uma conversação (unidade de trabalho do ponto de vista so usuário). Veja os comentários 10 e 11 abaixo.
   • SESSION: A instância permanece no contexto da sessão do usuário.
   • BUSINESS_PROCESS: Utilizado para processos longos de negócio através do jBPM.
   • APPLICATION: A instância se mantém desde o início até o final da execução da aplicação dentro do container.
3. Através da annotation @In o Seam injeta uma instância do componente que está no contexto. Por exemplo, se temos um objeto na sessão do usuário basta colocar @In que teremos disponível a referência a ele.
4. O framework se responsabiliza por injetar o EntityManager para manipularmos as nossas entidades. Isso é próximo a utilizar a annotation @PersistenceContext em Session Bean, porém a vantagem de utilizar @In é que o Seam estende o contexto de persistência durante o escopo do componente. Dessa forma não precisamos nos preocupar com o controle dos objetos que são desanexados do contexto de persistência entre uma requisição e outra do usuário.
5. Para carregar em uma tabela os contatos precisamos definimos um Data Model através dessa annotation, ou seja, é o conteúdo da lista contatos que será exibido para o usuário.
6. De forma simples podemos pegar qual o contato que o usuário selecionou na tabela. Quando ele clicar em “Editar” em um contato o Seam irá injetar na variável qual contato ele deseja editar.
7. Ao contrário da annotation @In, através de @Out colocamos uma instância no contexto.
8. Como visto em (5) temos uma lista dos contatos como Data Model. Para carregar esses contatos o Seam chamará o método que tem annotation @Factory(“contatos”).
9. Na verdade essa annotation não tem relação com o Seam. Apenas é para indicar ao compilador para ignorar um aviso, já que estamos utilizando Generics (List<Contato>) e na query é retornada uma List comum (apenas List).
10. Quando o usuário deseja criar/editar um contato, para ele é como se uma unidade de trabalho (transação) iniciasse. Essa unidade de trabalho termina em três casos: ao salvar o contato, cancelar a operação ou após um tempo limite. Em um sistema online fica impraticável manter uma transação no banco de dados por tanto tempo, já que isso causaria a trava (lock) de tabelas ou de alguns de seus registros. Para resolver essa situação utilizamos o conceito de conversação simulando uma longa unidade de trabalho para o usuário. Essa unidade de trabalho pode ser mantida, por exemplo, durante a navegação entre várias páginas em um cadastro do tipo wizard que representa um maior caso de uso. Para indicar o inicio dessa conversação utilizamos a annotation @Begin. No momento em que os métodos “novoContato()” e “editarContato()” são chamados a conversação se inicia e uma instância de nosso componente “contatoAction” é mantido no contexto web.
11. A annotation @End define que a conversação deve ser finalizada na chamada deste método. Além disso, neste momento o Seam pode descartar a instância alocada no contexto do componente “contatoAction”, já que seu escopo é CONVERSATION.
12. No JSF quando temos métodos chamados pela página (actions) temos que retornar uma string. Essa string é utilizada para definir as regras de navegação entre as páginas.

Passo 3: A parte visual (JSF e Facelets)

Na camada de visão utilizamos JSF com Facelets (veja mais sobre em Referências). A vantagem da utilização do Facelets é que podemos definir templates para as páginas facilitando assim a definição e manutenção do layout. Como este projeto foi gerado pela ferramenta seam-gen alguns templates já foram definidos automaticamente.

O arquivo abaixo é a lista de contatos:

contato_list.xhtml:

<!DOCTYPE composition PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
                             "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<ui:composition xmlns="http://www.w3.org/1999/xhtml"
	xmlns:s="http://jboss.com/products/seam/taglib"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:rich="http://richfaces.org/rich" template="layout/template.xhtml"> 

	<ui:define name="body"> <!-- 1 -->

		<h:messages globalOnly="true" styleClass="message" id="globalMessages" /> <!-- 2 -->

		<rich:panel>
			<f:facet name="header">Contatos</f:facet>
<div class="results" id="contatoList">
				<rich:dataTable	id="contatoList" var="_contato" value="#{contatos}"> <!-- 3 -->
					<h:column>
						<f:facet name="header">Id</f:facet>
			            		#{_contato.id} <!-- 4 -->
			        	</h:column>
					<h:column>
						<f:facet name="header">Nome</f:facet>
			            		#{_contato.nome}
			        	</h:column>
					<h:column>
						<f:facet name="header">Email</f:facet>
			            		#{_contato.email}
			        	</h:column>
					<h:column>
						<f:facet name="header">Ação</f:facet>
						<s:link id="editar" action="#{contatoAction.editarContato}" value="Editar" /> <!-- 5 -->
						<s:link id="remover" action="#{contatoAction.removerContato}" value="Remover" /> <!-- 5 -->
					</h:column>
				</rich:dataTable></div>
</rich:panel>

		<s:div styleClass="actionButtons">
			<s:button view="/contato_edit.xhtml" id="novo" value="Novo contato"/>
		</s:div>

	</ui:define>
</ui:composition>

Explicações do código (cada número se refere ao número comentado no código):

1. Esta é uma tag do Facelets que indica que estamos definindo o conteúdo de body do template.  Neste exemplo utilizei os templates padrões do Seam para as telas.
2. Local onde mensagens de informações e erros serão exibidas.
3. O valor da dataTable é “contatos” que declaramos como @DataModel na componente seam contatoAction. O que foi colocado em var (“_contato”) é o nome da variável que representa o contato de cada iteração (linha) para o preenchimento da tabela, ou seja, como funciona em um “for each” em Java. Em geral, é uma boa prática utilizar “_” antes do nome neste caso para não ficar ambíguo com “contato” que é um componente seam que ficará no contexto.
4. Através da variável “_contato” definimos o conteúdo de cada coluna da tabela referenciando uma de suas propriedades.
5. Nos links para a execução de uma ação utilizamos o “s:link”. O Seam se encarregará de injetar no atribudo “contato” de “contatoAction” qual foi o contato que o usuário está se referenciando.

Mas como ao clicar em “Editar” a página de edição é carregada? Quando utilizamos somente JSF definimos uma regra de navegação no arquivo faces_config.xml. No caso de utilização do Seam fazemos isso através do arquivo pages.xml. Porém, assim todas as regras ficam em um mesmo arquivo. Outra maneira de fazermos isso é especificar um arquivo por página chamando-o, neste caso, de contato_list.page.xml:

contato_list.page.xml:

<?xml version="1.0" encoding="UTF-8"?>
<page xmlns="http://jboss.com/products/seam/pages"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://jboss.com/products/seam/pages http://jboss.com/products/seam/pages-2.0.xsd"
      login-required="true">

	<navigation>
		<rule if-outcome="novoContato">
			<redirect view-id="/contato_edit.xhtml"/>
		</rule>
		<rule if-outcome="editarContato">
			<redirect view-id="/contato_edit.xhtml"/>
		</rule>
		<rule if-outcome="contatoRemovido">
			<redirect view-id="/contato_list.xhtml"/>
		</rule>
	</navigation>

</page>

Basicamente o que é definido neste XML é que quando os métodos retornarem “novoContato” (linha 8 ) ou “editarContato” (linha 11) o usuário deve ser redirecionado para a página de edição do contato. Já quando um contato for removido continuará na página de listagem. Uma coisa importante também de ser comentada é o atributo “login-required” (linha 5) na tag “page”. Definindo como “true” dizemos ao Seam que somente se o usuário estiver logado poderá acessar a página. Em futuros posts pretendo mostrar como a parte de tratamento da segurança com o JBoss Seam é interessante e simples de ser utilizada.

Abaixo o código da página de criação/edição do contato:

contato_edit.xhtml:

<!DOCTYPE composition PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
                             "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"></pre>
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
		   xmlns:s="http://jboss.com/products/seam/taglib"
		   xmlns:ui="http://java.sun.com/jsf/facelets"
		   xmlns:f="http://java.sun.com/jsf/core"
		   xmlns:h="http://java.sun.com/jsf/html"
		   xmlns:a="http://richfaces.org/a4j"
		   xmlns:rich="http://richfaces.org/rich"
		   template="layout/template.xhtml">

<ui:define name="body">

 	<h:messages globalOnly="true" styleClass="message" id="globalMessages"/>

 	<h:form id="contato" styleClass="edit">

 		<rich:panel>
 			<f:facet name="header">Contato</f:facet>

 			<s:decorate id="nomeDecoration" template="layout/edit.xhtml"> <!-- 1 -->
 				<ui:define name="label">Nome</ui:define>
 				<h:inputText id="nome"
 						required="true"
 						size="50"
						maxlength="50"
 						value="#{contato.nome}"> <!-- 2 -->
 					<a:support event="onblur" reRender="nomeDecoration"
 						bypassUpdates="true" ajaxSingle="true" /> <!-- 3 -->
 				</h:inputText>
 			</s:decorate>

			<s:decorate id="emailDecoration" template="layout/edit.xhtml">
 				<ui:define name="label">Email</ui:define>
 				<h:inputText id="email"
 						required="true"
 						size="50"
 						maxlength="50"
 						value="#{contato.email}"> <!-- 2 -->
 					<a:support event="onblur" reRender="emailDecoration"
 						bypassUpdates="true" ajaxSingle="true" /> <!-- 3 -->
 				</h:inputText>
 			</s:decorate>
<div style="clear:both">
 			<span class="required">*</span> required fields</div>
</rich:panel>
<div class="actionButtons">
 		<h:commandButton id="salvar"
 				    value="Salvar"
 				    action="#{contatoAction.salvarContato}"/> <!-- 4 -->

 		<s:button id="cancelar" value="Cancelar" propagation="end"
 			     view="/contato_list.xhtml" /> <!-- 5 --></div>
</h:form>

</ui:define>

</ui:composition>
<pre>

Explicações do código (cada número se refere ao número comentado no código):

1. A tag “s:decorate” do Seam envolve um campo de entrada do JSF e exibe uma mensagem de erro caso sua validação falhar.
2. Como definimos em nossa action, “contato” se refere ao contato que está sendo criado ou que foi previamente selecionado pelo usuário. O Seam se encarrega de colocar sua instância no contexto. Por isso, para associarmos a propriedade “nome” com o componente JSF inputText basta colocarmos value=”#{contato.nome}”.
3. Para suportarmos Ajax podemos utilizar o Ajax4JSF. Neste caso, quando o usuário deixar o campo seu preenchimento será validado. Caso esteja em branco uma mensagem de erro é exibido, já que os 2 inputText estão com a propriedade “required” como “true”.
4. Ao clicar no botão “Salvar” o método “salvarContato” de nossa action é chamado.
5. Esse componente do Seam é um botão que possui o atributo “propagation”, que como está igual a “end” permite que ao clicar em “Cancelar” a conversação seja finalizada. Além disso, o usuário é redirecionado para a lista de contatos.

Agora a última coisa, o arquivo que define as propriedades da página de edição:

contato_edit.page.xml:

<?xml version="1.0" encoding="UTF-8"?>
<page xmlns="http://jboss.com/products/seam/pages"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://jboss.com/products/seam/pages http://jboss.com/products/seam/pages-2.0.xsd"
      no-conversation-view-id="/contato_list.xhtml"
      login-required="true">

   	<navigation>
		<rule if-outcome="contatoSalvo">
			<redirect view-id="/contato_list.xhtml"/>
		</rule>
	</navigation>
</page>

Como pode ser visto, ele define que após salvar um contato o usuário é redirecionado para a lista de contatos.

Conclusão

Espero que este artigo tenha sido útil para demonstrar alguns dos principais conceitos do JBoss Seam. Este framework possui muitas outras funcionalidades como controle de segurança, suporte a URLs do estilo REST, geração de relatórios PDF/Excel, etc. Se tiver alguma dúvida ou sugestão é só deixar um comentário ou me enviar um e-mail. O código-fonte completo do exemplo pode ser baixado neste link.

Referências:

Sobre o Seam:

• http://www.seamframework.org/
• http://www.jboss.com/products/seam
• http://docs.jboss.org/seam/2.1.0.GA/reference/en-US/html/
• http://www.marcossousa.com/2008/01/14/jboss-seam-getting-started/
• http://www.urubatan.com.br/java-on-rails-produtividade-em-java-parte-1-jboss-seam/

Usando o seam-gen para desenvolver projetos Seam:

• http://docs.jboss.org/seam/2.1.0.GA/reference/en-US/html/gettingstarted.html
• http://www.marcossousa.com/tag/seam-gen/

Usando o JBoss Tools para desenvolver projetos Seam:

• http://docs.jboss.org/seam/2.1.0.GA/reference/en-US/html/gettingstartedwithjbosstools.html
• http://techieexchange.wordpress.com/2008/02/01/how-to-make-jboss-seam-work-with-eclipse-for-windows/
• http://www.devx.com/Java/Article/37547?trk=DXRSS_JAVA

Site do JBoss Tools:

• http://www.jboss.org/tools/

Sobre a JSR:

• http://jcp.org/en/jsr/detail?id=299
• http://www.urubatan.com.br/criada-uma-jsr-para-a-definio-de-web-beans-seam/

Sobre Facelets:

• https://facelets.dev.java.net/
• http://javawora.blogspot.com/2007/08/tutorial-faceltes.html
• http://www.devmedia.com.br/articles/viewcomp.asp?comp=5332

Sobre Ajax4JSF:

• http://www.jboss.org/projects/jbossAjax4jsf/
• http://www.devmedia.com.br/articles/viewcomp.asp?comp=5529

Se você está tentando usar o plugin Subeclipse no Eclipse 3.4 no Ubuntu 8.04 provavelmente já percebeu que arranjou uma dor de cabeça. O grande problema está na versão do SVN, que é a 1.4.x no Ubuntu 8.04 e o plugin precisa da 1.5.

Encontrei 2 soluções: a primeira que achei mais interessante fiz um passo-a-passo aqui, a segunda deixo um link indicado.

Solução 1: Usar o plugin Subversive

A partir do Eclipse 3.4 o Subversive se tornou o plugin padrão para acessar um repositório SVN. Entretanto, por problemas de licenciamento, uma parte do plugin está no site do eclipse.org e a outra (SVN Connectors) continuam no site polarion.org.

Instalando o Subversive SVN Team Provider:

1. Vá em “Help” e “Software Updates…”
2. Na aba “Available Software” expanda o item da árvore “Ganymede” e depois “Collaboration Tools”
3. Marque “Subversive SVN Team Provider (Incubation)” e clique em “Install…”

Instalando o Subversive SVN Team Provider

Instalando SVN Subversive Connectors:

1. Na mesma tela (“Available Software”) clique em “Add Site…”
2. Coloque a url “http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/” e clique em “OK”
3. Expanda esse novo site, vá em “Subversive SVN Connectors” e selecione quais interessa a você.

Instalando SVN Subversive Connectors

Notas para quem vai usar o JavaHL:

Se você for utilizar o Connector para o JavaHL é necessário instalá-lo no Ubuntu:

sudo apt-get install libsvn-javahl

Também adicione a seguinte linha no eclipse.ini:

-Djava.library.path=/usr/lib/jni

Definir o SVN Subversive Connector:

1. Reinicie o Eclipse, vá em “Window” e “Preferences”
2. Em “Team”, “SVN” e “SVN Connector” defina qual você deseja utilizar (se a combo estiver vazia leia mais abaixo como resolver)

Definir SVN Connector

A combo com os Connectors está vazia. O que fazer?

Infelizmente quando realizei essa instalação a versão do Subversive no site eclipse.org estava desatualizada. Se você também está passando pelo mesmo problema aconselho desistalar o plugin “Subversive SVN Team Provider” e seguir os passos abaixo:

1. Na aba “Available Software” clique em “Manage Sites…”
2. Desmarque a opção Ganymede
3. Vá para baixo, marque “http://download.eclipse.org/technology/subversive/0.7/update-site/” e clique em OK
4. Agora expanda na lista a opção “http://download.eclipse.org/technology/subversive/0.7/update-site/”
5. Instale o plugin normalmente

Solução 2: Atualizar o SVN do Ubuntu

Eu não testei essa solução, pois por adicionar o repositório de uma versão instável do Ubuntu pode ser que ocorram alguns problemas. De qualquer forma, segue o link de onde li sobre essa solução: http://muriloq.com/blog/2008/07/subclipse-no-eclipse-34-ganymede-e-ubuntu-804/

UPDATE: Agora com o lançamento oficial do Ubuntu 8.10 você pode utilizar essa nova versão sem problemas.

Referências:

http://muriloq.com/blog/2008/07/subclipse-no-eclipse-34-ganymede-e-ubuntu-804/

http://mohangk.org/blog/2008/09/ubuntu-subclipse-woes-use-javahl-bindings/

http://olafsblog.sysbsb.de/?p=53