How to create JNDI context in Spring Boot with Embedded Tomcat Container

I recently had the requirement to use JNDI with an embedded Tomcat in Spring Boot.
Actual answers give some interesting hints to solve my task but it was not enough as probably not updated for Spring Boot 2.

Here is my contribution tested with Spring Boot 2.0.3.RELEASE.

Specifying a datasource available in the classpath at runtime

You have multiple choices:

• using the DBCP 2 datasource (you don't want to use DBCP 1 that is outdated and less efficient).
• using the Tomcat JDBC datasource.
• using any other datasource: for example HikariCP.

If you don't specify anyone of them, with the default configuration the instantiation of the datasource will throw an exception:

Caused by: javax.naming.NamingException: Could not create resource factory instance at org.apache.naming.factory.ResourceFactory.getDefaultFactory(ResourceFactory.java:50) at org.apache.naming.factory.FactoryBase.getObjectInstance(FactoryBase.java:90) at javax.naming.spi.NamingManager.getObjectInstance(NamingManager.java:321) at org.apache.naming.NamingContext.lookup(NamingContext.java:839) at org.apache.naming.NamingContext.lookup(NamingContext.java:159) at org.apache.naming.NamingContext.lookup(NamingContext.java:827) at org.apache.naming.NamingContext.lookup(NamingContext.java:159) at org.apache.naming.NamingContext.lookup(NamingContext.java:827) at org.apache.naming.NamingContext.lookup(NamingContext.java:159) at org.apache.naming.NamingContext.lookup(NamingContext.java:827) at org.apache.naming.NamingContext.lookup(NamingContext.java:173) at org.apache.naming.SelectorContext.lookup(SelectorContext.java:163) at javax.naming.InitialContext.lookup(InitialContext.java:417) at org.springframework.jndi.JndiTemplate.lambda$lookup$0(JndiTemplate.java:156) at org.springframework.jndi.JndiTemplate.execute(JndiTemplate.java:91) at org.springframework.jndi.JndiTemplate.lookup(JndiTemplate.java:156) at org.springframework.jndi.JndiTemplate.lookup(JndiTemplate.java:178) at org.springframework.jndi.JndiLocatorSupport.lookup(JndiLocatorSupport.java:96) at org.springframework.jndi.JndiObjectLocator.lookup(JndiObjectLocator.java:114) at org.springframework.jndi.JndiObjectTargetSource.getTarget(JndiObjectTargetSource.java:140) ... 39 common frames omitted Caused by: java.lang.ClassNotFoundException: org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory at java.net.URLClassLoader.findClass(URLClassLoader.java:381) at java.lang.ClassLoader.loadClass(ClassLoader.java:424) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331) at java.lang.ClassLoader.loadClass(ClassLoader.java:357) at java.lang.Class.forName0(Native Method) at java.lang.Class.forName(Class.java:264) at org.apache.naming.factory.ResourceFactory.getDefaultFactory(ResourceFactory.java:47) ... 58 common frames omitted 

• To use Apache JDBC datasource, you don't need to add any dependency but you have to change the default factory class to org.apache.tomcat.jdbc.pool.DataSourceFactory.
  You can do it in the resource declaration: resource.setProperty("factory", "org.apache.tomcat.jdbc.pool.DataSourceFactory"); I will explain below where to add this line.

• To use DBCP 2 datasource, a dependency is required:

<dependency> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-dbcp</artifactId> <version>8.5.4</version> </dependency> 

Of course, adapt the artifact version according to your Spring Boot Tomcat embedded version.

• To use HikariCP, add the required dependency if not already present in your configuration (it may be if you rely on persistence starters of Spring Boot) such as:

<dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> <version>3.1.0</version> </dependency> 

and specify the factory that goes with in the resource declaration:

resource.setProperty("factory", "com.zaxxer.hikari.HikariJNDIFactory"); 

Datasource configuration/declaration

You have to customize the bean that creates the TomcatServletWebServerFactory instance.
Two things to do:

• enabling the JNDI naming which is disabled by default

• creating and add the JNDI resource(s) in the server context

For example with PostgreSQL and a DBCP 2 datasource, do that:

@Bean public TomcatServletWebServerFactory tomcatFactory() { return new TomcatServletWebServerFactory() { @Override protected TomcatWebServer getTomcatWebServer(org.apache.catalina.startup.Tomcat tomcat) { tomcat.enableNaming(); return super.getTomcatWebServer(tomcat); } @Override protected void postProcessContext(Context context) { // context ContextResource resource = new ContextResource(); resource.setName("jdbc/myJndiResource"); resource.setType(DataSource.class.getName()); resource.setProperty("driverClassName", "org.postgresql.Driver"); resource.setProperty("url", "jdbc:postgresql://hostname:port/dbname"); resource.setProperty("username", "username"); resource.setProperty("password", "password"); context.getNamingResources() .addResource(resource); } }; } 

Here the variants for Tomcat JDBC and HikariCP datasource.

In postProcessContext() set the factory property as explained early for Tomcat JDBC ds:

@Override protected void postProcessContext(Context context) { ContextResource resource = new ContextResource(); //... resource.setProperty("factory", "org.apache.tomcat.jdbc.pool.DataSourceFactory"); //... context.getNamingResources() .addResource(resource); } 

and for HikariCP:

@Override protected void postProcessContext(Context context) { ContextResource resource = new ContextResource(); //... resource.setProperty("factory", "com.zaxxer.hikari.HikariJNDIFactory"); //... context.getNamingResources() .addResource(resource); } 

Using/Injecting the datasource

You should now be able to lookup the JNDI ressource anywhere by using a standard InitialContext instance:

InitialContext initialContext = new InitialContext(); DataSource datasource = (DataSource) initialContext.lookup("java:comp/env/jdbc/myJndiResource"); 

You can also use JndiObjectFactoryBean of Spring to lookup up the resource:

JndiObjectFactoryBean bean = new JndiObjectFactoryBean(); bean.setJndiName("java:comp/env/jdbc/myJndiResource"); bean.afterPropertiesSet(); DataSource object = (DataSource) bean.getObject(); 

To take advantage of the DI container you can also make the DataSource a Spring bean:

@Bean(destroyMethod = "") public DataSource jndiDataSource() throws IllegalArgumentException, NamingException { JndiObjectFactoryBean bean = new JndiObjectFactoryBean(); bean.setJndiName("java:comp/env/jdbc/myJndiResource"); bean.afterPropertiesSet(); return (DataSource) bean.getObject(); } 

And so you can now inject the DataSource in any Spring beans such as:

@Autowired private DataSource jndiDataSource; 

Note that many examples on the internet seem to disable the lookup of the JNDI resource on startup:

bean.setJndiName("java:comp/env/jdbc/myJndiResource"); bean.setProxyInterface(DataSource.class); bean.setLookupOnStartup(false); bean.afterPropertiesSet(); 

But I think that it is helpless as it invokes just after afterPropertiesSet() that does the lookup !

After all i got the answer thanks to wikisona, first the beans:

@Bean public TomcatEmbeddedServletContainerFactory tomcatFactory() { return new TomcatEmbeddedServletContainerFactory() { @Override protected TomcatEmbeddedServletContainer getTomcatEmbeddedServletContainer( Tomcat tomcat) { tomcat.enableNaming(); return super.getTomcatEmbeddedServletContainer(tomcat); } @Override protected void postProcessContext(Context context) { ContextResource resource = new ContextResource(); resource.setName("jdbc/myDataSource"); resource.setType(DataSource.class.getName()); resource.setProperty("driverClassName", "your.db.Driver"); resource.setProperty("url", "jdbc:yourDb"); context.getNamingResources().addResource(resource); } }; } @Bean(destroyMethod="") public DataSource jndiDataSource() throws IllegalArgumentException, NamingException { JndiObjectFactoryBean bean = new JndiObjectFactoryBean(); bean.setJndiName("java:comp/env/jdbc/myDataSource"); bean.setProxyInterface(DataSource.class); bean.setLookupOnStartup(false); bean.afterPropertiesSet(); return (DataSource)bean.getObject(); } 

the full code it's here: https://github.com/wilkinsona/spring-boot-sample-tomcat-jndi

In SpringBoot 2.1, I found another solution. Extend standard factory class method getTomcatWebServer. And then return it as a bean from anywhere.

public class CustomTomcatServletWebServerFactory extends TomcatServletWebServerFactory { @Override protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { System.setProperty("catalina.useNaming", "true"); tomcat.enableNaming(); return new TomcatWebServer(tomcat, getPort() >= 0); } } @Component public class TomcatConfiguration { @Bean public ConfigurableServletWebServerFactory webServerFactory() { TomcatServletWebServerFactory factory = new CustomTomcatServletWebServerFactory(); return factory; } 

Loading resources from context.xml doesn't work though. Will try to find out.

Please note instead of

public TomcatEmbeddedServletContainerFactory tomcatFactory() 

I had to use the following method signature

public EmbeddedServletContainerFactory embeddedServletContainerFactory() 

In Spring boot v3 it seems that the previous solutions are no more possible.

With Spring documentation I came with this approach:

1. Create a WebServerFactoryCustomizer and create your jndi resource

2. Add in a lifecycle listener to enable naming

3. Add tomcat jdbc dependency

Customizer:

@Component public class MyDatasourceJndiCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> { @Value("${mydatasource.jndi.name}") private String jndiName; @Value("${mydatasource.jndi.driver-class-name}") private String driverClassName; @Value("${mydatasource.jndi.url}") private String url; @Value("${mydatasource.username}") private String username; @Value("${jndi.password}") private String password; @Override public void customize(TomcatServletWebServerFactory server) { server.addContextCustomizers(new TomcatContextCustomizer() { @Override public void customize(Context context) { ContextResource resource = new ContextResource(); resource.setName(jndiName); resource.setType(DataSource.class.getName()); resource.setProperty("driverClassName", driverClassName); resource.setProperty("factory", "org.apache.tomcat.jdbc.pool.DataSourceFactory"); resource.setProperty("url", url); resource.setProperty("username", username); resource.setProperty("password", password); context.getNamingResources() .addResource(resource); } }); enableNaming(server); } private static void enableNaming(TomcatServletWebServerFactory server) { server.addContextLifecycleListeners(new NamingContextListener()); // The following code is copied from Tomcat System.setProperty("catalina.useNaming", "true"); String value = "org.apache.naming"; String oldValue = System.getProperty("java.naming.factory.url.pkgs"); if (oldValue != null) { if (oldValue.contains(value)) { value = oldValue; } else { value = value + ":" + oldValue; } } System.setProperty("java.naming.factory.url.pkgs", value); value = System.getProperty("java.naming.factory.initial"); if (value == null) { System.setProperty("java.naming.factory.initial", "org.apache.naming.java.javaURLContextFactory"); } } } 

Dependency:

 <dependency> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jdbc</artifactId> <version>10.1.9</version> </dependency> 

Have you tried @Lazy loading the datasource? Because you're initialising your embedded Tomcat container within the Spring context, you have to delay the initialisation of your DataSource (until the JNDI vars have been setup).

N.B. I haven't had a chance to test this code yet!

@Lazy @Bean(destroyMethod="") public DataSource jndiDataSource() throws IllegalArgumentException, NamingException { JndiObjectFactoryBean bean = new JndiObjectFactoryBean(); bean.setJndiName("java:comp/env/jdbc/myDataSource"); bean.setProxyInterface(DataSource.class); //bean.setLookupOnStartup(false); bean.afterPropertiesSet(); return (DataSource)bean.getObject(); } 

You may also need to add the @Lazy annotation wherever the DataSource is being used. e.g.

@Lazy @Autowired private DataSource dataSource; 

Had to solve this problem from scratch, because none of the examples that I came across worked for me. Looks like it depends on the configuration of the embedded application...

Goal: legacy application as war file with JNDI resource, run with embedded server.

The snippet below works for both Spring Boot 2 and 3, but be careful because Spring Boot 3 uses Jakarta EE 9 specification (has new top-level jakarta package), which may not be compatible with your application (like in my case).

Main pain points marked with //important:

@Bean public TomcatServletWebServerFactory servletContainerFactory() { return new TomcatServletWebServerFactory() { @Override protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { //add webapp try { //...app preparation here final Context context = tomcat.addWebapp(contextPath, application.getURL()); context.setParentClassLoader(getClass().getClassLoader()); //important: helps the embedded app reach spring boot dependencies } catch (IOException e) { throw new RuntimeException(e); } //configure jndi tomcat.enableNaming(); //important: speaks for itself ContextResource resource = new ContextResource(); resource.setType(DataSource.class.getName()); resource.setName("jdbc/JNDI_NAME_HERE"); resource.setProperty("factory", HikariJNDIFactory.class.getName()); resource.setProperty("jdbcUrl", getUrl()); resource.setProperty("driverClassName", getDriverClassName()); tomcat.getServer().getGlobalNamingResources().addResource(resource); //important: solution for successful jndi lookup return super.getTomcatWebServer(tomcat); } }; } 

Only 3 steps in total and only 2 for jndi specifically.