Spring, Hibernate y una fuente de datos JNDI

Programación

1. Información general

En este artículo, crearemos una aplicación Spring usando Hibernate / JPA con una fuente de datos JNDI.

Si desea redescubrir los conceptos básicos de Spring e Hibernate, consulte este artículo.

2. Declaración de la fuente de datos

2.1. Sistema

Como estamos usando una fuente de datos JNDI, no la definiremos en nuestra aplicación, la definiremos en nuestro contenedor de aplicaciones.

En este ejemplo, usaremos la versión 8.5.x de Tomcat y la versión 9.5.x de la base de datos PostgreSQL.

Debería poder replicar los mismos pasos utilizando cualquier otro contenedor de aplicaciones Java y una base de datos de su elección (¡siempre que tenga los archivos JDBC adecuados para ello!)

2.2. Declaración de la fuente de datos en el contenedor de la aplicación

Declararemos nuestra fuente de datos en el archivo / conf / server.xml dentro del elemento.

Suponiendo que el servidor de la base de datos se está ejecutando en la misma máquina que el contenedor de la aplicación, y que la base de datos deseada se llama postgres , y que el nombre de usuario es baeldung con la contraseña pass1234 , un recurso se vería así:

Tenga en cuenta que hemos denominado nuestro recurso jdbc / BaeldungDatabase . Este será el nombre que se utilizará al hacer referencia a esta fuente de datos.

También tuvimos que especificar su tipo y el nombre de clase del controlador de la base de datos. Para que funcione, también debe colocar el jar correspondiente en / lib / (en este caso, el jar JDBC de PostgreSQL).

Los parámetros de configuración restantes son:

  • auth = "Contenedor" : significa que el contenedor iniciará sesión en el administrador de recursos en nombre de la aplicación
  • maxTotal, maxIdle y maxWaitMillis : son los parámetros de configuración de la conexión del grupo

También debemos definir un ResourceLink dentro delelemento en / conf / context .xml, que se vería así:

Tenga en cuenta que estamos usando el nombre que definimos en nuestro recurso en server.xml .

3. Uso del recurso

3.1. Configuración de la aplicación

Vamos a definir una aplicación simple Spring + JPA + Hibernate usando una configuración pura de Java ahora.

Comenzaremos definiendo la configuración del contexto de Spring (tenga en cuenta que aquí nos estamos enfocando en JNDI y asumiendo que ya conoce los conceptos básicos de la configuración de Spring):

@Configuration @EnableTransactionManagement @PropertySource("classpath:persistence-jndi.properties") @ComponentScan("com.baeldung.hibernate.cache") @EnableJpaRepositories(basePackages = "com.baeldung.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 }

Tenga en cuenta que tenemos un ejemplo completo de la configuración en el artículo Spring 4 y JPA con Hibernate.

Para crear nuestro bean dataSource , necesitamos buscar el recurso JNDI que definimos en nuestro contenedor de aplicación. Almacenaremos esto en la clave persistence-jndi.properties (entre otras propiedades):

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

Tenga en cuenta que en la propiedad jdbc.url estamos definiendo un nombre raíz para buscar: java: comp / env / (estos son valores predeterminados y corresponden al componente y al entorno) y luego el mismo nombre que usamos en server.xml : jdbc / BaeldungDatabase .

3.2. Configuración JPA: modelo, DAO y servicio

Vamos a usar un modelo simple con la anotación @Entity con una identificación generada y un nombre :

@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 }

Definamos un repositorio simple:

@Repository public class FooDao { @PersistenceContext private EntityManager entityManager; public List findAll() { return entityManager .createQuery("from " + Foo.class.getName()).getResultList(); } }

Y por último, creemos un servicio simple:

@Service @Transactional public class FooService { @Autowired private FooDao dao; public List findAll() { return dao.findAll(); } }

Con esto, tiene todo lo que necesita para usar su fuente de datos JNDI en su aplicación Spring.

4. Conclusión

En este artículo, hemos creado una aplicación Spring de ejemplo con una configuración JPA + Hibernate que trabaja con una fuente de datos JNDI.

Tenga en cuenta que las partes más importantes son la definición del recurso en el contenedor de la aplicación y la búsqueda del recurso JNDI en la configuración.

Y, como siempre, el proyecto completo se puede encontrar en GitHub.