Jak utworzyć kontekst JNDI w Spring Boot z wbudowanym kontenerem Tomcat

[20]} ostatnio miałem wymóg używania JNDI z wbudowanym Tomcatem w wiosennym bagażniku.
Rzeczywiste odpowiedzi dają kilka ciekawych wskazówek, aby rozwiązać moje zadanie, ale to nie wystarczyło, ponieważ prawdopodobnie nie zaktualizowano Spring Boot 2.

Oto mój wkład testowany Z Spring Boot 2.0.3.Uwolnij.

Określenie źródła danych dostępnego w classpath w czasie wykonywania

Masz wiele możliwości:

• korzystanie z DBCP 2 datasource (nie chcesz używać DBCP 1, który jest przestarzały i mniej wydajny).
• korzystanie z Tomcat JDBC datasource.
• korzystanie z dowolnego innego źródła danych : na przykład HikariCP.

Jeśli nie podasz żadnego z nich, przy domyślnej konfiguracji instancja źródła danych rzuci wyjątek:

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

• Aby używać Apache JDBC datasource, nie musisz dodawać żadnych zależności, ale musisz zmienić domyślną klasę factory na org.apache.tomcat.jdbc.pool.DataSourceFactory.
  Możesz to zrobić w zasobie deklaracja : resource.setProperty("factory", "org.apache.tomcat.jdbc.pool.DataSourceFactory"); Wyjaśnię poniżej, gdzie dodać tę linię.

• Aby użyć DBCP 2 datasource wymagana jest zależność:

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

Oczywiście, dostosuj wersję artefaktu zgodnie z wersją osadzoną Spring Boot Tomcat.

• Aby użyć HikariCP, dodaj wymaganą zależność, jeśli nie jest jeszcze obecna w Twojej konfiguracji (może być, jeśli polegasz na trwałościach starterów Spring Boot), takich jak :

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

I określ fabrykę, z którą idzie w deklaracji zasobów:

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

Datasource configuration / declaration

Musisz dostosować fasolę, która tworzy instancję TomcatServletWebServerFactory.
Dwie rzeczy do zrobienia:

• Włączanie nazw JNDI, które jest domyślnie wyłączone

• Tworzenie i dodawanie zasobów JNDI w kontekście serwera{[22]]}

Na przykład z PostgreSQL i DBCP 2 datasource, zrób to:

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

Tutaj warianty dla Tomcat JDBC i HikariCP datasource.

W postProcessContext() ustaw właściwość fabryczną tak, jak wyjaśniono wcześniej dla 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);          
    }
};

I dla HikariCP:

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

Używanie / wstrzykiwanie źródła danych

Teraz powinieneś być w stanie wyszukać JNDI ressource w dowolnym miejscu, używając standardowej instancji InitialContext:

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

Możesz również użyć JndiObjectFactoryBean sprężyny, aby wyszukać źródło:

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

Aby skorzystać z pojemnika DI możesz również zrobić DataSource wiosenną fasolkę:

@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();
}

I tak możesz teraz wprowadzić źródło danych do dowolnych fasolek wiosennych, takich jak:

@Autowired
private DataSource jndiDataSource;

Zauważ, że wiele przykładów w Internecie wydaje się wyłączać wyszukiwanie zasobu JNDI przy starcie:

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

Ale myślę, że jest bezradny, ponieważ wywołuje tuż po afterPropertiesSet() to robi wyszukiwanie !

W końcu dostałem odpowiedź dzięki wikisonie, najpierw fasolki:

@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();
}

Pełny kod jest tutaj: https://github.com/wilkinsona/spring-boot-sample-tomcat-jndi

W SpringBoot 2.1 znalazłem inne rozwiązanie. Rozszerzenie standardowej metody gettomcatwebserver klasy fabrycznej. A potem zwróć go jako fasolę z dowolnego miejsca.

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

Ładowanie zasobów z kontekstu.xml jednak nie działa. Spróbuje się dowiedzieć.

Uwaga zamiast

public TomcatEmbeddedServletContainerFactory tomcatFactory()

Musiałem użyć następującej metody

public EmbeddedServletContainerFactory embeddedServletContainerFactory() 

Próbowałeś @Lazy załadować źródło danych? Ponieważ inicjalizujesz osadzony kontener Tomcat w kontekście Spring, musisz opóźnić inicjalizację DataSource (dopóki nie zostaną skonfigurowane var-y JNDI).

N. B. nie miałem jeszcze okazji przetestować tego kodu!

@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();
}

Może być również konieczne dodanie adnotacji @Lazy wszędzie tam, gdzie używane jest źródło danych. np.

@Lazy
@Autowired
private DataSource dataSource;