Abraçando a WEB: Serviços RESTful

Apesar dos Web Services serem desenvolvidos para muitos protocolos o que vemos na grande maioria das implementações é o uso do protocolo HTTP como meio para o transporte de outro protocolo o SOAP. Esse excesso de abstração da camada de transporte impossibilita o uso dos recursos do protocolo HTTP. Por quê não utilizar HTTP somente?

Um dos meios para utilizar o protocolo HTTP para distribuir serviços, Web Services, de maneira amigável seria o uso do REST. Seguindo os princípios do REST podemos ter uma arquitetura SOA altamente escalável. Sem dúvida REST se tornou uma alternativa muito atraente para substituir os Web Services SOAP/WS-*, resolvendo os problemas citados na Parte 1, como interoperabilidade e escalabilidade. Segue algumas características dos serviços RESTful:

• Endereçamento de recursos/serviços através de uma URI
• Interações baseadas somente em HTTP
• Uso de métodos padrões HTTP (GET, POST, PUT, etc)
• Interações sem estado
• Possibilita diferentes formatos de distribuição
• Armazenamento em Cache
• Iteroperabilidade
• Escalabilidade

A simplicidade e o alto nível de interoperabilidade dos serviços em RESTful são alguns dos fatores que podem melhorar a agilidade da próxima geração de soluções SOA.

Interoperabilidade com WS-*

Apesar do notável trabalho acadêmico realizado na família de protocolos WS-* percebemos que ainda não supre as expectativas iniciais. Interoperabilidade e complexidade ainda são desafios importantes que encaramos na adoção dos protocolos WS-*. A melhor prática para melhorar a interoperabilidade dos protocolos WS-* é identificar as características dos consumidores dos serviços e criar endpoints distintos para cada particularidade desses consumidores. Por exemplo, vamos considerar um senário que devemos assegurar um Web Service que irá ser consumido por aplicações .NET, Sun Metro, Oracle Weblogic e Ruby on Rails. Neste senário podemos permitir que três endpoints com diferentes configurações de segurança atendam às diferentes características das aplicações que consomem o Web Service, como mostrado na Figura 6:

Padrão de múltiplos endpoints de serviços

Federação de ESB: Um caminho menos árduo

Vimos na sessão anterior que uma arquitetura com um ESB centralizado é uma das causas fundamentais de falhas na implementação de um sistema SOA. Após inúmeras tentativas de implementação de um ESB centralizado em grandes organizações a indústria está adotando um padrão mais ágil de implementação do ESB. Essencialmente, esse novo padrão visa particionar as funcionalidades em leves ESBs físicos que são agrupados como entidades federativas. Este padrão é comumente conhecido como Federação de ESB e representa uma das emergentes arquiteturas para implementar soluções ESB de alta escalabilidade. Com essa arquitetura podemos ter uma infraestrutura ESB específica para interfaces Business to Business, outra para troca de transações financeiras, como mostrada na Figura 6.

Padrão de Federação de ESB

Governça em SOA: Capitalizando SOA

A limitada adoção do UDDI em sistemas SOA de grande porte tem sido um catalisador do surgimento de um modelo mais leve e mais interoperável de governaça em SOA, levando em conta tecnologias como REST e Web 2.0. Essencialmente, esses modelos foram criados para remover algumas complexidades que são apresentadas pelo modelo UDDI centralizado, substituindo algumas tecnologias por outras amplamente adotadas como HTTP, Atom e JSON.
Uma das formas mais populares de implementar esse novo modelo de governaça SOA é utilizar um repositório de serviços RESTful. Neste modelo a implementação tradicional SOA como serviços, endpoints, operações e mensagens são representadas como recursos que podem ser acessados através de um conjunto de interfaces RESTful.
O maior benefício que traz esse novo modelo é a interoperabilidade ganha utilizando interfaces RESTful, como mostrada na Figura 7, além de ser uma abordagem muito mais leve e flexível.

Repositório RESTful

Bem-vindo a Computação em Núvem

A computação em núvem pode auxiliar em uma arquitetura SOA híbrida, onde alguns componentes de um sistema SOA possam estar em uma outra infraestrutura. Alguns exemplos do uso da computação em núvem em um sistema SOA:

• ESB na Núvem: Podemos hospedar um ESB na núvem? Claro que podemos! Este tipo de arquitetura possibilita disponibilizar todos os recursos de um ESB através de uma infraestrutura na Núvem.
• Serviços de Segurança na Núvem: Nos últimos anos temos percebido o aumento da adoção de serviços de segurança, assim como o Windows Live ID ou o Facebook Connect, e usar a Núvem para prover serviços de segurança pode facilitar a implementação de mecanismos altamente interoperáveis, disponibilizando serviços de autenticação, identificação e autorização a diversos clientes distintos.
• Serviços de Armazenamento na Núvem: Indiscutivelmente, serviços de armazenamento como Amazon S3 ou o Azure DB são os serviços mais atraentes encontrados na Núvem. Considerar esse mecanismo pode alavancar a flexibilidade e a interoperabilidade da troca de dados de seu sistema SOA, além de eliminar algumas complexidades existentes em se ter uma infraestrutura própria para armazenamento de dados.

Serviços na Núvem

Conclusão

A tradicional arquitetura SOA implica em sérios desafios que tornam impraticável implementações em larga escala. Este artigo post sugeriu uma série de padrões que podem ajudar o desenvolvedor a ter uma implementação mais leve, interoperável e escalável de SOA, possibilitando realmente serviços de negócio com agilidade em senários de larga escala empresarial.

Abstração de Protocolos:

• Considerar primeiro o protocolo padrão, HTTP. Ele é muito leve e pode conversar com outros frameworks.
• Fazer uso do SOAP e WS-* quando houver necessidade de controle de transações ou a necessidade de muita performance no protocolo TCP/IP.

SOAP e WSDL:

• Não fazer uso de SOAP e WSDL até ter certeza que vai precisar de algum recurso que eles oferecem.
• Considerar o uso de REST, JSON e Atom Pub como alternativas mais leves.
• Não cair na armadilha de gerar o WSDL a partir do código, o contrato vem sempre em primeiro.

Governaça

• Fazer uso de um repositório de serviços para ajudar a gerenciar os serviços de sua empresa.
• Considerar o uso de um repositório de serviços RESTful.

Enterprise Service Bus

• Não confundir um ESB com um sistema que processa eventos.
• Considerar o uso de federação de ESBs.

Serviços baseados na Núvem

• Considerar serviços de segurança local, privado ou públic baseados na Núvem, é um dos os serviços mais maduros que existe na Núvem
• Considerar a possibilidade futura de serviços de armazenamento e serviços de ESB na Núvem.

A coisa mais importante que você deve ter em mente quando está contruindo sua aplicação SOA é o mantra “Convenção ao invés de Configuração”. Diminuindo o número de opções ao mínimo e fazendo somente o que são requisitos do negócio, você deve acreditar que é possível contruir uma arquitetura orientada a serviços que seja leve, fácil de manter e evoluir, mesmo em ambientes de larga escala empresarial.

Minha Conclusão

Acho que essa segunda parte extendeu um pouco, portanto, vou deixar minha conclusão para uma terceira parte.

Mesmo assim nessa segunda parte podemos ver as sugestões de Jesus Rodriguez e Don Demsak para solucionar alguns dos problemas encontrados nas implementações tradicionais SOA. Espero que tenham gostado, mas se não gostaram podem deixar suas queixas nos comentários irei acatá-las com certeza. Até a próxima parte…

SOA: Arquitetura sem Restrições

SOA tem sido o cerne dos sistemas distribuídos nos últimos anos, prometendo agilidade na implementação de serviços de negócio através de interfaces de negócio. É muito comum encontrar um conjunto de características semelhantes entre os tradicionais sistemas em SOA, sendo elas:

• A adotação do SOAP e WSDL como padrão para especificar o contrato, ou interface, dos serviços.
• O uso dos protocolos WS-* para pertimir algumas características de missão crítica aos serviços.
• O uso de um ESB central abstraindo diferentes orquestrações de serviço.
• O uso de um servidor de integração para gerenciar complexos processos de negócio, BPM.
• O uso de ferramentas de governança em SOA para gerenciar toda arquitetura de serviços.

Figura 1: O modelo ideal SOA

A arquitetura apresentada na Figura 1 pode ser considerada ideal pra sistemas SOA, mas esta arquitetura não leva em consideração as retrições que os sistemas SOA impõem à arquitetura, como interoperabilidade, performance e escalabilidade. A arquitetura apresentada na Figura 1 leva em consideração abstrair a complexidade de implementação dos sistemas SOA utilizando mais padrões e ferramentas.

Ultimamente se ouve muito o mantra Conveção ou invés de Configuração, que remove opções de configuração, ou parâmetros, que aumentam a complexidade do sistema por convenções previamente adotadas. Utilize as opções de configuração somente quando for realmente necessário.

SOAP: A ilusão de uma abstração da camada de transporte

Inicialmente o SOAP foi desenvolvido para abstrair os serviços das diferentes camadas de transporte, ou protocolos. Embora na teoria se mostre uma boa idéia, na prática constatamos que abstrair os serviços da camada de transporte exige um custo significativo de complexidade. Um exemplo da complexidade desta abstração é trafegar SOAP sobre HTTP, que hoje em dia é frequente. Por quê não usar o HTTP somente?

WSDL: Em abundância

O WSDL tem como propósito descrever os características dos serviços e as mensagens trocadas. Conceitualmente, o WSDL representa uma evolução para do antigo IDL. Ao utilizar o WSDL como padrão para especificar os serviços, esse se torna um artefato vital para as aplicações clientes. Essa relação entre o provedor de serviços e o cliente tende a ter um acoplamento alto, sendo que se houver uma alteração no contrato dos serviços o(s) cliente(s) serão afetados. Pensando em uma ambiente pequeno que envolve poucos clientes consumindo alguns serviços não é preocupante, mas em um ambiente empresarial e complexo o alto acoplamento entre o cliente e o provedor de serviços é um problema a se considerar.

Figura 2: Auto acoplamento com WSDL, o grande desafio de sistemas SOA de grande porte

ESB: Ter ESB ou não ter ESB

A integração heterogênea de sistemas, LOB, tem sido uma grande promessa dos sistemas empresarias SOA. Para pôr em prática essa integração entre diferentes sistemas heterogêneos foi determinado um conjunto de padrões que constituem o ESB. Ainda que não exista um padrão industrial que defina o que é um ESB, podemos adotar algumas características comuns entre os ESBs existentes no mercado. Atualmente o ESB é usado como um barramento central de serviços, como mostrado na Figura 3:

Figura 3: ESB centralizado

Pode parecer uma boa estratégia arquitetural utilizar o ESB de forma centralizada, mas na prática esse tipo de arquitetura apresenta sérias limitações nos aspectos de gerenciamento, performance e escalabilidade. Ao inves do ESB se tornar um facilitador ele pode se tornar um gargalo em sistemas SOA.

Protocolos WS-*: O lado negro

Os protocolos WS-* criados para complementar características de segurança, confiabilidade e transacionabilidade ao SOAP/WSDL não receberam muita adoção em ambientes heterogêneos. Um dos motivos da não adoção dos protocolos WS-* está nas centenas de diferentes versões de protocolos WS-* existentes, isso cria desconfiança e descredibilidade na tecnologia. A interoperabilidade é o maior desafio das soluções baseadas em protocolos WS-*, como diferentes ferramentas de Web Services as vezes implementam diferentes protocolos WS-* teremos então diferentes versões dos mesmos protolos e mesmo diferentes aspectos da mesma especificação.

Figura 4: O desafio da interoperabilidade

Governaça em SOA: Ditatura em SOA

Em sistemas SOA de médio e grande porte existe a necessidade de versionar, monitorar e gerenciar os serviços de negócio e esse papel é realizado pelas ferramentas de governaça em SOA. O maior desafio dessas ferramentas de governança é permitir de maneira confiável o gerenciamento de complexos serviços de negócio, por este motivo as tecnologias de governança em SOA tem crescido muito nos últimos tempos. As tecnologias de governaça estão adotando uma arquitetura que virtualiza os serviços de negócio em um ambiente centralizado de governaça. Embora, essa arquitetura possa ser aplicada em sistemas SOA de pequeno porte, ela apresenta sérias limitações em termos de iteroperabilidade, performance e escalabilidade em ambientes de sistemas SOA de grande porte, como mostrado na Figura 5:

Figura 5: Modelo centralizado de governança SOA

Conclusão

Nesta primeira parte do artigo foi explorado as arquiteturas SOA adotadas comumente nos dias de hoje. Na abstração da camada de transporte dos serviços de negócio foi mostrada a adoção do protocolo SOAP utilizando a especificação WSDL para manter um contrato, ou interface, dos serviços de negócio disponíveis que acarreta em uma sobrecarga de protocolos e um aumento muito significativo do acoplamento entre o provedor de serviços de negócio e os clientes cosumidores destes serviços.

Também foi mostrada a arquitetura centralizada do ESB que apresenta limitações em termos de gerenciamento, performance e escalabilidade. As diversas implementações dos protocolos WS-* que são utilizadas de forma não padronizada criando desconfiança e descredibilidade da tecnologia. Como a arquitetura centralizada do ESB foi mostrada a arquitetura que virtualiza os serviços de negócio em um ambiente centralizado de governança SOA que apresenta limitações de interoperabilidade, performance e escalabilidade.

Na segunda parte deste artigo será discutido arquiteturas e tecnologias que visão melhorar alguns aspectos negativos mostrados nessa primeira parte do artigo. Até lá ;).

Este post não tem como  objetivo discutir se utilizar Fluent Interfaces, ou não, é a melhor maneira de resolver problemas relacionados a expressões regulares, mas sim, propor um exercício a fim de criar uma possível API fluente e, ao final do artigo, demonstrar uma pequena porção de código Java que pode solucionar alguns problemas relacionados a expressões regulares utilizando esta abordagem.

O problema

O grande problema de quando trabalhamos com expressões regulares é conhecer todos os recursos disponíveis (metacaracteres, quantificadores gananciosos, possessivos, relutantes, etc) para validarmos determinada String e posteriormente recuperarmos os grupos que nos interessa para aplicarmos a lógica que necessitamos. Além disso, quanto maior for a expressão mais difícil será de interpretá-la, por isso, utilizar a abordagem “Divisão e Conquista” é uma boa prática a ser seguida.

A solução

Criar uma API para abstrair os recursos (metacaracteres, quantificadores, etc) e disponibilizar ao usuário, métodos mais legíveis e simples de escrever. Para chegar a este fim, me propus a analisar as expressões regulares que mais utilizo no dia-a-dia, “mapeá-las” para o português estruturado e, então, escrever uma porção de código que reflita a interpretação do português estruturado o mais fluente possível.

Interpretando Expressões Regulares

Analisando uma expressão regular que tem como objetivo validar se Strings representam uma data em um formato dd/mm/aaaa (em java dd/MM/yyyy), temos:

Expressão Regular: \\d{2}/\\d{2}/\\d{4}

Português estruturado: A String em questão: Inicia com dois dígitos (numéricos), seguido de uma barra, seguido de dois dígitos (numéricos), seguido de uma barra e finaliza com quatro dígitos (númericos).

Código Java:

RegexComposer composer = RegexComposer.getInstance();
composer
    .startsWith(exactly(2, digit()))
    .followedBy(exactly(1, literal("/")))
    .followedBy(exactly(2, digit()))
    .followedBy(exactly(1, literal("/")))
    .finishedWith(exactly(4, digit()));

Parece bacana, mas não está ao contrário? Porque o quantificador vem antes do dígito no código Java e na expressão regular não? Pois ao interpretarmos a expressão regular em português estruturado, também passamos o quantificador a frente do dígito e é essa a diferença, pois, ao interpretarmos uma expressão como: \\d{2} nós não escrevemos “Esta expressão representa digítos (numéricos) dois“, e sim “Esta expressão representa dois dígitos (numéricos)”.

Este foi o meu principal questionamento quando analisei a API do senhor Joshua Flanagan, pois acredito que ao utilizarmos a abordagem fluente, devemos valorizar a maneira  como escreveríamos em uma língua (português/inglês) e não como é a sintaxe de uma determinada linguagem (de programação).

Delimitadores

Uma ocorrência constante (inclusive citado no artigo do Martin Fowler) é a utilização de delimitadores para separarmos os dados em Strings (tokens). São exemplos disto, os arquivos CSV (valores separados por vírgula) e também a data do exemplo anterior (separados por barra “/”). Desta forma, seria conveniente se pudessemos configurar a API para interpretar delimitadores. A seguir, demostro um exemplo de como isto poderia ser feito:

Expressão Regular: \\d{2}/\\d{2}/\\d{4}

Português estruturado: A String em questão: Inicia com dois dígitos (numéricos), seguido de dois dígitos (numéricos), finaliza com quatro dígitos (númericos) e é delimitada por uma barra.

Código Java:

RegexComposer composer = RegexComposer.getInstance();
composer
    .startsWith(exactly(2, digit()))
    .followedBy(exactly(2, digit()))
    .finishedWith(exactly(4, digit()))
    .delimitedBy(exactly(1, literal("/")));

Tá começando a melhorar, mas existe um recurso muito importante que deve ser considerado, os agrupamentos.

Agrupamentos

Os agrupamentos em Java são efetuados através inserção da expressão em parênteses, isto possibilita recuperar a String de determinado grupo uma vez que foi validado que a String se encontra no padrão requerido. A seguir demonstro uma maneira que, inicialmente, acreditei ser adequada para este fim.

Imagine que, após validar uma determinada data, você queira recuperar o dia, mês e ano separadamente para efetuar alguma lógica, então, teríamos algo como:

Expressão Regular: (\\d{2})/(\\d{2})/(\\d{4})

Português estruturado: A String em questão: Inicia com dois dígitos (numéricos) agrupados, seguido de dois dígitos (numéricos) agrupados, finaliza com quatro dígitos (númericos) agrupados e é delimitada por uma barra.

Código Java:

RegexComposer composer = RegexComposer.getInstance();

Pattern p = composer
                 .startsWith(exactly(2, digit()).grouped())
                 .followedBy(exactly(2, digit()).grouped())
                 .finishedWith(exactly(4, digit()).grouped())
                 .delimitedBy(exactly(1, literal("/")))
                 .compile();

Matcher matcher = p.matcher("05/01/1979");

if(matcher.matches()) {

    System.out.println("Dia: " + matcher.group(1));
    System.out.println("Mes: " + matcher.group(2));
    System.out.println("Ano: " + matcher.group(3));

} else {

     System.out.println("Formato invalido");

}

Legal, ao menos à primeira vista, entretanto eu ainda precisaria saber em qual grupo está o dia (matcher.group(1)), o mês (matcher.group(2)) e o ano (matcher.group(3)) e isto não é muito bacana. Creio que o ideal seria criarmos um alias para cada grupo e depois recuperarmos o número do grupo através do alias. Seria algo como .startsWith(exactly(2, digit()).grouped(usingAlias(”dia”))) e depois recuperarmos o grupo usando matcher.group(composer.getAliasGroup(”dia”)). Uma outra questão é que há outra interpretação para expressões agrupadas, por exemplo, “A String em questão: Inicia com um grupo de dois dígitos …”. Isto quer dizer que escreveriamos algo como: .startsWith(groupOf(exactly(2, digit())).usingAlias(”dia”)).

Embora eu considere estas opções adequadas, não escrevi nada disso ainda. No exemplo, a seguir, irei demonstrar um pouco mais de detalhes do que já implementei.

Exemplo prático

Utilizando o exemplo que o Martin Fowler deu em seu artigo, irei validar se a String “score 400 for 2 nights at Minas Tirith Airport” se encontra no padrão correto e ,após isto, recuperar os números 400 e 2.

Código Java:

import br.com.submundojava.regexcomposer.RegexComposer;
import static br.com.submundojava.regexcomposer.quantifier.Quantifiers.*;
import static br.com.submundojava.regexcomposer.value.MetaCharacters.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

/**
 *
 * @author Henrique Lima
 */
public class Test {

    public static void main(String argz[]) {

        RegexComposer composer = RegexComposer.getInstance();

        Pattern pattern = composer
                        .startsWith(exactly(1, literal("score")))
                        .followedBy(oneOrMore(digit()).grouped())
                        .followedBy(exactly(1, literal("for")))
                        .followedBy(oneOrMore(digit()).grouped())
                        .followedBy(exactly(1, literal("night")))
                        .followedBy(zeroOrOne(literal("s")))
                        .followedBy(exactly(1, literal("at")))
                        .delimitedBy(zeroOrMore(whiteSpace()))
                        .finishedWith(oneOrMore(any()))
                        .compile();

        Matcher matcher = pattern.matcher("score 400 for 2 nights at Minas Tirith Airport");

        if (matcher.matches()) {

            System.out.println(matcher.group(1));
            System.out.println(matcher.group(2));

        } else {
            System.out.println("Formato inválido");
        }

    }

}

Muito simples! Veja que não utilizamos nenhum metacaracter, nenhum quantificador, agrupamos os dados necessários e ainda utilizamos um delimitador. Uma pessoa nem precisaria conhecer de expressões regulares para validar a String (embora seja desejável).

Perceba que novas coisas aconteceram e utilizamos import static do Java 5 para disponibilizarmos os métodos necessários à nossa classe. Além disso, utilizamos novos métodos quantificadores (não regex) que são: zeroOrMore(), para zero ou mais ocorrências (análogo a *), oneOrMore(), para uma ou mais ocorrências (análogo a +), zeroOrOne() para zero ou uma ocorrência (análogo a ?) e por final utilizamos o método compile() para obtermos um objeto do tipo java.util.regex.Pattern para podermos validar a String.

Código fonte

Abaixo segue o projeto que criei para efetuar este post.

Para netbeans: download
Para eclipse: download

Considerações Finais

Procurei demonstrar uma maneira fluente de trabalhar com expressões regulares, abstraindo seus recursos e disponibilizando métodos de alto nível. O exemplo que escrevi ainda está muito “verde”, com nomes esquisitos para algumas classes, métodos e pacotes. Na verdade, em alguns casos, nem sei se o inglês está correto.

Além disso, existem muitas limitações, por exemplo, se eu quiser usar um delimitador e ao mesmo tempo validar um dos tokens com um outro RegexComposer, não é possível. Seria desejável poder aninhar RegexComposer’s para este fim. Outro detalhe é que os métodos da classe RegexComposer recebem sempre uma instância de Quantifier e deveriam receber uma instância de uma classe com um nome mais adequado, como Expression ou ExpressionGroup. Detalhes a serem resolvidos.

Aguardo seus comentários e quem quiser entrar em contato, meu twitter é hgflima

Um abraço.

Pense na definição da profissão “Arquiteto de Software”,
uma das muitas definições existentes segue abaixo:

“A arquitetura de um software é a estrutura ou estruturas do
sistema, o que compreende componentes de software, propriedades
desses componentes que são visíveis externamente e o relacionamento
entre eles”, Paul Clements, SEI.

Muitas vezes os profissionais que trabalham nessa profissão
não realizam exatamente o que devem, mas
a empresa se enaltece por ter um arquiteto de software envolvido em um de seus projeto.

O papel de um arquiteto de software é equiparado ao papel de um gerente de projetos,
onde um gerência a tecnologia aplicada e o outro gerência pessoas. Portanto, temos que o
fracasso de um projeto por causa de uma má gestão pessoal é culpa do gerente de projetos e
o fracasso de um projeto por causa de um problema técnico é culpa do arquiteto de software.

Ao desenvolvermos um software para um cliente temos que seguir uma lista de requisitos
que são eles funcionais e não-funcionais. Os requisitos funcionais estão quase sempre relacionados
ao negócio da empresa, como exemplo “Realizar pedido”. Já os requisitos não-funcionais estão
relacionados com performance, disponibilidade, interroperabilidade, escalabilidade,
segurança, performance, usabilidade, etc. São inúmeros os requisitos não-funcionais e
às vezes são desprezados por muitos, principalmente o gerente de projeto. O gerente de projetos
quer ver o pedido sendo realizado e o dinheiro entrando na conta da empresa e na dele,
mas temos um enorme problema nisso! Ao ignorarmos os requisitos não-funcionais, que nunca são poucos,
estamos escondendo o sol com a peneira e esperando para ficar cegos.

O papel do arquiteto de software deve ser de não permitir que os requisitos não-funcionais
sejam ignorados e nem tão pouco deixados para última hora. Muitos requisitos não-funcionais podem
interferir diretamente em um requisito funcional. O Arquiteto deve entender e compreender os
requisitos não-funcionais e propor soluções para resolvê-los. Mas isso não é o que acontece nas
empresas por ai.

Primeiro, para a maioria das empresas é inaceitável o arquiteto de software ter o mesmo
nível que um gerente de projeto. Segundo, nunca um arquiteto de software tem voz ativa
diante uma equipe de desenvolvedores que estão acostumados a fazer telas em linha de produção.

Por isso um arquiteto de software não é um super brinquedo que somente serve para
se exibir e que com o tempo perde a utilidade. Um arquiteto de software é o ícone muito influente
no ciclo de vida de um projeto e é dever dele garantir que o software funcione desde o
início de sua vida em um ambiente de produção.

O link de referência citado abaixo tem uma ótima descrição do papel de um arquiteto, todas
as empresas deveriam ler e seguir este documento, assim teríamos software funcionando!

http://www.wthreex.com/rup/process/workers/wk_archt.htm

Links relacionados:

http://pt.wikipedia.org/wiki/Arquitetura_de_software

http://www.marcomendes.com/ArquivosBlogIntroducaoArquiteturaSoftware.pdf

Na informática, mais precisamente na área de desenvolvimento, trabalhamos focados em objetivos e entregáveis bem definidos. Claro que sem uma meta bem estabelecida e tarefas bem planejadas não terá trabalho a ser entregue. Para mostrar o que estou tentando dizer vou usar como exemplo em cenário ágil.

Como a maioria deve saber o Product Owner com ajuda do time na metodologia Scrum deve lançar atividades que representam os requisitos de um projeto e priorizar cada um desses requisitos. Após o  Product Backlog ter sido analisado parte-se para os planejamentos das atividades e assim por diante.

Se o Product Backlog não foi bem analisado e bem priorizado o time acaba tendo muita dificuldade em realizar o planejamento das estórias e atividades. Portanto, durante o andamento da Sprint podemos perceber um aumento de atividades que não foram previstas com antecedência gerando uma certa insegurança para o time se realmente aquela estória ou mesmo requisito é necessário ou se deve realmente ser realizada da forma que foi planejado.

Isso faz com que o tempo gasto do time até descobrir que a Sprint deve ser cancelada por ter a meta alterada é uma perda para o andamento do projeto. E até o momento de decidir cancelar a Sprint o time detém seu tempo com várias discusões e elocubrações à respeito do real motivo de tudo estar indo para as cucuias. Isso ao olhar do Product Owner e/ou dos Stackholders aparente puro ócio do time. Como o conceito de <em>pronto</em> não foi bem definido eles não visualizam os entregáveis no tempo em que imaginavam e culpam o time por divagar demais em idéias alheias.

Mas na verdade o time não tem culpa e não está ocioso, o time está correndo atrás para saber se realmente ocorreu um problema durante a Sprint para cancelar e começar novamente de maneira correta. Já que a metodologia ágil prega o princípio de “Quanto antes encontrarmos o problema mais rápido temos que discuti-lo”.

Isso pode ser ocasionado por falta de comunicação e entendimento do Scrum Master, time e Product Owner. Um gráfico que pode ser usado para perceber com rapidez que a sprint esta caminhando em direção a outra meta é o Burn-Up.

Por isso valorizem muito a comunicação e o bom entendimento dos requisitos que serão entregue. Acredite, quem não comunica, se estrumbica.

Referências:

• Tem um artigo bem direto quanto a utilização e alguns benefícios de utilizar o burn-up chart: Burn-up e Burn-Down.

-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256M
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Xms128m
-Xmx512m
-XX:MaxPermSize=128m

E se por um acaso alguém quiser saber mais detalhes sobre este problema, recomendo a leitura do POST dreaded “java.lang.OutOfMemoryError: PermGen space” error.

Dando continuidade ao meu último POST, estarei apresentando uma maneira simples de trabalhar com Ajax utilizando componentes JSF.
As aplicações que usufruem de recursos Ajax têm evoluído de diversas maneiras nos últimos tempos e um dos aspectos importantes é a produtividade. Quando iniciei os meus estudos sobre Ajax, era necessário escrever uma quantidade significativa de código javascript, manipulando o objeto XmlHttpRequest diretamente, além de uma porção adicional de código em alguma linguagem server side (para gerar XML dinamicamente). Depois de um certo tempo vieram os frameworks javascript que diminuiram a quantidade de código a ser escrito e atualmente é possível desenvolver aplicações inteiras sem utilizar nenhum código javascript, através dos componentes do RichFaces (entre outros).

Requisitos

Antes de seguir os passos aqui descritos, é recomendável que você leia o POST Java Server Faces 1.2 Hello World ou tenha conhecimentos compatíveis.

Configurando o ambiente

Para rodar aplicações Java Server Faces 1.2 é necessário um container que implemente a especificação da JSP 2.1. Para este tutorial iremos utilizar o container Tomcat 6.0.
Download: http://tomcat.apache.org/download-60.cgi

Além dos jars para rodar o Java Server Faces 1.2 serão necessários mais 3 jars do RichFaces. Quando este POST foi escrito a versão mais recente do RichFaces era a 3.1.2. Desta forma, os nomes dos jars são: richfaces-api-3.1.2.GA.jar, richfaces-impl-3.1.2.GA.jar e richfaces-ui-3.1.2.GA.jar e se encontram dentro da pasta lib do arquivo disponível para download.
Download: http://labs.jboss.com/jbossrichfaces/downloads/

Para configurar o RichFaces serão necessárias algumas pequenas modificações no web.xml demonstrado no POST Java Server Faces 1.2 Hello World. A listagem 1 apresenta o código completo do novo web.xml.

Listagem 1

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/webapp_2_5.xsd">
<display-name>JSFAjax</display-name>

	<context-param>
		<param-name>com.sun.faces.verifyObjects</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>

	<context-param>
		<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
		<param-value>clien+t</param-value>
	</context-param>

	<context-param>
		<param-name>org.richfaces.SKIN</param-name>
		<param-value>blueSky</param-value>
	</context-param>

	<filter>
		<display-name>RichFaces Filter</display-name>
		<filter-name>richfaces</filter-name>
		<filter-class>org.ajax4jsf.Filter</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>richfaces</filter-name>
		<servlet-name>Faces Servlet</servlet-name>
		<dispatcher>REQUEST</dispatcher>
		<dispatcher>FORWARD</dispatcher>
		<dispatcher>INCLUDE</dispatcher>
	</filter-mapping>

	<servlet>
		<servlet-name>Faces Servlet</servlet-name>
		<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>Faces Servlet</servlet-name>
		<url-pattern>/faces/*</url-pattern>
	</servlet-mapping>

	<welcome-file-list>
		<welcome-file>faces/index.jsp</welcome-file>
	</welcome-file-list>

</web-app>

Um novo parâmetro de contexto foi adicionado para configurar qual skin o RichFaces irá utilizar. Por padrão, podem ser utilizados 8 valores: DEFAULT, plain, emeraldTown, blueSky, wine, japanCherry, ruby, classic e deepMarine. É possível criar novas skins e modificar os estilos dos componentes através de CSS, entretanto, este assunto será abordado em uma outra oportunidade.
Para utilizar o restante dos recursos do RichFaces o filtro org.ajax4jsf.Filter deverá ser configurado. Existem algumas opções de configuração e até diferentes tipos de configurações para um grupo de páginas. Para maiores detalhes sobre configurações dos filtros do RichFaces utilize a seção 5.5 - Filter Configuration da documentação.

Criando o javabean

Utilizaremos um simples javabean para efetuarmos um CRUD. Na listagem 2 será apresentado a classe Contato.java que deverá ser criada no pacote br.com.jsfajax.entity.

Listagem 2

package br.com.jsfajax.entity;

import java.util.Date;

public class Contato {

	private String nome;
	private Date dataNascimento;
	private String email;

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public Date getDataNascimento() {
		return dataNascimento;
	}

	public void setDataNascimento(Date dataNascimento) {
		this.dataNascimento = dataNascimento;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

}

Criando o Bean Gerenciado (Managed Bean ou Backing Bean)

Crie no pacote br.com.jsfajax.web.mbean o arquivo ContatoManager.java conforme demostra a listagem 3.

Listagem 3

package br.com.jsfajax.web.mbean;

import br.com.jsfajax.entity.Contato;

import java.util.ArrayList;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;

public class ContatoManager {

	private Contato contato;
	private List<Contato> contatos;
	private DataModel contatosData;

	public ContatoManager() {

		contato = new Contato();
		contatos = new ArrayList<Contato>();
		contatosData = new ListDataModel(contatos);

	}

	public Contato getContato() {
		return contato;
	}

	public void setContato(Contato contato) {
		this.contato = contato;
	}

	public List<Contato> getContatos() {
		return contatos;
	}

	public void setContatos(List<Contato> contatos) {
		this.contatos = contatos;
	}

	public DataModel getContatosData() {
		return contatosData;
	}

	public void setContatosData(DataModel contatosData) {
		this.contatosData = contatosData;
	}

	public void salvar(ActionEvent e) {

		// Se o contato já existia antes na lista de contatos, atualiza os dados. Do contrário adiciona.
		if(contatos.contains(contato))
			contatos.set(contatos.lastIndexOf(contato), contato);
		else
			contatos.add(contato);

		// Zera o contato para que os campos do formulário sejam limpos.
		contato = new Contato();

		// Cria uma nova mensagem de informação para o JSF
		FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO,
							"Contato adicionado com sucesso!",
							"Contato adicionado com sucesso!");

		// Adiciona a mensagem ao formulário de cadastro
		FacesContext.getCurrentInstance().addMessage("formularioCadastro", message);

	}

	public void deletar(ActionEvent e) {
		contatos.remove((Contato)contatosData.getRowData());
	}

	public void editar(ActionEvent e) {
		contato = (Contato)contatosData.getRowData();
	}

	public boolean isRendered() {
		return !contatos.isEmpty();
	}

}

Configurando o Bean Gerenciado no faces-config.xml

Adicione ao faces-config.xml o código conforme demonstra a listagem 4:

Listagem 4

<managed-bean>
	<managed-bean-name>contatoManager</managed-bean-name>
	<managed-bean-class>br.com.jsfajax.web.mbean.ContatoManager</managed-bean-class>
	<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

Criando a página JSP

Crie um arquivo chamado index.jsp, no diretório WEB-INF/ de sua aplicação WEB, com o conteúdo demonstrado na listagem 5.

Listagem 5

<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
		<title>Contato CRUD</title>
	</head>
	<body>
	<f:view>
          <h:form id="formularioCadastro">
         	<rich:panel id="cadastro" header="Cadastro de Contatos">
         		Nome:
         		<h:inputText value="#{contatoManager.contato.nome}" id="nome" required="true"
				requiredMessage="Digite o nome corretamente!"/> <br />
         		Data Nascimento (dd/mm/aaaaa):
         		<h:inputText value="#{contatoManager.contato.dataNascimento}" id="dataNascimento"
				required="true" requiredMessage="Digite a data de nascimento!"
				converterMessage="Digite a data de nascimento no formato correto!">
         			<f:convertDateTime pattern="dd/MM/yyyy"  />
         		</h:inputText> <br />
         		E-mail:
			<h:inputText value="#{contatoManager.contato.email}" id="email" required="true"
				requiredMessage="Digite o e-mail corretamente!"/> <br />
         		<a4j:commandButton value="Salvar"  actionListener="#{contatoManager.salvar}"
				reRender="cadastro,formularioLista" /><br /><br />
         		<h:messages errorStyle="color:red" infoStyle="color:#5ac67e"  />
         	</rich:panel>
           </h:form>
           <h:form id="formularioLista">
           	<rich:dataTable value="#{contatoManager.contatosData}" var="contato"
			id="listaContatos" rendered="#{contatoManager.rendered}">
           		<h:column>
				<f:facet name="header">
					<h:outputText value="Nome" />
				</f:facet>
				<h:outputText value="#{contato.nome}"/>
			</h:column>
			<h:column>
				<f:facet name="header">
					<h:outputText value="Data Nascimento" />
				</f:facet>
				<h:outputText value="#{contato.dataNascimento}">
					<f:convertDateTime pattern="dd/MM/yyyy"/>
				</h:outputText>
			</h:column>
			<h:column>
				<f:facet name="header">
					<h:outputText value="E-mail" />
				</f:facet>
				<h:outputText value="#{contato.email}"/>
			</h:column>
			<h:column>
				<f:facet name="header">
					<h:outputText value="Editar" />
				</f:facet>
				<a4j:commandLink value="Editar"
					actionListener="#{contatoManager.editar}" reRender="cadastro"/>
			</h:column>
			<h:column>
				<f:facet name="header">
					<h:outputText value="Deletar" />
				</f:facet>
				<a4j:commandLink value="Deletar"
					actionListener="#{contatoManager.deletar}" reRender="listaContatos"/>
			</h:column>
           	</rich:dataTable>
           </h:form>
        </f:view>
     	</body>
</html>

Conforme demonstrado na listagem 5, serão utilizadas mais duas taglibs responsáveis pelas funcionalidades Ajax, http://richfaces.org/a4j representada pelo apelido a4j e http://richfaces.org/rich representada pelo apelido rich.
Foram utilizados 2 formulários pois todo formulário com campos cujo atributo required possua o valor true só pode ser submetido se tais campos estiverem preenchidos. Desta forma, se os botões de editar e deletar (quando em um mesmo form) forem acionados e os campos (com required=true) estiverem vazios uma mensagem de erro será apresentada.
O atributo requiredMessage do componente h:inputText é utilizado para configurar a mensagem de erro a ser apresentada quando este campo não for preenchido e seu atributo required possuir o valor true.
O converter f:converterDateTime é utilizado para transformar a String digitada (no campo em que este converter for aplicado) em um objeto do tipo java.util.Date e vice-versa.
O atributo converterMessage do componente h:inputText é utilizado para configurar a mensagem de erro a ser apresentada quando não for possível efetuar a conversão da String para o objeto java.util.Date ou vice-versa.
Os componentes commandButton e commandLink do a4j serão responsáveis por efetuar as chamadas assíncronas. No atributo actionListener destes componentes é configurado qual método do managed bean será executado. No atributo reRender será configurado quais componentes serão atualizados depois de ser executado o método do managed bean. Desta forma, quando o botão salvar for pressionado o método salvar do managed bean será executado e o componente cujo ID é listaContatos será atualizado com um novo registro.
O componente h:messages é reponsável por apresentar as mensagens adicionadas ao FacesContext através da classe FacesMessage.
É possível customizar os estilos CSS das mensagens em função do tipo de mensagem. Um FacesMessage pode ser classificada em 4 tipos:

• FacesMessage.SEVERITY_ERROR - Indica que um erro ocorreu.
• FacesMessage.SEVERITY_FATAL - Indica que um erro grave ocorreu.
• FacesMessage.SEVERITY_INFO - Mensagem com caráter informativo.
• FacesMessage.SEVERITY_WARN - Indica que um erro pode ter acontecido.

Para utilizar estilos de CSS diferente para cada tipo de mensagem existem atributos correspondentes no componente h:messages, são eles: errorClass, fatalClass, infoClass, warnClass, errorStyle, fatalStyle, infoStyle e warnStyle. Estes atributos são correspondentes aos atributos style e class dos componentes html.

Considerações Finais

Através da utilização de componentes JSF é possível ganhar produtividade, diminuindo a quantidade de código e, na maioria das vezes, ganhar performance. Entretanto, em muitas situações isto não ocorre, devido a grande quantidade de chamadas assíncronas, consultas à base de dados desnecessárias, utilização indevida de session entre outros fatores. Em uma próxima oportunidade darei continuidade a este POST adicionando recursos da Java Persistence API e mostrando como otimizar o desempenho desta pequena aplicação.

Será necessário o conhecimento dos seguintes itens para a criarmos nosso primeiro exemplo:

1. Nível básico de conhecimento de orientação a objetos utilizando Java.
2. Nível básico de conhecimento na criação de aplicações WEB utilizando Tomcat, de preferência versão 6.0.
3. Manipulação de bibliotecas jar. (Utilizando IDE ou não).
4. Nível básico de conhecimento de HTML e XML.

Configurando o ambiente

Para rodar aplicações Java Server Faces 1.2 é necessário um container que implemente a especificação da JSP 2.1.

Para este tutorial iremos utilizar o container Tomcat 6.0.
Download: http://tomcat.apache.org/download-60.cgi

Serão necessários 8 arquivos jars que devem estar no classpath ou no diretorio WEB-INF/lib de sua aplicação WEB, são eles:

• jsf-api.jar e jsf-impl.jar
  Download: https://javaserverfaces.dev.java.net/download.html
• commons-beanutils.jar
  Download: http://commons.apache.org/downloads/download_beanutils.cgi
• commons-colletions.jar
  Download: http://commons.apache.org/downloads/download_collections.cgi
• commons-logging.jar
  Download: http://commons.apache.org/downloads/download_logging.cgi
• commons-diggester.jar
  Download: http://commons.apache.org/downloads/download_digester.cgi
• jstl.jar e standard.jar (Standard Taglib)
  Download: http://jakarta.apache.org/site/downloads/downloads_taglibs-standard.cgi

Para que o Java Server Faces funcione adequadamente se faz necessário a configuração do Faces Servlet para que este
atenda às requisições das páginas JSF. A Listagem 1 mostra um exemplo de configuração do web.xml.

Listagem 1

<?xml version="1.0" encoding="UTF-8"?><web-app version="2.5"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/webapp_2_5.xsd">

<context-param>

 	<param-name>com.sun.faces.verifyObjects</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>

<context-param>

 	<param-name>javax.faces.STATE_SAVING_METHOD</param-name>

 	<param-value>client</param-value>

</context-param>

<servlet>

<servlet-name>Faces Servlet</servlet-name>

<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>Faces Servlet</servlet-name>

<url-pattern>/faces/*</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>faces/index.jsp</welcome-file>

</welcome-file-list>

</web-app>

Como pode-se observar foram configurados 3 parâmetros de contexto. A utilidade destes será descrita a seguir:

• com.sun.faces.verifyObjects
  Esta flag é configurada como true quando se quer que implementação do Java Server Faces verifique se os objetos da aplicação
  (conversores, etc) foram criados adequadamente. Seu valor padrão é false, por afetar a performance no início da execução
  da aplicação.
• com.sun.faces.validateXml
  Esta flag é configurada como true quando se quer que a implementação do Java Server Faces verifique a integridade do arquivo
  faces-config.xml em função do seu DTD correspondente. Seu valor padrão é false.
• javax.faces.STATE_SAVING_METHOD
  Esta flag é usada para configurar em que lado da aplicação o estado da “view” deve ser salvo.
  Existem 2 valores possíveis: server e client. Quando configurado como client o estado de toda camada de visão será renderizado
  em um campo hidden na página jsp. Seu valor padrão é server.

Criando o Bean Gerenciado (Managed Bean ou Backing Bean)

O Bean Gerenciado é a camada de negócios das aplicações JSF. Sua principal função é compartilhar seus atributos e métodos
com as páginas JSP. Cada campo de um formulário da página JSP é integrado com uma atributo e cada ação e/ou evento
com um método do Bean Gerenciado, resultando numa ótima separação da camada de negócio da camada de visão. Crie no
pacote br.com.jsftutorial o arquivo HelloWorldBean.java conforme demostra a listagem 2.

Listagem 2

package br.com.jsftutorial;public class HelloWorldBean {private String nome;

public HelloWorldBean() {

}

public String getNome() {

return nome;

}

public void setNome(String nome) {

this.nome = nome;

}

public String acao() {

return "sucesso";

}

}

Todo Bean Gerenciado deve possuir o construtor default (sem nenhum argumento), do contrário será lançado uma java.lang.InstantiationException.
Todo atributo integrado à página JSP deverá possuir seus métodos setters e getters mesmo que seu modificador de visibilidade
seja public, como por exemplo o atributo nome do HelloWorldBean.

Configurando o Bean Gerenciado no faces-config.xml

O arquivo faces-config.xml é o arquivo de configuração do Java Server Faces.
Este arquivo deve estar na pasta WEB-INF/ de sua aplicação e contém entre outras configurações as declarações dos Beans Gerenciados que deverão ser instanciados pela
implementação do JSF. Na listagem 3 é apresentado um modelo típico de configuração de um Bean Gerenciado.

Listagem 3

<?xml version='1.0' encoding='UTF-8'?>

<faces-config version="1.2"

 	xmlns="http://java.sun.com/xml/ns/javaee"

 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

 	http://java.sun.com/xml/ns/javaee/webfacesconfig_1_2.xsd">

<managed-bean>

<managed-bean-name>hwBean</managed-bean-name>

<managed-bean-class>br.com.jsftutorial.HelloWorldBean</managed-bean-class>

<managed-bean-scope>request</managed-bean-scope>

</managed-bean>

</faces-config>

Entre as tags <faces-config> e </faces-config> se localizam toda a configuração da aplicação JSF.
A configuração necessária para um Bean Gerenciado é bem intuitiva, abaixo segue a descrição das tags utilizadas:

• managed-bean
  Toda a configuração de um, e apenas um, Bean Gerenciado deve estar contido nesta tag.
• managed-bean-name
  Nome utilizado para referenciar o Bean Gerenciado nas páginas JSP.
• managed-bean-class
  O caminho completo para a classe que representa este Bean Gerenciado.
• Managed-bean-scope
  Indica de qual escopo (scope) este Bean Gerenciado será resgatado. Existem 4 tipos possíveis.
  • none
    Só poderá ser utilizado como propriedade de um outro managed bean.
  • request
    Estará disponível através do request, ou seja, seu tempo de vida acaba após a submissão do formulário.
  • session
    Estará disponível através da session, ou seja, seu tempo de vida é o mesmo que o tempo de vida da session configurada no web.xml.
  • application
    Estará disponível através do objeto application, ou seja, seu tempo de vida é o mesmo da aplicação.

Existem outras tags que adicionam funcionalidades ao Bean Gerenciado, aconselho a utilizar o
Java (TM) EE 5 tutorial capítulo 5 item Backing Beans que pode ser acessado
através da url http://java.sun.com/javaee/5/docs/tutorial/doc/.

Criando o index.jsp

Crie a página index.jsp na pasta de arquivos WEB (mesma altura que WEB-INF/ e META-INF/) de sua aplicação com o conteúdo da Listagem 4.

Listagem 4

<%@page contentType="text/html"%><%@page pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Java Server Faces Tutorial</title>

</head>

<body>
	<f:view>
<h:form id=”formulario”>

<b>Nome:</b>

<h:inputText id=”nome” value=”#{hwBean.nome}” required=”true” requiredMessage=”O campo nome deve ser preenchido!”/>

<h:commandButton value=”GO” action=”#{hwBean.acao}” /><br>

<h:message for=”nome” errorStyle=”color:red”/>

</h:form>

</f:view>

</body>

</html>

Nas linhas 3 e 4 temos as declarações das taglibs core e html do Java Server Faces que serão utilizadas para criarmos os
componentes na página JSP.

A tag <f:view> deve conter os componentes JSF.

A tag <h:form> é análogo a tag <form> do html.

Através da tag <h:inputText> será criado um componente input do html e do tipo text (<input type=”text”>).
O atributo value permite integrar o valor deste componente a uma propriedade do Managed Bean, ou seja, quando o formulário for
submetido o valor deste componente será copiado para a propriedade “nome” do Managed Bean configurado no faces-config.xml
cujo o nome foi configurado como hwBean (<managedbean-name>hwBean</managed-bean-name>). O atributo
required determina que o formulário não poderá ser submetido caso este campo não seja preenchido.
O atributo requiredMessage determina a mensagem de erro que será apresentada caso, ao submeter o formulário, este componente não seja preenchido.

Através da tag <h:commandButton> será criado um componente button do html (<input type=”button”>).
O atributo action determina o método do Managed Bean que será executado quando este botão for pressionado.

A tag <h:message> é um componente utilizado para apresentar as mensagens ao usuário. O atributo “for” deve ser
preenchido com o id do componente que desejamos que esta mensagem seja integrada, ou seja, serão apresentadas as
mensagens referentes apenas ao campo cujo o id é “nome” do formulário. O atributo errorStyle permite aplicarmos um estilo
CSS ao componente quando a mensagem for de erro.

Criando o resultado.jsp

Crie a página resultado.jsp na pasta de arquivos WEB (mesma altura que WEB-INF/ e META-INF/) de sua aplicação com o conteúdo da Listagem 5.

Listagem 5

<%@page contentType="text/html"%><%@page pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Java Server Faces Tutorial</title>

</head>

<body>

<f:view>

Ola, <h:outputText value="#{hwBean.nome}" />!

</f:view>

</body>

</html>

Criando o fluxo do aplicativo

Para determinarmos o fluxo do aplicativo adicionamos uma “navigation rule” ao faces-config.xml.
Ao executarmos o método acao() do Managed Bean, a String “sucesso” será retornada e pela “navigation rule” determinamos que a página resultado.jsp
deverá ser apresentada. A listagem 6 demonstra o conteúdo do faces-config.xml.

Listagem 6

<?xml version='1.0' encoding='UTF-8'?>

<faces-config version="1.2"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/webfacesconfig_1_2.xsd">

<managed-bean>

<managed-bean-name>hwBean</managed-bean-name>

<managed-bean-class>br.com.jsftutorial.HelloWorldBean</managed-bean-class>

<managed-bean-scope>none</managed-bean-scope>

</managed-bean>

<navigation-rule>

<navigation-case>

<from-outcome>sucesso</from-outcome>

<to-view-id>/resultado.jsp</to-view-id>

</navigation-case>

</navigation-rule>

</faces-config>

Após a submissão do formulário, a propriedade “nome” do Managed Bean terá o valor digitado no componente <h:inputText> do index.jsp,
então a página resultado.jsp será apresentada (conforme configurado no faces-config.xml).
Para testar a aplicação inicie o tomcat e acesse a url: http://localhost:8080/HelloJSF/faces/index.jsp

Próximos Passos

Existem ainda diversos recursos e componentes do JSF, aconselho a leitura da referência da API,
acessando a url http://java.sun.com/javaee/javaserverfaces/reference/api/index.html.
Além disso, existem outras ótimas implementações que disponibilizam novos componentes e
recursos como a utilização de Ajax e DOM na renderização das páginas. Recomendo o estudo do IceFaces e do Ajax4Jsf, ambos open source.

Conclusão

Apesar de muita discussão sobre a qualidade dos diversos frameworks open source do mercado, Java Server Faces se apresenta
como uma ótima opção no desenvolvimento de interfaces para aplicações JEE. Com a inclusão deste framework na JEE 5,
existe uma grande tendência ao crescimento de sua utilização o que torna indispensável o conhecimento de seus recursos e
de suas diversas implementações. Neste tutorial foi abordado o conceito básico do funcionamento deste framework e em
uma nova oportunidade voltarei a escrever sobre esta tecnologia. Até lá.