Come utilizzare l'origine dati JNDI fornita da Tomcat in primavera?

Si dice che nell'articolo javadoc di primavera sulla DriverManagerDataSourceclasse, questa classe sia molto semplice e sia raccomandata

per utilizzare un'origine dati JNDI fornita dal contenitore. Tale DataSourcepuò essere esposto come DataSourcebean in un Spring ApplicationContext tramiteJndiObjectFactoryBean

La domanda è: come posso ottenere questo risultato?

Ad esempio, se desidero avere un DataSourcebean per accedere al mio database MySQL personalizzato, cosa dovrei richiedere? Cosa devo scrivere nella configurazione del contesto, ecc.?

Se si utilizza la configurazione basata sullo schema XML di Spring, impostare nel contesto Spring in questo modo:

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:jee="http://www.springframework.org/schema/jee" xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd">
...
<jee:jndi-lookup id="dbDataSource"
   jndi-name="jdbc/DatabaseName"
   expected-type="javax.sql.DataSource" />

In alternativa, eseguire l'installazione utilizzando una configurazione bean semplice come questa:

<bean id="DatabaseName" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="java:comp/env/jdbc/DatabaseName"/>
</bean>

Puoi dichiarare la risorsa JNDI nel server.xml di tomcat usando qualcosa del genere:

<GlobalNamingResources>
    <Resource name="jdbc/DatabaseName"
              auth="Container"
              type="javax.sql.DataSource"
              username="dbUser"
              password="dbPassword"
              url="jdbc:postgresql://localhost/dbname"
              driverClassName="org.postgresql.Driver"
              initialSize="20"
              maxWaitMillis="15000"
              maxTotal="75"
              maxIdle="20"
              maxAge="7200000"
              testOnBorrow="true"
              validationQuery="select 1"
              />
</GlobalNamingResources>

E fare riferimento alla risorsa JNDI dal Web context.xml di Tomcat in questo modo:

  <ResourceLink name="jdbc/DatabaseName"
   global="jdbc/DatabaseName"
   type="javax.sql.DataSource"/>

Documentazione di riferimento:

• Tomcat 8 JNDI Datasource HOW-TO
• Riferimento per i collegamenti alle risorse di contesto Tomcat 8
• Primavera 4 Riferimenti allo schema XML di ricerca JEE JNDI
• Spring 4 JndiObjectFactoryBean Javadoc

Modifica: questa risposta è stata aggiornata per Tomcat 8 e Spring 4. Sono state apportate alcune modifiche al nome della proprietà per l' impostazione del pool di risorse dell'origine dati predefinita di Tomcat .

Con il meccanismo JavaConfig di Spring, puoi farlo in questo modo:

@Configuration
public class MainConfig {

    ...

    @Bean
    DataSource dataSource() {
        DataSource dataSource = null;
        JndiTemplate jndi = new JndiTemplate();
        try {
            dataSource = jndi.lookup("java:comp/env/jdbc/yourname", DataSource.class);
        } catch (NamingException e) {
            logger.error("NamingException for java:comp/env/jdbc/yourname", e);
        }
        return dataSource;
    }

}

Supponendo di avere una definizione dell'origine dati "sampleDS" all'interno della configurazione di Tomcat, è possibile aggiungere le seguenti righe applicationContext.xmlall'accesso all'origine dati utilizzando JNDI.

<jee:jndi-lookup expected-type="javax.sql.DataSource" id="springBeanIdForSampleDS" jndi-name="sampleDS"/>

Devi definire lo spazio dei nomi e la posizione dello schema per il jeeprefisso usando:

xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd"

Documentazione: C.2.3.1 <jee:jndi-lookup/>(semplice)

Esempio:

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/MyDataSource"/>

Devi solo scoprire a quale nome JNDI il tuo appserver ha associato l'origine dati. Questo è interamente specifico del server, consulta i documenti sul tuo server per scoprire come.

Ricorda di dichiarare lo jeespazio dei nomi nella parte superiore del file bean, come descritto in C.2.3 Lo schema jee .

Un'altra caratteristica: invece di server.xml, puoi aggiungere il tag "Resource" in
your_application / META-INF / Context.xml (secondo i documenti Tomcat ) in questo modo:

<Context>
<Resource name="jdbc/DatabaseName" auth="Container" type="javax.sql.DataSource"
  username="dbUsername" password="dbPasswd"
  url="jdbc:postgresql://localhost/dbname"
  driverClassName="org.postgresql.Driver"
  initialSize="5" maxWait="5000"
  maxActive="120" maxIdle="5"
  validationQuery="select 1"
  poolPreparedStatements="true"/>
</Context>

Secondo la pagina HOW-TO di Datasource JNDI di Apache Tomcat 7, ci deve essere una configurazione delle risorse in web.xml:

<resource-ref>
  <description>DB Connection</description>
  <res-ref-name>jdbc/TestDB</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>

Per me va bene

Nella tua classe di primavera, puoi iniettare un bean annotato come

@Autowired
@Qualifier("dbDataSource")
private DataSource dataSource;

e lo aggiungi nel tuo context.xml

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

È possibile dichiarare la risorsa JNDI in server.xml di tomcat utilizzando

<Resource name="jdbc/TestDB" 
  global="jdbc/TestDB" 
  auth="Container" 
  type="javax.sql.DataSource" 
  driverClassName="com.mysql.jdbc.Driver" 
  url="jdbc:mysql://localhost:3306/TestDB" 
  username="pankaj" 
  password="pankaj123" 

  maxActive="100" 
  maxIdle="20" 
  minIdle="5" 
  maxWait="10000"/>

torna a context.xml de spring aggiungi questo

<ResourceLink name="jdbc/MyLocalDB"
                global="jdbc/TestDB"
                auth="Container"
                type="javax.sql.DataSource" />

se, come questo esempio, si sta iniettando una connessione al database, assicurarsi che il vaso MySQL sia presente nella directory libcat tomcat, altrimenti tomcat non sarà in grado di creare il pool di connessioni al database MySQL.

Ho trovato questa soluzione molto utile in modo pulito per rimuovere completamente la configurazione XML.

Si prega di controllare questa configurazione db usando JNDI e il framework di primavera. http://www.unotions.com/design/how-to-create-oracleothersql-db-configuration-using-spring-and-maven/

In questo articolo, spiega come è facile creare una configurazione db basata sulla configurazione del database jndi (db / test). una volta terminata la configurazione, tutti i repository db vengono caricati usando questo jndi. L'ho trovato utile. Se @Pierre ha problemi con questo, fammelo sapere. È la soluzione completa per scrivere la configurazione del db.