1. Overview

In this article, we’ll create a Spring application using Hibernate/JPA with a JNDI datasource.

If you want to rediscover the basics of Spring and Hibernate, check out this article.

2. Declaring the Datasource

2.1. System

Since we’re using a JNDI datasource, we won’t define it in our application, we’ll define it in our application container.

In this example, we’re going to use 8.5.x version of Tomcat and the 9.5.x version of the PostgreSQL database.

You should be able to replicate the same steps using any other Java application container and a database of your choice (as long as you have proper JDBC jars for it!).

2.2. Declaring the Datasource on the Application Container

We’ll declare our datasource in <tomcat_home>/conf/server.xml file inside the <GlobalNamingResources> element.

Assuming that the database server is running on the same machine as the application container, and that the intended database is named postgres, and that the username is baeldung with password pass1234, a resource would look like this:

<Resource name="jdbc/BaeldungDatabase" 

Take note that we’ve named our resource jdbc/BaeldungDatabase. This will be the name to be used when referencing this datasource.

We’ve also had to specify its type and database driver’s class name. For it to work, you must also place the corresponding jar in <tomcat_home>/lib/ (in this case, PostgreSQL’s JDBC jar).

Remaining configuration parameters are:

  • auth=”Container” – means that the container will be signing on to the resource manager on behalf of the application
  • maxTotal, maxIdle, and maxWaitMillis – are pool connection’s configuration parameters

We must also define a ResourceLink inside the <Context> element in <tomcat_home>/conf/context.xml, which would look like:


Note that we are using the name we defined in our Resource in server.xml.

3. Using the Resource

3.1. Setting the Application

We’re going to define a simple Spring + JPA + Hibernate application using pure Java config now.

We’ll start by defining the Spring context’s configuration (keep in mind that we are focusing on JNDI here and assuming that you already know the basics of Spring’s configuration):

@EnableJpaRepositories(basePackages = "com.baeldung.hibernate.cache.dao")
public class PersistenceJNDIConfig {

    private Environment env;

    public LocalContainerEntityManagerFactoryBean entityManagerFactory() 
      throws NamingException {
        LocalContainerEntityManagerFactoryBean em 
          = new LocalContainerEntityManagerFactoryBean();
        // rest of entity manager configuration
        return em;

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

    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        return transactionManager;

    // rest of persistence configuration

Note that we have a full example of the configuration in the Spring 4 and JPA with Hibernate article.

In order to create our dataSource bean, we need to look for the JNDI resource we defined at our application container. We’ll store this in persistence-jndi.properties key (among other properties):


Note that in the jdbc.url property we’re defining a root name to look for: java:comp/env/ (this are defaults and correspond to component and environment) and then the same name we used in server.xml: jdbc/BaeldungDatabase.

3.2. JPA Configuration – Model, DAO and Service

We’re going to use a simple model with the @Entity annotation with a generated id and a name:

public class Foo {

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

    // default getters and setters

Let’s define a simple repository:

public class FooDao {

    private EntityManager entityManager;

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

And lastly, let’s create a simple service:

public class FooService {

    private FooDao dao;

    public List<Foo> findAll() {
        return dao.findAll();

With this, you have everything you need in order to use your JNDI datasource in your Spring application.

4. Conclusion

In this article, we’ve created an example Spring application with a JPA + Hibernate setup working with a JNDI datasource.

Note that the most important parts are the definition of the resource in the application container and the lookup for the JNDI resource on the configuration.

And, as always, the full project can be found over on GitHub.

Course – LSD (cat=Persistence)

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

res – Persistence (eBook) (cat=Persistence)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.