Suporte a JSF 2.x no NetBeans IDE

O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0

O NetBeans IDE fornece diversas funcionalidades que ativam o suporte integrado para o JavaServer Faces (JSF) 2.0 e 2.1. O suporte ao JSF 2.x do IDE baseia-se no suporte anterior do JavaServer Faces e inclui aprimoramentos versáteis do editor para as páginas de Facelets, diversas facilidades para trabalhar com entidades de classe e um conjunto de assistentes do JSF para tarefas comuns de desenvolvimento, como criar beans gerenciados pelo JSF, modelos de Facelets e componentes compostos.

Os tópicos a seguir demonstram as funcionalidades do JSF 2.x à sua disposição ao trabalhar no NetBeans IDE. Para testar as novas funcionalidades JSF, faça o download do pacote Java do NetBeans IDE, que inclui tecnologias Java Web e EE. O pacote de downloads também inclui o GlassFish Server Open Source Edition, que é a implementação de referência da especificação de plataforma Java EE 6 (JSR 316).

Conteúdo

Suporte do JSF 2.x para Projetos

O suporte JSF para projetos pode ser categorizado da seguinte forma:

  • Os arquivos de modelos Facelets estão incluídos no projeto
  • A bibliotecas JSF 2.x são adicionadas ao classpath do projeto
  • O servlet Faces e o mapeamento de servlet são adicionados no descritor de implantação do projeto

Usando o GlassFish server ou qualquer outro servidor compatível com Java EE, você pode criar projetos com suporte do JSF 2.x ou adicionar suporte do JSF 2.x a um projeto existente.

Criando um Novo Projeto com Suporte do JSF 2.x

Utilize o assistente Projeto do IDE para criar um nova aplicação Java Web. Para isso, clique no botão Novo Projeto ( Botão Novo Projeto ) da barra de ferramentas principal do IDE ou pressione Ctrl-Shift-N (⌘-Shift-N no Mac). Quando chegar na Etapa 4: Frameworks, selecione JavaServer Faces.

Assistente de Novo Projeto: Frameworks

Após selecionar o JavaServer Faces, diversas opções de configuração se tornarão disponíveis, conforme mostrado na imagem anterior. É possível determinar como seu projeto tem acesso às bibliotecas JSF 2.x. Clique na guia Configuração para especificar como o servlet Faces será registrado no descritor de implantação do projeto.

Guia Configuração

Adicionando Suporte JSF 2.x a um Projeto Existente

Se você deseja adicionar o suporte JSF 2.x a uma aplicação Java Web existente, você poderá fazê-lo na janela Propriedades.

  1. Na janela Projetos (Ctrl-1; &#8984-1 no Mac), clique com o botão direito do mouse no nó do projeto e selecione Propriedades. A Janela Propriedades do Projeto será exibida
  2. Selecione a categoria Frameworks e, em seguida e clique no botão Adicionar.
  3. Selecione JavaServer Faces na caixa de diálogo Adicionar um Framework. Clique em OK.
    Janela Propriedades do Projeto: Caixa de diálogo Adicionar Framework

    Após selecionar JavaServer Faces, diversas opções de configuração se tornarão disponíveis, como a especificação do caminho para bibliotecas JSF 2.x, e o registro de servlet Faces no descritor de implantação do projeto.


Utilizando o Editor

O editor do IDE é específico em linguagem e fornece o suporte dependendo do tipo de arquivo no qual você está trabalhando. De uma forma geral, é possível pressionar Ctrl-Espaço em um elemento do arquivo para chamar a funcionalidade autocompletar código e a documentação API. Você também pode tirar vantagem dos atalhos do teclado e dos modelos de código.

Selecione Ajuda > Cartão de Atalhos do Teclado, no menu principal do IDE para exibir atalhos comuns do teclado e modelos de código. Para obter a lista completa, consulte Especificação de Atalhos do Teclado do NetBeans IDE 6.x.

O IDE fornece suporte Javadoc incorporado para o JSF 2.0 API e JSF 2.1 API, bem como para a Documentação de Biblioteca de Tags de JSF. Para aproveitar esses recursos em seu trabalho, basta pressionar Ctrl-Espaço em um determinado elemento do Editor.

Se preferir ter contínuo acesso à documentação do Javadoc, você pode abrir a janela Javadoc do IDE (Janela > Outro > Javadoc). A janela Javadoc é automaticamente atualizada dependendo da localização de seu cursor no Editor.

Quando você trabalha em um projeto JSF, seus esforços de edição serão gastos principalmente em arquivos Facelets, beans gerenciados pelo JSF e no arquivo de configuração Faces (faces-config.xml). A seguir, demonstramos rapidamente o suporte do Editor que está à sua disposição.

Editor Facelets

O Editor Facelets do IDE fornece diversas funcionalidades que facilitam o desenvolvimento JSF, incluindo o realce de sintaxe e a verificação de erros de tags JSF, suporte à documentação e a funcionalidade autocompletar código para expressões EL, bibliotecas Core Facelets núcleo e namespaces.

É possível pressionar Ctrl-Espaço para chamar a funcionalidade autocompletar código e o suporte à documentação, onde for aplicável.

Editor do IDE exibindo a funcionalidade autocompletar código e o suporte à documentação

Você também pode digitar um prefixo antes de pressionar Ctrl-Espaço, por exemplo., jsf, para filtrar itens.

Lista pop-up da funcionalidade autocompletar no editor do IDE

É possível pressionar Ctrl-Espaço para chamar a funcionalidade autocompletar código para namespaces Facelets.

Lista pop-up da funcionalidade autocompletar no editor do IDE

De forma semelhante, se você digitar uma tag JSF, cujo namespace não tenha sido declarado na página, o IDE o adicionará automaticamente à tag <html> da página.

O editor fornece o suporte à funcionalidade autocompletar código para a sintaxe de Linguagem da Expressão (EL). Pressione Ctrl-Espaço no código EL para chamar sugestões para objetos implícitos, beans gerenciados pelo JSF e suas propriedades.

Lista pop-up da funcionalidade autocompletar código para expressões EL

Você também pode realçar snippets do código no editor e selecionar Converter para Componente Composto para criar componentes compostos JSF. Consulte o assistente de Componente Composto para obter mais detalhes.

O editor fornece recursos de verificação básica de erros. Um erro é exibido com um sublinhado vermelho e o indicador correspondente na margem esquerda. As advertências ficam sublinhadas em amarelo e são indicadas por um identificador amarelo na margem esquerda. É possível passar o mouse sobre o indicador ou texto sublinhado para exibir uma descrição do erro.

Quando você insere tags JSF, diversas verificações são efetuadas. Estas são incluídas se:

  • a biblioteca declarada existir
  • a biblioteca correspondente ao prefixo da tag contiver tal componente ou tag
  • a tag contiver todos os atributos requeridos
  • todos os atributos inseridos estiverem definidos na interface do componente

O Editor também verifica:

  • a existência de componentes não declarados
  • a presença de declarações da biblioteca de tags sem utilizações

Editor de Configuração Faces XML

Se você incluir um arquivo faces-config.xml em seu projeto JSF, você poderá pressionar Ctrl-Espaço ao definir as regras de navegação ou ao declarar beans gerenciados para apresentar a funcionalidade autocompletar código e o suporte à documentação.

Se preferir inserir regras de navegação e beans gerenciados utilizando caixas de diálogo em vez de codificá-los manualmente, o IDE fornecerá diversas caixas de diálogo específicas do JSF para esse fim. Estas são acessíveis a partir do menu contextual do Editor.

arquivo faces-config.xml - menu contextual

O IDE fornece duas views distintas para o arquivo faces-config.xml : a view Código-fonte, que exibe o código-fonte XML, e a view Fluxo de Página, que é uma interface gráfica que descreve as regras de navegação JSF definidas no arquivo faces-config.xml.

Por exemplo, se seu arquivo contiver a seguinte regra de navegação:

<navigation-rule>
    <from-view-id>/greeting.xhtml</from-view-id>
    <navigation-case>
        <from-outcome>response</from-outcome>
        <to-view-id>/success.xhtml</to-view-id>
    </navigation-case>
</navigation-rule>

A view em Fluxo de Página exibe a seguinte relação, indicando a navegação de greeting.xhtml para success.xhtml que ocorre quando "response" é transmitida ao NavigationHandler do JSF.

Arquivo faces-config.xml: view em Fluxo de Página

Ao clicar duas vezes nos componentes da view em Fluxo de Página, você pode navegar diretamente para o arquivo de origem. Por exemplo, quando você clica duas vezes no componente greeting.xhtml, o arquivo greeting.xhtml é aberto no editor. Da mesma forma, se você clicar duas vezes na seta entre os dois componentes, o Editor irá focar na regra de navegação definida na view em XLM faces-config.xml.


Assistentes do JSF

O NetBeans IDE fornece vários assistentes que facilitam o desenvolvimento com o JSF 2.x. Você pode criar novas páginas de Facelets, modelos de Facelets, beans gerenciados de JSF, componentes do composto, arquivos de configuração do Faces e muito mais.

Todos os assistentes são acessíveis por meio do assistente de Arquivo genérico do IDE. Para acessar o assistente de Arquivo, pressione o botão Novo Arquivo ( Botão Novo Arquivo ) ou selecione Arquivo > Novo Arquivo no menu principal (ou pressione Ctrl-N; ⌘-N no Mac). Os assistentes específicos do JSF são listados na categoria JavaServer Faces.

Assistente de Arquivo: Categoria do JavaServer Faces selecionada

Os seguintes assistentes estão disponíveis ao trabalhar em um projeto Java Web com suporte JSF.

Assistente de Página JSF

Utilize o assistente de Página JSF para criar páginas de Facelets e JSP para seu projeto. No assistente de Arquivo do IDE, selecione a categoria JavaServer Faces e, em seguida, selecione Página JSF. No JSF 2.x, Facelets é a forma preferencial para declarar páginas JSF. A opção Facelets no assistente é selecionada por default. Selecione a opção Arquivo JSP se deseja criar novas páginas JSP ou fragmentos JSP (arquivos.jspf).

Assistente de Arquivo JSF

Assistente de Bean Gerenciado

É possível criar beans gerenciados pelo JSF para sua aplicação utilizando o assistente de Bean Gerenciado do IDE. Na categoria JavaServer Faces no assistente de Arquivo do IDE, selecione Bean gerenciado pelo JSF.

Como default, os metadados especificados são traduzidos em anotações que são aplicadas ao bean gerenciado após ele ser gerado. Por exemplo, na imagem a seguir, você pode criar uma nova classe com escopo na sessão denominada NewJSFManagedBean e nomeá-la como myManagedBean.

Assistente de Bean Gerenciado

Quando o bean gerenciado é gerado, ele aparece da seguinte forma com anotações apropriadas.

package my.org;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean(name="myManagedBean")
@SessionScoped
public class NewJSFManagedBean {

    /** Creates a new instance of NewJSFManagedBean */
    public NewJSFManagedBean() {
    }

}

Se o seu projeto já contiver um arquivo faces-config.xml, a opção "Adicionar dados ao arquivo de configuração' do assistente ficará ativa, permitindo declarar o bean gerenciado no arquivo de configurações do Faces ou ter metadados especificados por meio de anotações no bean gerenciado.

Assistente de Configuração do Faces

O JSF 2.x introduz anotações como uma alternativa ao arquivo de configuração padrão do Faces (faces-config.xml) para configurar sua aplicação. Portanto, ao adicionar o suporte JSF 2.x a um projeto, o IDE não gera um arquivo faces-config.xml default (como acontecia no JSF 1.2). Naturalmente, você pode querer adicionar um arquivo faces-config.xml ao seu projeto, a fim de definir determinadas definições de configuração. Para isso, utilize o assistente de Configuração de Faces do IDE.

Na categoria JavaServer Faces do assistente de Arquivo do IDE, selecione Configuração do JSF Faces. Isso permite criar um novo arquivo faces-config.xml, que será colocado por default na pasta WEB-INF de seu projeto.

Consulte Editor de configuração XML do Faces para obter uma descrição do suporte do Editor do IDE para faces-config.xml.

Assistente de Componente Composto

O JSF 2.x simplificou o processo de criação de componentes compostos da interface do usuário (UI), que podem ser reutilizados em páginas Web. É possível utilizar o assistente de Componente Composto do IDE para gerar um modelo de Facelets para um componente composto JSF.

Como com todos os assistentes relativos ao JSF, você pode acessar o assistente de Componente Composto a partir da categoria JavaServer Faces no assistente de Arquivodo IDE. No entanto, uma forma mais intuitiva de solicitar o assistente é realçando o snippet do código de uma página de Facelets no Editor e selecionando Refatorar > Converter para Componente Composto, no menu pop-up.

O exemplo a seguir descreve as ações que ocorrem, e os recursos à sua disposição, ao chamar o assistente de Componente Composto do snippet, '<p>This is the composite component.</p>'.

Editor de Facelets - opção do menu Converter para Componente Composto

O assistente de Componente Composto é aberto, contendo o snippet selecionado em seu painel Seção de implementação.

Assistente de Componente Composto

Por default, o assistente cria uma pasta ezcomp para conter os componentes compostos. Por exemplo, se você estiver criando um novo componente denominadomyComponent, o assistente irá gerar uma página de Facelets myComponent.xhtml , residindo na pasta resources/ezcomp da raiz da Web da sua aplicação.

Quando você conclui o assistente, o arquivo de origem do componente do composto é gerado para o snippet de código fornecido. O modelo inclui uma referência para a biblioteca de tags composite do JSF 2.x.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
    xmlns:cc="http://xmlns.jcp.org/jsf/composite">

  <!-- INTERFACE -->
  <cc:interface>
  </cc:interface>

  <!-- IMPLEMENTATION -->
  <cc:implementation>
    <p>This is the composite component.</p>
  </cc:implementation>
</html>

Além disso, uma nova tag de componente é inserida na localização do editor em que você realçou o snippet do código. Nesse caso, a tag gerada é: <ez:myComponent/>. Observe que o IDE adiciona automaticamente o namespace onde o componente composto reside para a tag <html> da página.

Assistente de Componente Composto

O IDE também suporta o hiperlink para os arquivos de origem do componente composto. É possível navegar até o componente composto de uma página de Facelets pressionando Ctrl (&#8984 no Mac) enquanto passa o mouse sobre a tag do componente. Quando você clica no hiperlink, o arquivo de origem do componente do composto é aberto no Editor.

Para obter mais informações sobre componentes compostos no JSF 2.x, consulte Abstração Verdadeira: Componentes de IU Compostos no JSF 2.0.

Assistente de Páginas JSF de Classes de Entidade

Consulte o tópico Criando Páginas JSF de Classes de Entidade em Suporte para Classes de Entidade.

Assistente de Modelo de Facelets

Utilize o assistente de Modelo de Facelets para gerar um modelo Facelets. Na categoria JavaServer Faces do assistente de Arquivo do IDE, selecione Modelo de Facelets. É possível escolher entre oito estilos de layout exclusivos e especificar se o layout será implementado utilizando a tag <table> CSS ou HTML.

Assistente de Modelo de Facelets

O assistente cria um arquivo de modelo XHTML utilizando as tags <h:head> e <h:body> e coloca as folhas de estilos associadas na pasta resources/css da raiz da Web da aplicação. O assistente gera um arquivo default.css, e um arquivo cssLayout.css ou tableLayout.css , dependendo da sua seleção de layout.

Para exibir o modelo em um browser, clique com o botão direito do mouse no editor e selecione Exibir. Será aberta uma janela do browser para exibir o modelo.

Assistente de Cliente de Modelo de Facelets

Utilize o assistente Cliente de Modelo de Facelets para gerar uma página que referencie um modelo de Facelets no seu projeto. Na categoria JavaServer Faces no assistente de Arquivo do IDE, selecione Cliente de Modelo de Facelets. Você pode especificar o local do Modelo de Facelets utilizado pelo cliente. Você pode especificar se a tag raiz é <html> ou <ui:composition>

Assistente de Cliente de Modelo de Facelets

Para obter mais detalhes sobre como utilizar modelos e clientes de Facelets, consulte a seção Aplicando um Modelo de Facelets em Introdução ao JavaServer Faces 2.x no NetBeans IDE.


Suporte para Classes de Entidade

Se você estiver utilizando a persistência Java em sua aplicação e tiver classes de entidade com base em seu esquema de banco de dados, o IDE fornecerá a funcionalidade que permitirá trabalhar de forma eficiente com dados da classe de entidade.

Observação: para criar classes de entidade de uma tabela de banco de dados, utilize o assistente de Classes de Entidade do Banco de Dados do IDE, acessível a partir da categoria Persistência do assistente de Arquivodo IDE.

Criando Páginas JSF de Classes de Entidade

Após ter classes de entidade em sua aplicação, você pode utilizar Páginas JSF do IDE usando o assistente de Classes de Entidade para criar uma interface Web a fim de exibir e modificar dados da classe de entidade. O código gerado pelo assistente baseia-se nas anotações de persistência contidas nas classes de entidade.

Para cada classe de entidade o assistente gera o seguinte:

  • um bean de sessão stateless para a criação, recuperação, modificação e remoção de instâncias de entidade
  • um bean gerenciado com escopo de sessão JSF
  • um diretório contendo quatro arquivos de Facelets para os recursos CRUD (Create.xhtml, Edit.xhtml, List.xhtml e View.xhtml)
  • classes de utilitário utilizadas pelos beans gerenciados pelo JSF (JsfUtil, PaginationHelper)
  • um conjunto de propriedades para mensagens localizadas e uma entrada correspondente no arquivo de configuração Faces do projeto (será criado um arquivo faces-config.xml, caso já não exista um).
  • arquivos Web auxiliares, incluindo uma folha de estilo default para componentes renderizados e um arquivo de modelo de Facelets

Para utilizar as Páginas JSF do assistente de Classes de Entidade, acesse o assistente de Arquivo do IDE. Selecione a categoria JavaServer Faces e, em seguida, selecione Páginas JSF das Classes de Entidade.

Quando você chegar à Etapa 3: Gere Páginas e Classes JSF, você poderá especificar as localizações dos arquivos que serão gerados.

Etapa 3: Gerar Páginas e Classes JSF

Por exemplo, se você estiver aplicando o assistente a uma classe de entidade Customer , as definições mostradas na imagem acima irão gerar os seguintes arquivos:

Janela Projetos - arquivos gerados a partir do assistente
  • Um arquivo faces-config.xml para registrar a localização do conjunto de propriedades que contém as mensagens localizadas para as views JSF. Por exemplo, especificar /my/org/Bundle para o Nome do Conjunto de Localizações no assistente irá gerar a seguinte entrada:
    <application>
        <resource-bundle>
            <base-name>/my/org/Bundle</base-name>
            <var>bundle</var>
        </resource-bundle>
    </application>
  • Uma pasta customer em sua raiz da Web, que contém quatro arquivos de Facelets para os recursos CRUD:
    • Create.xhtml: Um form JSF para criar um novo cliente.
    • Edit.xhtml: um form JSF para editar um cliente.
    • List.xhtml: Uma tabela de dados JSF para navegar entre os clientes.
    • View.xhtml: Um form JSF para exibir os detalhes do cliente.
  • jsfcrud.css: Uma folha de estilo utilizada para renderizar os forms JSF e a tabela de dados.
  • template.xhtml: uma página de modelo de Facelets opcional, que inclui uma referência à folha de estilo jsfcrud.css gerada.
  • Um bean (enterprise) de sessão stateless denominado CustomerFacade, que reside no pacote my.org.data. Esta classe também pode ser acessada a partir do nó Enterprise Beans do projeto.
  • Bundle.properties: Um conjunto de propriedades que contém as mensagens default localizadas para as views JSF.
  • Um bean gerenciado de escopo de sessão JSF denominado CustomerController, que reside no pacote my.org.ui.
  • Duas classes de utilitário (JsfUtil e PaginationHelper) residindo no pacote my.org.ui.util. Essas são utilizadas pelo bean gerenciado CustomerController.

Criando um Form JSF para Dados da Entidade

É possível utilizar o Form da caixa de diálogo Entidade para gerar um form JSF que contém campos para todas as propriedades contidas na classe de entidade. É preciso já ter um bean gerenciado pelo JSF criado para manipular dados do usuário associados ao form.

Observação: Se você utilizar essa caixa de diálogo sem ter um bean gerenciado associado, você poderá inserir um nome para o bean gerenciado na caixa de diálogo e esse nome será utilizado na página independentemente de ser ou não válido. É possível, então, criar um bean gerenciado utilizando o assistente de Bean Gerenciado do IDE, ou se você utilizar o assistente de Página JSF de Classes de Entidade, os beans gerenciados serão gerados para todas as classes de entidade selecionadas.

É possível acessar o Form a partir da caixa de diálogo Entidade pressionando Ctrl-Espaço no editor de uma página de Facelets e, em seguida, escolhendo Form JSF na Entidade ou clicando duas vezes no item Form da Entidade listada na Paleta do IDE (Ctrl-Shift-8; &#8984-Shift-8 no Mac).

Por exemplo, na imagem a seguir, já existe uma classe de entidade Customer no pacote my.org do projeto fornecido. Um bean gerenciado customerController também já existe no projeto especificado, e o bean gerenciado contém uma propriedade denominada selected que retorna um objeto Customer.

Caixa de diálogo Form JSF da Entidade

Observação: Selecione a opção 'Gerar uma view somente leitura' para criar um form que contenha campos somente para leitura. Quando esta opção é selecionada, o IDE aplica as tags <h:outputText> a campos do form, ao passo que as tags <h:inputText> são aplicadas quando a opção não está selecionada.

Quando você preenche a caixa de diálogo, o IDE gera o código para sua página Facelets. Por exemplo, uma classe de entidade Customer contendo uma propriedade customerId é exibida no seguinte formato:

<f:view>
    <h:form>
        <h1><h:outputText value="Create/Edit"/></h1>
        <h:panelGrid columns="2">
            <h:outputLabel value="CustomerId:" for="customerId" />
            <h:inputText id="customerId" value="#{customerController.selected.customerId}" title="CustomerId" required="true" requiredMessage="The CustomerId field is required."/>
            ...
            [ Other fields added here. ]
            ...
        </h:panelGrid>
    </h:form>
</f:view>

Para modificar o modelo utilizado para o código gerado, clique no link Personalizar Modelo da caixa de diálogo Form da Entidade.

Criando uma Tabela de Dados JSF para Dados da Entidade

É possível utilizar a Tabela de Dados a partir da caixa de diálogo Entidade para gerar uma tabela de dados JSF que contenha colunas para todas as propriedades contidas na classe de entidade. Para poder utilizar essa facilidade, é preciso já ter um bean gerenciado pelo JSF criado para manipular dados de backend associados à classe de entidade.

Observação: Se você utilizar essa caixa de diálogo sem ter um bean gerenciado associado, você poderá inserir um nome para o bean gerenciado na caixa de diálogo e esse nome será utilizado na página independentemente de ser ou não válido. É possível, então, criar um bean gerenciado utilizando o assistente de Bean Gerenciado do IDE, ou se você utilizar o assistente de Página JSF de Classes de Entidade, os beans gerenciados serão gerados para todas as classes de entidade selecionadas.

É possível acessar a Tabela de Dados a partir da caixa de diálogo Entidade pressionando Ctrl-Espaço no editor de uma página de Facelets e selecionando Tabela de Dados JSF da Entidade ou clicando duas vezes no item da Tabela de Dados da Entidade listado na Paleta do IDE (Ctrl-Shift-8; &#8984-Shift-8 no Mac).

Por exemplo, na imagem a seguir, á existe uma classe de entidade Produto no pacote my.org.entity do projeto especificado. Um bean gerenciado productController também já existe no projeto, e o bean gerenciado contém um método denominado getProductItens() que retorna um objeto List ou Product.

Caixa de diálogo Tabela de Dados JSF da Entidade

Quando você preenche a caixa de diálogo, o IDE gera o código para sua página Facelets. Por exemplo, uma classe de entidade Product contendo uma propriedade productId é exibida no seguinte formato:

<f:view>
    <h:form>
        <h1><h:outputText value="List"/></h1>
        <h:dataTable value="#{productController.productItems}" var="item">
            <h:column>
                <f:facet name="header">
                    <h:outputText value="ProductId"/>
                </f:facet>
                <h:outputText value="#{item.productId}"/>
            </h:column>
            ...
            [ Other columns added here. ]
            ...
        </h:dataTable>
    </h:form>
</f:view>

Para modificar o modelo utilizado para o código gerado, clique no link Personalizar Modelo da caixa de diálogo Form da Tabela de Dados.


Componentes da Paleta JSF

Ao trabalhar nas páginas de Facelets, você poderá obter vantagens da Paleta do IDE para arrastar e soltar tags JSF na página. É possível acessar a Paleta escolhendo Janela > Paleta no menu principal ou pressionar Ctrl-Shift-8 (&#8984-Shift-8 no Mac).

Paleta, com a categoria JSF expandida

Você também pode selecionar Fonte > Inserir Código (Alt-Insert; Ctrl-I no Mac) a partir do menu principal do IDE para chamar uma lista pop-up que contenha componentes específicos do JSF contidos na Paleta.

Lista pop-up da funcionalidade autocompletar no editor do IDE

A paleta fornece cinco componentes relativos ao JSF:

  • Metadados: Chama uma caixa de diálogo para adicionar pares de valores de nomes nas tags de metadados JSF. Por exemplo, se você especificar 'myId' e 'myValue' como o par de valores de nomes, o seguinte snippet de código será produzido:
    <f:metadata>
        <f:viewParam id='myId' value='myValue'/>
    </f:metadata>
  • Form JSF: Adiciona o seguinte snippet do código à página.
    <f:view>
        <h:form>
        </h:form>
    </f:view>
  • Form JSF da Entidade: Chama uma caixa de diálogo que permite associar dados de uma classe de entidade a campos contidos em um form JSF. Criando um Form JSF para Dados da Entidade
  • Tabela de Dados JSF: Adiciona o seguinte snippet do código à página.
    <f:view>
        <h:form>
            <h:dataTable value="#{}" var="item">
            </h:dataTable>
        </h:form>
    </f:view>
  • Tabela de Dados JSF da Entidade: Chama uma caixa de diálogo que permite associar dados de uma classe de entidade a campos contidos na tabela de dados JSF. Criando uma Tabela de Dados JSF para Dados da Entidade

Consulte Também

Para obter mais informações sobre o JSF 2.x, consulte os recursos a seguir:

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo