java.lang.IllegalStateException: Two components with the same name and precedence - component name: authenticator, component classes: com.app.security.Authenticator, com.app.security.Authenticator
at org.jboss.seam.init.Initialization.addComponentDescriptor(Initialization.java:596)
at org.jboss.seam.init.Initialization.installScannedComponentAndRoles(Initialization.java:949)
at org.jboss.seam.init.Initialization.scanForComponents(Initialization.java:889)
at org.jboss.seam.init.Initialization.init(Initialization.java:701)
at org.jboss.seam.servlet.SeamListener.contextInitialized(SeamListener.java:35)

Essa exceção pode ocorrer, claro, quando existirem duas classes com o mesmo @Name, ou pode ocorrer num caso mais sutil. O Seam possui um modo de debug em que ele faz hot deploy de páginas Facelets e pages.xml’s. Projetos criados pelo seam-gen já vêm com esse modo habilitado:

<core:init debug="true"/>

Nesse modo o Seam usa um classloader próprio ao invés do classloader do container para carregar as classes. Ele faz isso criando um pasta WEB-INF/dev de onde carrega as classes. Isso não vale para EJB3 (então sem hot deploy de entity beans..) e as classes não serão visíveis para o container ou para outros projetos Seam (já que o Seam usa uma instância própria de classloader).

O problema é que de algum jeito o Seam (na verdade deve ser o JBoss Tools) se confunde em algumas situações e tenta fazer um novo deploy do componente, ao invés de fazer um redeploy. Com isso há um conflito de @Name. Não consegui identificar em que casos exatamente isso ocorre. Fazer um Clean, Build, etc não adianta porque a pasta dev não é mexida.

Bom, para resumir, basta apagar a pasta WEB-INF/dev

Você notará que serão adicionadas várias perspectivas, entre elas, a Seam. Vamos selecionar essa perspectiva e criar um novo Seam Project. Com isso já temos um projeto funcional com segurança, apresentação de erros, e conexão com banco de dados. Também é criado um projeto <projeto>-Test para testes. Vamos entender um pouco do que nos foi gerado.

1. classe usada pelo Seam para autenticação
2. arquivo chave. Indica ao Seam que ele deve procurar nesse diretório por componentes
3. persistence.xml do JPA
4. arquivo com algumas propriedados a serem substituidas pelo Ant no components.xml
5. import.sql do Hibernate
6. mensagens para internacionalização
7. arquivo Drools com regras de autorização
8. datasource gerado para o JBoss
9. arquivo de configuração do Seam (componentes, integração)
10. arquivo de configuração WAR do JBoss
11. arquivo de configuração do Seam (regras de fluxo, segurança, controle de conversação)
12. similar ao arquivo pages.xml, mas específico para o login.xhtml
13. arquivo de configuração do plugin Hibernate Console

Vamos ver por alto algumas configurações interessantes. Na parte de segurança temos no components.xml:

<event type="org.jboss.seam.security.notLoggedIn">
<action execute="#{redirect.captureCurrentView}"/>
</event>
<event type="org.jboss.seam.security.loginSuccessful">
<action execute="#{redirect.returnToCapturedView}"/>
</event>

O Seam possui o conceito de eventos. Eventos são mensagens que podem ser capturadas ou lançadas, no estilo broadcast. O Seam em si lança vários eventos e podemos capturar esses eventos através de XML, como no exemplo acima. O trecho acima está invocando métodos do componente built-in #{redirect} quando eventos de segurança forem lançados. Ele especifica que a view id JSF deve ser salva quando o usuário não-logado tentar acessar uma página restrita e que essa view id deve ser restaurada uma vez que ele se autentique.
Um outro trecho especifica que componente é responsável pela autenticação:

<security:identity authenticate-method="#{authenticator.authenticate}"
security-rules="#{securityRules}"
remember-me="true"/>

E no pages.xml dizemos que página deve ser utilizada para login:

<exception class="org.jboss.seam.security.NotLoggedInException">
<redirect view-id="/login.xhtml">
<message>Please log in first</message>
</redirect>
</exception>

Aqui temos um tratamento de exceção bem parecido com o de servlets que definimos no web.xml. O usuário será redirecionado para a página login.xhtml e uma mensagem JSF será adicionada.
Se olharmos no login.pages.xml vemos ainda:

<navigation from-action="#{identity.login}">
<rule if="#{identity.loggedIn}">
<redirect view-id="/home.xhtml"/>
</rule>
</navigation>

O que nos lembra bastante as navigation rules JSF. De fato parecem muito, mas as extendem em funcionalidade, podendo não só enviar o usuário para outra página como também lançar um evento, executar um método para avaliar qual será a próxima página, e algumas coisas mais avançadas.

O objetivo desse post é apenas nos familiarizar mais com o Seam e dar uma visão sobre o scaffold que nos foi gerado de base e que iremos usar para desenvolver nossa aplicação. Ainda vamos falar com mais detalhes de eventos, componentes e configurações.

Seam é um framework muito amplo. Pegue alguns dos frameworks mais representativos, ponha algumas práticas de desenvolvimento e misture: assim que vejo o Seam. O Seam em sua plenitude usa os frameworks: EJB3, JSF, Facelets, Hibernate, Hibernate Validations, Richfaces, Ajax4JSF, jBPM, Drools (qualquer associação ao nome JBoss é mera coincidência). É muita coisa. Mas ele não só usa esses frameworks, ele também provê uma integração entre eles, disponibiliza componentes built-in (à la Spring, cujo qual inclusive pode-se integrar) e introduz algumas melhorias sobre eles. Além disso ele apregoa algumas práticas como desenvolvimento orientado a componentes e desencoraja outras, como desenvolvimento em camadas.

Vou deixar de lado o que cada framework faz, pois não entra no mérito do que o Seam tem a oferecer. Dando um enfoque bem prático, o Seam:

• Reduz plumbing code do JSF. Quem já programou com JSF sabe do que estou falando (Não? FacesContext? faces-config.xml?).
• Resolve o infame problema do “back button” em JSF. E reload, e bookmarking, e …
• Facilita o uso de JPA. Tem um código cheio de merges()? Usa uma long-running transaction num page flow?
• Possibilita page flows usando o jBPM.
• Permite aplicações multi-windows. E finalmente poder clicar “Abrir em nova janela” nos links!
• Permite o uso de workspaces. Como no Linux.
• Faz uso extensivo de anotações. Mas também permiti o uso de XML.
• Possui uma penca de tags JSF. Uns muito úteis, uns bem exóticos…
• E muito mais!

Dada essa introdução, vou detalhar nos próximos posts cada um desses itens dizendo como realizamos eles com o uso so Seam. Esse blog não é sobre Seam, então esperem outros posts no meio. Até mais!

referência: http://docs.jboss.com/seam/latest/reference/en-US/html/Book-Preface.html

Quem está começando a aprender JBoss Seam pode ter a impressão que ele roda apenas no JBoss AS, o que não é verdade. Devido à maioria da documentação ser provida pelo pessoal do JBoss é claro que tudo é feito tendo-se em mente o AS deles. Mesmo quem sabe ser possível rodar sobre outros ASs, muitas vezes não tem idéia de como fazê-lo.

O Seam em si não é um serviço no JBoss, mas sim um framework, o que possibilita sua utilização em vários ASs. Caso não seja usada nenhuma facilidade EE (ou mesmo algumas que o Seam cobre), é possível fazer o deploy de uma aplicação Seam até mesmo sobre um simples container web como o Tomcat e esse post sobre esse caso.

Sendo o Seam uma biblioteca, dificuldades em fazer deploy em containers se limitam a conflitos e dependências. Mas quem já usou Seam sabe da grande mão na roda que é o seam-gen para geração de scaffold (inclusa no JBoss Tools). O problema é que o scaffold gerado é feito para o JBoss.

Então nossos esforços serão basicamente mudar configurações do JBoss para o Tomcat e passar para o Seam o tratamento de features enterprise. As instruções são para o seguinte ambiente:

• Eclipse 3.3.2 com JBoss Tools 2.1.1.GA
• JBoss Seam 2.0.3.CR1
• Apache Tomcat 6.0.16

Vamos lá:

1. Já que estamos rodando num container web não temos o controle transacional provido pelo AS, então devemos passá-lo para o Seam.

No persistence.xml alteramos o transaction-type da persistence-unit para RESOURCE_LOCAL e removemos a property hibernate.transaction.manager_lookup_class. Vamos mudar também a linha do data source, para utilizar ENC. Ela deve refletir:

<non-jta-data-source>java:comp/env/jdbc/meuDatasource</non-jta-data-source>

Note que aqui perdemos a possibilidade de transações distribuídas.

2. Vamos definir agora no components.xml que o Seam será responsável pelo controle transcional. Adicionamos a seguinte linha:

<transaction:entity-transaction entity-manager="#{entityManager}"/>

Onde #{entityManager} é o nome da managed-persistence-context, que é o persistence context que será usado pelo Seam nas conversações. A definição do namespace:

xmlns:transaction="http://jboss.com/products/seam/transaction"
xsi:schemaLocation="http://jboss.com/products/seam/transaction http://jboss.com/products/seam/transaction-2.0.xsd"

3. Para finalizarmos com essa parte de persistência falta apenas criar o próprio datasource. Quem usa o Sysdeo deve ir nas propriedades do Tomcat Project fazer isso, mas quem usa o WTP (usem!) não tem essa opção. Ao invés disso podemos usar o esquema de deploy de contexto do Tomcat. Crie um arquivo context.xml em seu WEB-INF/META-INF contendo seu data source. No meu caso:

<?xml version="1.0" encoding="UTF-8"?>
<context>
<resource name="jdbc/meuDatasource" type="javax.sql.DataSource" driverClassName="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:meuBD" username="sa" password="" auth="Container" maxActive="20" maxIdle="5" maxWait="10000"/>
</context>

4. Por último temos que adicionar as seguintes bibliotecas que não vêm no Tomcat:

persistence-api.jar
hibernate.jar
hibernate-entitymanager.jar
hibernate-validator.jar
hibernate-annotations.jar
dom4j.jar
jta.jar
hibernate-commons-annotations.jar
cglib-nodep.jar
antlr.jar
jboss-common-core.jar

jsf-api.jar
jsf-impl.jar

commons-logging-1.1.1.jar
commons-collections-3.2.1.jar
javassist.jar

A maioria delas pode ser achada na pasta lib do Seam. No meu caso criei uma User Libraries e as marquei como dependência para a Web Library, assim organizo meus jars e torno mais fácil a adição desses frameworks em projetos futuros.

Assumi que se sabe somo criar um projeto Seam. Deixei a idéia de um tutorial básico de lado, quero ainda falar do uso do JBoss Tools para geração de código e um pouco da integração com o Drools e com o jBPM (muito interessante!!).

Dêem o feedback sobre o que querem ler! Que se houver muita manifestação de interesse faço um post, até se for o caso, sobre o gorado tutorial ou o passo-a-passo para a criação de um projeto Seam.

referência: Edem Morny’s Tech Blog

Tive a primeira aula ontem e me pareceu ter idéias muito interessantes. Os não tão atuais esforços de padronizar a idéia do Seam sobre a JSR 299 (Web Beans) deverão dar um maior impulso e maior adesão ao Seam. Vejo vários indícios de um futuro próspero para esse framework.

Acabado o curso pretendo dar um overview sobre o Seam e quem sabe fazer um tutorial ao longo de vários posts. Aguardem!