Configurando o Spring (II)

Este post faz parte de uma série sobre Spring, JPA e JSF. Caso algum assunto abordado aqui não esteja claro, consulte este link: Spring + JPA.

Continuando o post anterior, vou mostrar agora o arquivo web-application-config.xml. Tive alguns problemas com a localização do arquivo, o que foi resolvido mantendo o seguinte padrão: os arquivos de configuração do Spring referenciados no arquivo web.xml devem ser sempre colocados em uma subpasta /WEB-INF/classes. Observe na imagem abaixo:

O conteúdo do arquivo é bem simples:

<?xml version="1.0" encoding="UTF-8"?><br/><beans xmlns="http://www.springframework.org/schema/beans"<br/>       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br/>       xmlns:context="http://www.springframework.org/schema/context"<br/>       xsi:schemaLocation="<br/>           http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br/>           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"<br/>       default-autowire="byName"><br/>    <context:component-scan base-package="configuracao" /><br/>    <import resource="security-config.xml" /><br/></beans>

Uma atenção especial para as linhas 9 e 10:

Na linha 9, é declarado um pacote onde o Spring vai procurar por arquivos de configuração, que mostrarei logo a seguir.

Na linha 10, é declarado um arquivo de configuração para autenticação, que será mostrado em outro post. Se não houver necessidade de autenticação, ou se for preciso testar o projeto inicialmente sem preocupação com autorização de acesso, esta linha pode ser temporariamente comentada.

Seguindo a declaração da linha 9, o projeto deve ter um pacote chamado "configuracao":

Neste pacote foi criada uma classe AppConfig.java, que substitui a implementação xml da configuração do Spring. Qual a vantagem disso? É que um arquivo de classe pode ser facilmente reaproveitado em um projeto novo, simplesmente criando um arquivo jar.

Vamos analisar rapidamente a classe AppConfig:

package configuracao;

import java.io.Serializable;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.jndi.JndiObjectFactoryBean;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.support.SharedEntityManagerBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.jta.JtaTransactionManager;

@Configuration
@EnableTransactionManagement
@ComponentScan(basePackages = { "controle", "dao", "delegate", "entidades", "service"})
public class AppConfig implements Serializable {

    @Bean @Scope(value="singleton")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
        bean.setPersistenceUnitName("PU");
        return bean;
    }

    @Bean @Scope(value="singleton")
    public SharedEntityManagerBean jpaTemplate() {
        SharedEntityManagerBean bean = new SharedEntityManagerBean();
        bean.setEntityManagerFactory(entityManagerFactory().getObject());
        return bean;
    }

    @Bean @Scope(value="singleton")
    public JtaTransactionManager transactionManager() {
        JtaTransactionManager bean = new JtaTransactionManager();
        return bean;
    }

    @Bean @Scope(value="singleton")
    public JndiObjectFactoryBean fonteDeDados() {
        JndiObjectFactoryBean bean = new JndiObjectFactoryBean();
        bean.setJndiName("java:comp/env/jdbc/fonteDeDados");
        return bean;
    }
}

Novamente, a classe deve ser estudada e o leitor deve buscar na documentação do Spring as explicações para todas as anotações mostradas aqui. Mas vamos destacar as linhas mais importantes da classe:

• Na linha 14, uma anotação que vai sinalizar ao Spring para que use o conteúdo deste arquivo como configuração. Logo em seguida, na linha 16, uma lista com os pacotes onde o Spring deve procurar por classes com anotações. Isto será muito importante quando chegar o momento de construir a camada de acesso aos dados (DAO). É óbvio que os pacotes devem ser criados com os mesmos nomes declarados na linha 16.

• Na linha 22, podemos identificar o nome da unidade de persistência que vai ser utilizada ("PU"). Vamos criar esta unidade de persistência durante a construção da camada de acesso aos dados.

• E nas linhas 40 e 42, podemos ver a mesma referência que foi utilizada na configuração do Spring contida no arquivo web.xml.

Importante: esta configuração é para uso do Spring com Jboss. Há diferenças nas configurações se o servidor de aplicações for TomCat, ou Glassfish. Em um próximo artigo, vou mostrar como configurar o Jboss para este projeto.

No próximo post, a configuração do Spring Security.