Wie verwende ich die von Tomcat im Frühjahr bereitgestellte JNDI DataSource?

Es wird gesagt, dass im Spring Javadoc Artikel über DriverManagerDataSourceKlasse, dass diese Klasse sehr einfach ist und dass es empfohlen wird

Verwenden einer vom Container bereitgestellten JNDI-Datenquelle. Ein solches DataSourcekann als DataSourceBean in einem Spring ApplicationContext über verfügbar gemacht werdenJndiObjectFactoryBean

Die Frage ist: Wie schaffe ich das?

DataSourceWas würde ich dann benötigen , wenn ich Bean für den Zugriff auf meine benutzerdefinierte MySQL-Datenbank haben möchte? Was soll ich in die Kontextkonfiguration usw. schreiben?

Wenn Sie die XML-Schema-basierte Konfiguration von Spring verwenden, richten Sie sie im Spring-Kontext folgendermaßen ein:

<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" />

Alternativ können Sie die Einrichtung mit einer einfachen Bean-Konfiguration wie folgt einrichten:

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

Sie können die JNDI-Ressource in der Datei server.xml von tomcat folgendermaßen deklarieren:

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

Verweisen Sie auf die JNDI-Ressource aus Tomcats Web context.xml wie folgt:

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

Referenzdokumentation:

• Tomcat 8 JNDI-Datenquelle HOW-TO
• Referenz zu Tomcat 8-Kontextressourcen-Links
• Spring 4 JEE JNDI Lookup XML-Schema-Referenz
• Frühling 4 JndiObjectFactoryBean Javadoc

Bearbeiten: Diese Antwort wurde für Tomcat 8 und Spring 4 aktualisiert. Es wurden einige Änderungen am Eigenschaftsnamen für das Standard- Datenpool-Ressourcenpool-Setup von Tomcat vorgenommen.

Mit dem JavaConfig-Mechanismus von Spring können Sie dies folgendermaßen tun:

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

}

Angenommen, Sie haben eine "sampleDS" -Datenquellendefinition in Ihrer Tomcat-Konfiguration, können Sie Ihrer Zeile folgende Zeilen applicationContext.xmlhinzufügen, um über JNDI auf die Datenquelle zuzugreifen.

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

Sie müssen den Namespace und den Schema-Speicherort für das jeePräfix definieren, indem Sie:

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"

Dokumentation: C.2.3.1 <jee:jndi-lookup/>(einfach)

Beispiel:

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

Sie müssen nur herausfinden, an welchen JNDI-Namen Ihr App-Server die Datenquelle gebunden hat. Dies ist vollständig serverspezifisch. Lesen Sie die Dokumente auf Ihrem Server, um herauszufinden, wie.

Denken Sie daran, den jeeNamespace oben in Ihrer Beans-Datei zu deklarieren , wie in C.2.3 Das Jee-Schema beschrieben .

Eine weitere Funktion: Anstelle von server.xml können Sie in
your_application / META-INF / Context.xml (gemäß Tomcat-Dokumenten ) das Tag "Resource" wie folgt hinzufügen :

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

Laut Apache Tomcat 7 JNDI-Datenquellen-HOW-TO-Seite muss in web.xml eine Ressourcenkonfiguration vorhanden sein:

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

Das ist für mich in Ordnung

In Ihrer Frühlingsklasse können Sie eine Bohne injizieren, die wie folgt beschriftet ist

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

und Sie fügen dies in Ihre context.xml ein

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

Sie können die JNDI-Ressource in der server.xml von tomcat mit deklarieren

<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"/>

zurück zu context.xml de spring füge dies hinzu

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

Wenn Sie wie in diesem Beispiel eine Verbindung zur Datenbank herstellen, stellen Sie sicher, dass MySQL jar im Verzeichnis tomcat lib vorhanden ist. Andernfalls kann tomcat den Verbindungspool für die MySQL-Datenbank nicht erstellen.

Ich fand diese Lösung auf saubere Weise sehr hilfreich, um die XML-Konfiguration vollständig zu entfernen.

Bitte überprüfen Sie diese Datenbankkonfiguration mit JNDI und Spring Framework. http://www.unotions.com/design/how-to-create-oracleothersql-db-configuration-using-spring-and-maven/

In diesem Artikel wird erläutert, wie einfach es ist, eine Datenbankkonfiguration basierend auf der Datenbank-JNDI-Konfiguration (Datenbank / Test) zu erstellen. Sobald Sie mit der Konfiguration fertig sind, werden alle Datenbank-Repositorys mit diesem JNDI geladen. Ich fand es nützlich. Wenn @Pierre ein Problem damit hat, lassen Sie es mich wissen. Es ist eine Komplettlösung zum Schreiben der Datenbankkonfiguration.