TOC

Spring, Hibernate e uma fonte de dados JNDI

Spring, Hibernate e uma fonte de dados JNDI

1. Visão geral

Neste artigo, criaremos um aplicativo Spring usando Hibernate / JPA com uma fonte de dadosJNDI.

Se você quiser redescobrir o básico do Spring e do Hibernate, verifiquethis article.

2. Declarando a fonte de dados

2.1. Sistema

Como estamos usando uma fonte de dados JNDI, não vamos defini-la em nosso aplicativo, vamos defini-la em nosso contêiner de aplicativo.

Neste exemplo, vamos usar a versão 8.5.x deTomcate a versão 9.5.x do banco de dadosPostgreSQL.

Você deve ser capaz de replicar as mesmas etapas usando qualquer outro contêiner de aplicativo Java e um banco de dados de sua escolha (desde que você tenha jarros JDBC adequados!).

2.2. Declarando a fonte de dados no contêiner do aplicativo

Declararemos nossa fonte de dados no arquivo<tomcat_home>/conf/server.xml dentro do elemento<GlobalNamingResources>.

Supondo que o servidor de banco de dados está sendo executado na mesma máquina que o contêiner do aplicativo, e que o banco de dados pretendido se chamapostgres, e que o nome de usuário éexample com senhapass1234, um recurso parece com isso:

Observe que nomeamos nosso recursojdbc/exampleDatabase. Esse será o nome a ser usado ao fazer referência a essa fonte de dados.

Também tivemos que especificar o tipo e o nome da classe do driver de banco de dados. Para que funcione, você também deve colocar o jar correspondente em<tomcat_home>/lib/ (neste caso, o jar JDBC do PostgreSQL).

Os parâmetros de configuração restantes são:

  • auth=”Container” - significa que o contêiner se conectará ao gerenciador de recursos em nome do aplicativo

  • maxTotal, maxIdle, emaxWaitMillis - são os parâmetros de configuração da conexão do pool

Devemos também definir umResourceLink dentro do elemento<Context> em<tomcat_home>/conf/context.xml, que se pareceria com:

Observe que estamos usando o nome que definimos em nossoResource emserver.xml.

3. Usando o recurso

3.1. Configurando o aplicativo

Vamos definir um aplicativo Spring + JPA + Hibernate simples usando a configuração Java pura agora.

Vamos começar definindo a configuração do contexto do Spring (tenha em mente que estamos nos concentrando no JNDI aqui e assumindo que você já conhece os fundamentos da configuração do Spring): 

@Configuration
@EnableTransactionManagement
@PropertySource("classpath:persistence-jndi.properties")
@ComponentScan("com.example.hibernate.cache")
@EnableJpaRepositories(basePackages = "com.example.hibernate.cache.dao")
public class PersistenceJNDIConfig {

    @Autowired
    private Environment env;

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory()
      throws NamingException {
        LocalContainerEntityManagerFactoryBean em
          = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource());

        // rest of entity manager configuration
        return em;
    }

    @Bean
    public DataSource dataSource() throws NamingException {
        return (DataSource) new JndiTemplate().lookup(env.getProperty("jdbc.url"));
    }

    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }

    // rest of persistence configuration
}

Observe que temos um exemplo completo da configuração no artigoSpring 4 and JPA with Hibernate.

Para criar nosso beandataSource, precisamos procurar o recurso JNDI que definimos em nosso contêiner de aplicativo. Vamos armazenar isso na chavepersistence-jndi.properties (entre outras propriedades): 

jdbc.url=java:comp/env/jdbc/exampleDatabase

Observe que emjdbc.url property estamos definindo um nome de raiz para procurar:java:comp/env/ (esses são os padrões e correspondem a componente e ambiente) e, em seguida, o mesmo nome que usamos emserver.xml: jdbc/exampleDatabase.

3.2. Configuração JPA - Modelo, DAO e Serviço

Vamos usar um modelo simples com a anotação@Entity com umide umname gerado: 

@Entity
public class Foo {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "ID")
    private Long id;

    @Column(name = "NAME")
    private String name;

    // default getters and setters
}

Vamos definir um repositório simples: 

@Repository
public class FooDao {

    @PersistenceContext
    private EntityManager entityManager;

    public List findAll() {
        return entityManager
          .createQuery("from " + Foo.class.getName()).getResultList();
    }
}

E, por último, vamos criar um serviço simples: 

@Service
@Transactional
public class FooService {

    @Autowired
    private FooDao dao;

    public List findAll() {
        return dao.findAll();
    }
}

Com isso, você tem tudo o que precisa para usar sua fonte de dados JNDI em seu aplicativo Spring.

4. Conclusão

Neste artigo, criamos um aplicativo Spring de exemplo com uma configuração JPA + Hibernate trabalhando com uma fonte de dados JNDI.

Observe que as partes mais importantes são a definição do recurso no contêiner do aplicativo e a pesquisa do recurso JNDI na configuração.

E, como sempre, o projeto completo pode ser encontradoover on GitHub.

Related