Ajax e JSF com NetBeans

Criando uma aplicação Java EE no NetBeans 7.x

Criar uma aplicação jsp + java beans no Netbeans 7.3

Criando uma aplicação JSP no NetBeans 7.3

[JPA] Conceitos Importantes

Fonte: http://tomee.apache.org/jpa-concepts.html

Se tem uma coisa que você precisa entender para usar com sucesso a JPA (Java Persistence API), é o conceito de Cache. Infelizmente o cache é uma estrutura interna, não exposta pela JPA via código.

O que você tem que ter em mente sobre o cache da JPA:

• Um Cache é uma cópia de dados, uma cópia desconectada do banco de dados.
• Flushing é o ato de levar as modificações feitas em cache para o banco de dados.
• Um PersistenceContext é, essencialmente, um Cache.
• Um EntityManager represetne um PersistenceContext (logo, um cache).
• Um EntityManagerFactory cria um EntityManager (e todavia um PersistenceContext/Cache).

Comparando os contextos de persistência RESOURCE_LOCAL e JTA.

Com <persistence-unit transaction-type="RESOURCE_LOCAL"> você é que se responsabiliza por criar e rastrear o EntityManager (PersistenceContext/Cache).

• Você precisa usar o EntityManagerFactory para obter um EntityManager.
• A instância do EntityManager obtida é um PersistenceContext/Cache.
• Um EntityManagerFactory pode ser injetado com a anotação @PersistenceUnit apenas (sem @Persistence Context).
• Não é permitido usar @PersistenceContext para se referir a uma unit do tipo RESOURCE_LOCAL.
• Você deve usar EntityTransaction API para iniciar/comitar todas as chamadas para seu ENtityManager.
• Chamar ENtityManagerFactory.createEntityManager() duas vezes resulta em duas instâncias separadas de EntityManager e, é claro, dois PersistenceContext/Caches separados.
• Não é uma boa idéia ter mais de uma instânciade um EntityManager em uso (não crie um segundo EntityManager antes de destruir o primeiro).

Com <persistence-unit transaction-type="JTA"> o container irá cuidar da criação e do rastreamento do EntityManager para você, e neste caso:

• Você não pode usar o EntityManagerFactory para obter um EntityManager.
• Você só pode ter o EntityManager que é fornecido pelo container.
• Um EntityManager pode ser injetado pela anotação @PersistenceContext, somente (sem @PersistenceUnit).
• Você não pode usar @PersistenceUnit para fazer referência a uma unit do tipo JTA.
• O EntityManager fornecido pelo container é uma referência ao PersistenceContext/Cache associado a transação JTA.
• Se não há transações JTA em progresso, o EntityManager não pode ser usado porque não há PersistenceContext/Cache.
• Qualquer um com uma referência para a mesma unit na mesma transação irá automaticamente ter uma referência para o mesmo PersistenceContext/Cache.
• O PersistenceContext/Cache é flushed e limpo a cada commit JTA.

É isso aí! Mais informações e exemplos veja em http://tomee.apache.org/jpa-concepts.html

[JSF] Enviar requisição com Ajax

Referência: The Java EE 6 Tutorial Sending an Ajax Request.

Como prometido no post anterior Usando Ajax com JSF vou continuar nos estudos do The Java EE 6 Tutorial, agora mostrando como enviar requisições com Ajax.

O Java EE 6 Tutorial mostra quatro formas para enviar requisições Ajax, são elas:

Usando o atributo event da tag f:ajax

O atributo event define que evento d o DOM irá disparar a ação ajax. Alguns valores possíveis são click, keyup, mouseover, focus e blur.

Se um valor não for especificado para este atributo, ele irá assumir o evento default do componente pai da tag f:ajax correspondente.

Componentes ActionSource, como commandButton, commandLink e inputText tem o valor do atributo action como alvo de seus eventos default.

Exemplo:

<h:commandButton id="submit" value="Submit"> 
    <f:ajax event="click" />
</h:commandButton>
<h:outputText id="result" value="#{userNumberBean.response}" />

Note que estes eventos JSF, apesar de serem baseados em JavaScript, são diferentes dos eventos do DOM que possuem o prefixo "on".

Usando o atributo execute da tag f:ajax

Define o componente ou componentes que serão executados no servidor. O componente é identificado pelo seu atributo id e você pode especificar mais de um componente executável, separando-os com um espaço em branco.

Ao ser executado, o componente participa de todas as fases do ciclo de vida da requisição, exceto da fase Render Response.

O valor do atributo execute também pode ser uma palavra chave como @all, @none, @this e @form, explicados no post anterior Usando Ajax com JSF, referindo-se ao componente com que a tag f:ajax está aninhada.

A seguir, um exemplo mostrando como especificar que um inputText de id userNo seja executado no click de um commandButton de forma assíncrona:

<h:inputText id="userNo" 
             title="Type a number from 0 to 10:"
             value="#{userNumberBean.userNumber}">
    ...
</h:inputText>
<h:commandButton id="submit" value="Submit"> 
    <f:ajax event="click" execute="userNo" />
</h:commandButton>

Usando o atributo immediate

Se seu valor estiver configurado para true, seus eventos serão propagados durante a fase Apply Request Values. O valor default é false. Conheça o ciclo de vida JSF para complementar entendimentos.

Usando o atributo listener

Utilizado para referenciar um método do lado do servidor a ser executado por uma ação Ajax do lado do cliente. No seguinte exemplo o atributo listener da tag f:ajax chama um método em um bean quando o evento correspondente é disparado, observe:

<f:ajax listener="#{mybean.someaction}" render="somecomponent" />

Beleza?!

Agora você já pode sofisticar as interações com usuário em sua camada de apresentação JSF.

No próximo post vamos falar de CDI. Até lá!