sexta-feira, 6 de setembro de 2013

Um pouco sobre JSP e JSF


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

Então vamos lá.

O que é uma página JSP?


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

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

Um simples JSP Exemplo da página


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



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

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

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

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

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

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

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

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

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

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

Tecnologia JavaServer Faces

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

    JavaServer Faces Tecnologia Interface de Usuário

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

    JavaServer Faces Benefícios Tecnologia

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

    O que é uma aplicação JavaServer Faces?

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

    A JavaServer Faces Aplicação Simples

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

    Etapas do Processo de Desenvolvimento

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

    Mapeando o FacesServlet Instância

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

    Definindo a navegação de página

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

    Configurando mensagens de erro

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

    Desenvolver o Feijão

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

    Adicionando declarações managed bean

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

Admin: Bruno

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

De seu amigo Bruno Rafael.