Marcos Sousa’s Blog

O SpringFramework também conhecido como Interface 21, anunciou a versão realease 2.5. Esta versão vem focada em anotações, nesta versão o framework atinge seu objetivo: ser o mais flexível possível, a exemplo disto, o poderoso modelo de configuração para Java 1.4 e Java 5.0.

Em anotações a versão suporta as anotações descritas na JSR-250: @PostConstruct, @PreDestroy e @Resource; da  Java EE 5: @WebServiceRef e @EJB. Ela também possui suas próprias anotações: @Autowire, @Repository, @Service, @Controller, @Component. Através destas anotações é possível fazer quase tudo o que é feito nos arquivos de configuração em xml, que foi melhorado.  O suporte aos arquivos de configurações das versões anteriores foi mantido.

O spring 2.5 melhorou o suporte a jsf e agora tem um bom suporte com jsf 1.2 com o DelegatingFacesELResolver.

Mais informações em: http://www.springframework.org/

http://www.springframework.org/download

Um pouco atrasado mas, foi publicado no site da Java Magazine mais uma nova Vídeo Aula sobre JSF desta vez focada em componentes em Ajax.

Nas vídeo-aulas basicamente foi feito a configuração de bibliotecas RichFaces e Ajax4jsf, ajuste nos templates e estilos CSS, alteração dos botões de edição e novo na página de listagem para fazer requisições em ajax permitindo a inclusão e edição de registros na própria página de listagem.

Elas podem ser vistas através dos links:
Ajax em JSF: RichFaces e Ajax4faces - Parte 1
Ajax em JSF: RichFaces e Ajax4faces - Parte 2

No post passado apresentei algumas informações sobre o uso da anotação @Transactional. Neste vou mostrar alguns detalhes que fazem a dirença. Primeiro vamos supor que temos as interfaces:

@Transactional(propagation=Propagation.REQUIRED)
public interface Foo{
void fazAlgumaCoisa() throws FooException;
}

e uma interface que herda de Foo:

public interface Foo2 extends Foo{
void fazOutraCoisa() throws FooException;
}

Neste exemplo podemos chegar as concluções:

1° Que as transações são herdadas apenas para os métodos declarados na interface anotada.

2° Apenas exceções não verificadas gerarão rollback, ou seja, se um FooException for gerada a transação será efetivada. Para uma FooException resultar em rollback a anotação deve estar:
@Transactional(propagation=Propagation.REQUIRED, rollbackFor=FooException.class)

3° Toda implementação das interfaces acima, utilizarão as políticas transações definidas na interfaces, a menos que elas sejam sobrescritas, ou seja, incluindo a anotação @Transactional no método ou na classe.

Bom espero que tenha ajudado um pouco.

Uma das formas de fazer controle de transação no spring é usando a anotação @Transactional, basicamente ela funciona da seguinte forma, primeiro você informa no contexto da aplicação que esta anotação será válida:

<tx:annotation-driven transaction-manager=”transactionManager”/>

Nota: O parâmetro transaction-manager é opcional se o bean que controlará a transação tiver o nome transactionManager.

Agora para definir uma transação basta adicionar a transação ao método, a classe ou na interface. Veja as principais propriedades:

isolation - define como a transação a será controlada, as opções são: DEFAUT, READ_COMMIT, READ_UNCOMMIT e REPEATABLE_READ e SERIALIZABLE.
propagation - Tipo de propagação da transação, se é obrigatória, se requer que uma nova seja criada.
readOnly - não permite que alterações sejam feitas no banco de dados, resolve problema de flush do hibernate.
rollBackFor - arranjo de exceções verificadas que devem gerar roll back.
nonRollBackFor - arranjo de exceções que não devem gerar roll back.

Caso uma classe ou interface seja anotada, e precisa de customizar apenas um método, pode anotar o método a ter a transação customizada, pois, a anotação no método sobrescreve a anotação da classe ou interface.

Na próxima parte falarei de algumas regras e limitações.