O Seam Remoting oferece uma forma conveniente de acessar componentes backing beans via AJAX. Com uma simples anotação é possível chamar ações, intanciar objeto e etc. Porém este recurso é uma maneira limitada de acessar o contexto dos componentes e requer uma certa atenção de nós desenvolvedores. Pessoalmente, pude presenciar soluções fantásticas usando remoting e mas algumas implementações desastrosas. Fica a dica: use o remoting apenas quando os componentes AJAX existentes não solucionam um dado problema.

Por padrão, uma requisição AJAX via Seam Remoting não possui controle de transações e o contexto JSF não é criado. Para ambos os casos é possível habilitá-los. O controle de transações é mais simples, basta adicionar a anotação @Transactional com o tipo REQUIRED. Veja o exemplo:

@WebRemote @Transactional(TransactionPropagationType.REQUIRED)
public void updateUserProfile(Profile profile) {
entityManager.merge(profile);
}

Criar o contexto JSF exige algo um pouco mais avançado. Antes de iniciar a execução das ações, o contexto JSF deve ser criado, e para a sua criação é preciso o HttpServletRequest e o HttpServletResponse. Uma forma seria criando um filtro, mas acredito que não é uma boa solução. O Seam possui um recurso de ExecutionHandler que permite executar determinadas operações em requisições Remoting antes executar a ação. Este recurso usa o padrão Observer, onde o primeiro passo é criar o observer, ele precisa de implementar a interface ExecutionHandler:

public class RemotingFacesContextHandler extends ExecutionHandler {

private ServletContext servletContext;

protected FacesContext getFacesContext(HttpServletRequest request,
HttpServletResponse response) {

FacesContext facesContext = FacesContext.getCurrentInstance();

if (facesContext == null) {
FacesContextFactory contextFactory = (FacesContextFactory) FactoryFinder.getFactory(FactoryFinder.FACES_CONTEXT_FACTORY);
LifecycleFactory lifecycleFactory = (LifecycleFactory) FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
Lifecycle lifecycle = lifecycleFactory.getLifecycle(LifecycleFactory.DEFAULT_LIFECYCLE);
facesContext = contextFactory.getFacesContext(servletContext,request, response, lifecycle);
}

return facesContext;
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response)
throws Exception {
getFacesContext(request, response);
super.handle(request, response);
}
@Override
public void setServletContext(ServletContext ctx) {
this.servletContext = ctx;
super.setServletContext(ctx);
}
}

O método handle chama o método getFacesContext que é responsável por iniciar o contexto. A inicialização do FacesContext é feita por meio do método getFacesContext da classe FacesContextFactory. Além do contexto servlet, do request e do response, é necessário informar o ciclo de vida JSF.O Ciclo de vida é criado por meio da classe LifecycleFactory.

Uma vez criado o observer, basta registrá-lo. Uma das várias alternativas é registrá-lo após a inicialização usando a anotação @Observe:

@Name("registerHandler")
public class RegisterFacesContextHandler {
private static final String REQUEST_PATH_EXECUTE = "/execute";

@Observer("org.jboss.seam.postInitialization")
public void initHandler() {
RequestHandlerFactory.getInstance().registerHandler(REQUEST_PATH_EXECUTE, new RemotingFacesContextHandler());

}

}

Após inicializado o Seam (org.jboss.seam.postInitialization) o observer é registrado. Com isto você pode chamar FacesContext.getCurrentInstance() que não receberá aquele NullPointerException indesejado.

Nas versões anteriores, o componente para as páginas de listagens sobrescreviam os métodos:
- getEjbql: Consulta EJB QL usada para a listagem.
- getMaxResults: Define a quantidade de registros a serem retornados pela listagem.
- getRestrictions: Retorna lista de restrições a serem adicionadas a consulta.

Porém na versão 2.1 estes métodos deixaram de ser usados na geração do código. O problema é que o método getRestrictions teve o retorno aterado. Nas versões anteriores ele retornava uma lista de Strings, já na versão 2.1 o tipo de retorno foi alterado para uma lista de ValueExpression.

Com isto um código gerado na versão na versão 2.0.3, por exemplo, gera ClassCastException ao tentar converter String em ValueExpression. Solução? Atualizar o código, veja o antes e o depois:

@Name("userList")
public class UserList extends EntityQuery {

private static final String[] RESTRICTIONS = {
"lower(user.login) like concat(lower(#{userList.user.login}),'%')",
"lower(user.name) like concat(lower(#{userList.user.name}),'%')"};

private final User user = new User();
@Override
public String getEjbql() {
return "select user from User user";
}

@Override
public Integer getMaxResults() {
return 25;
}

public User getUser() {
return user;
}

@Override
public List<string> getRestrictions() {
return Arrays.asList(RESTRICTIONS);
}

}

A versão 2.1 o código gerado é algo semelhante a:

@Name("userList")
public class UserList extends EntityQuery<user> {

private static final String EJBQL = "select user from User user";

private static final String[] RESTRICTIONS = {
"lower(user.login) like concat(lower(#{userList.user.login}),'%')",
"lower(user.name) like concat(lower(#{userList.user.name}),'%')"};

private final User user = new User();

public UserList() {
setRestrictionExpressionStrings(Arrays.asList(RESTRICTIONS));
setMaxResults(25);
setEjbql(EJBQL);
}

public User getUser() {
return user;
}
}

Até que seja corrigido o problema fica a dica.

Esta semana foi publicada a edição 22 Web Mobile com uma matéria minha sobre o Jboss Seam, “Seam Framework: Simplificando o desenvolvimento Java Web”. Este artigo fala dos fundamentos e dos principais recurso do Jboss Seam.

No início do artigo foi abordado o Core do framework, com uma visão de como são tratados os componentes Seam, e de como é realizada o controle de transações e injeção de dependências.

Foram abordados também os contextos, o conceito de PageActions e a integração com WebServices. Por fim listei alguns recursos extras que deixa o Seam ainda mais competitivo.

A parte 8, faz a introdução do Seam Remoting. São mostradas as configurações necessárias e a forma de acesso a componentes SEAM. O Seam Remoting é uma forma eficiente acessar componentes SEAM usando AJAX, permitindo ao desenvolvedor resolver problemas que os componentes disponíveis no mercado não atendem. Para utilizá-lo é facil, basta apenas ter o SeamResourceServlet configurado e basta chamar os arquivos javascript ou usar a tag remote para usar os componentes, veja o exemplo:

<script type="text/javascript" src="seam/resource/remoting/resource/remote.js"></script>
<script type="text/javascript" src="seam/resource/remoting/interface.js?newsHome&amp;usersHome"></script>
<!-- Mesmo resultado em relação as 2 linhas anteriores-->
<s :remote include="newsHome,usersHome"/>

A parte 9 aborda uma feature interessante, a resolução de EL. Como uma expression language é resolvida durante a rendereização da página, para usar este recurso é preciso usar a função dentro fora da página em um arquivo Javascript. Depois é só chamar a função da seguinte forma:

Seam.Remoting.eval("#{newsHome.relatedNews}", newsCallback);
// callback function
function newsCallback(newsList) {
// read news
var area = document.getElementById("relatedNews");
for (var i = 0; i < newsList.length; i++) {
var news = newsList[i];
var span = document.createElement("span");
span.innerHTML = "<h4><a href='ViewNews.seam?newsId=" + news.getId() + "'>" +
news.getTitle() + "</a>" + news.getDescription();
area.appendChild(span);
}
}

A última vídeo aula da série mostrará chamadas em lote e a utilização de classes que não são componentes SEAM.

Parte 8
Parte 9

Arquivos Fontes

Para quem gera documentos excel, tenho uma boa notícia, agora facilmente será possível criar documentos XLS utilizando um módulo específico do Seam para isto. Integrado ao JExcelAPI, o módulo possibilita gerar planilhas com um simples documento XHTML de maneira bem semelhante ao geração de PDF, que já abordada anteriomente.

A criação de URL User Friendly agora tem suporte buit in ao URL Rewriter sem contar o suporte a JAX-RS através do suporte ao RESTeasy. A parte Core sofreu várias melhorias com melhor suporte a Cache e principalmente o suporte a chamadas simultâneas dentro de um mesmo escopo de conversação.

A melhoria da performance e escalabilidade terão destaque para o próximo release. A documentação para clustering está sendo preparada para usar juntamente com o Jboss Clustering. Há também rumores que nos próximos realeases o suporte ao OpenID já estará disponível.

A parte 6, mostra todos os passos para enviar e-mails usando o módulo de integração do Seam Framework com a JavaMail. O Seam Framework possui um gerenciador de envio de e-mails e para usá-lo é bastante simples. Vejo sempre em fóruns a dificuldade que usuários tem para enviar e-mails usando uma conta SMTP do google, porém o Seam oferece diversas facilidades para configuração. O código abaixo configura o envio de e-mails usando uma conta do Google.

<mail :mail-session host="smtp.gmail.com" port="587" username="testes@marcossousa.com" password="java2008." ssl="false" tls="true"/>

Para configurar a mensagem é bem simples, basta criar um arquivo XHTML usando as tags m:message. Nos fontes há o exemplo demonstrado na vídeoaula.

Já a parte 7 aborda outro tópico interessante, a utilização de CAPTCHA. O Seam oferece uma solução básica, que gera imagens usando representação de somas simples. Na vídeo eu mostro como customizar a classe para gerar imagens mais complexas, no exemplo criado gera códigos alfanuméricos de 6 caracteres. Por padrão, basta apenas configurar o Seam Resource Servlet e usar o código abaixo:

<s :decorate id="verification">
<h :graphicImage value="/seam/resource/captcha" id="captchaimg" />
<h :inputText value="#{captcha.response}"  required="true" id="verify">
<s :validate></s>
<a :support event="onblur" reRender="verification" bypassUpdates="true" ajaxSingle="true"></a>
</h>
</s>

As próximas vídeo aulas da série abordarão as funcionalidades do Seam Remoto.

Parte 6
Parte 7

Arquivos Fontes

Esta parte mostra um passo-a-passo para criar documentos em PDF usando o módulo de integração do Seam Framework com o iText. Na vídeo aula, são apresentadas algumas das tags descritas na publicação Gere PDF de Qualidade em 10 minutos, o documento resultante gera um PDF que contém imagens, títulos, texto HTML formatado e um rodapé contendo texto e numeração.

As próximas vídeo aulas abordarão o envio de e-mails, CAPTCHA e agendamento de tarefas.

Arquivos Fontes
Vídeo aula

Nesta parte não foi demonstrado nenhum recurso especial do Seam Framework, porém foi demonstrado o uso do componente input suggestion.

Link da Vídeo Aula
Arquivos fontes

As próximas partes abordarão a geração de PDF e envio de e-mails.

A primeira vídeo aula aborda a criação e configuração da aplicação. É criado o banco de dados, criação dos formulários e aplicado restrições de acesso a pasta dos cadastros de usuários, tags, anexos e notícias.

A segunda parte aborda a criação de uma classe de criptografia MD5, criptografia e validação de senhas no cadastro de usuário e customização da classe de autenticação de usuários usada pelo Seam Framework.

Por fim a terceira parte abordou a implementação do código necessário para fazer upload de arquivos usando o componente do RichFaces rich:fileUpload. No exemplo, foi limitado o tamanho máximo de arquivos, o tipo do arquivo (apenas imagens) e implementado a ação de modo que salvasse a imagem no Banco de Dados usando o Hibernate. Por fim foi apresentado também como pode ser realizado a exibição de imagens usando o a4j:mediaOutput.

As próximas vídeo aulas mostrarei a implementação do recurso de autocompletar, semelhante ao WordPress, e mostrarei também a geração de PDF e Envio de e-mails. Vale a pena conferir!

Basicamente para usar em um projeto Seam, basta adicionar a lib do itext e a lib de intregração jboss-seam.jar. Feito isto, basta criar páginas xhtml que use as tags de geração de arquivos PDF. Uma das opções que mais me chamaram a atenção foi a possibilidade de adicionar código html, algo que estava procurando para impressão de campos que usam o formato RichText. Outra coisa que me chamou a atenção foi a velocidade, um mesmo PDF que era gerado usando iReports levou um bom tempo a mais do que o gerando usando o Seam. As opções básicas como cabeçalho, rodapé e quebra de página estão presentes.

Tudo que é preciso fazer é criar uma página xhtml usando a tag p:document com o namespace http://jboss.com/products/seam/pdf:

<p :document xmlns:p="http://jboss.com/products/seam/pdf">
  <!-- Coloque aqui o conteúdo do documento -->
</p>

A tag de paragraph permite a criação de parágrafos de forma semelhante ao um documento HTML, para exibir um dado de uma EL JSF há três maneiras básicas: Colocar a EL direto no texto, usar o componente JSF padrão h:outputText ou ainda usar o componente do Seam p:text. Veja o exemplo:

<p :paragraph>
    Olá #{user.name}, você foi registrado com sucesso, seu login é <h  utputText value="#{user.login}" /> e seu último acesso foi em: </p><p :text value="#{user.lastAcess}">
        <f :convertDateTime pattern="dd/MM/yyyy HH:mm" />
    </p>

E não podia deixar de destacar, também deixar de destacar a habilidade do Seam de renderizar código HTML através da tag p:html:

<p :html>
    <h1>Título 1 em html</h1>
    <table>
        <th>
              <td>Título 1</td>
              <td>Título 2</td>
        </th>
        <tr>
              <td>Linha 1</td>
              <td>Linha 1</td>
        </tr>
        <tr>
              <td>linha 2</td>
              <td>Linha 2</td>
        </tr>
    </table>
    <ul>
        <li>Item 1</li>
        <li>Item 2</li>
        <li>Item 3</li>
    </ul>
</p>

Caso se interesse pelo assunto, sugiro acessar o Guia de Referência.