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

159

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?

Suzan Cioc
quelle

Antworten:

302

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:

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.

Kaliatech
quelle
@skaffman Ja, aber Sie stellen einen Link zur Spring-Referenzdokumentation bereit.
Etienne Miret
Welche Datei genau meinen Sie mit "Tomcat's web context.xml"?
Pavel Niedoba
1
@PavelNiedoba Tomcat verwendet einen "Kontext" für die Tomcat-spezifische Webanwendungskonfiguration. Die Kontextdatei und / oder Kontextkonfiguration kann an verschiedenen Orten abgelegt werden, daher kann ich Ihnen keine endgültige Antwort geben. Ein üblicher Speicherort ist "/META-INF/context.xml". Siehe Abschnitt "Definieren eines Kontexts" hier: tomcat.apache.org/tomcat-8.0-doc/config/…
kaliatech
Mmm ... scheint nicht für meine Orakel-Datenbank zu funktionieren, irgendwelche Unterschiede zu postgresql?
Phate
1
@Phate Auf der Ebene JDBC / JNDI / Tomcat gibt es keine grundlegenden Unterschiede zwischen Oracle und PostgreSQL. Oracle unterscheidet sich jedoch stark von PostgreSQL, wenn es um Details zur Einrichtung von Oracle-Clients / -Servern geht. Außerhalb des Bereichs der ursprünglichen Frage / Antwort. Schlagen Sie vor, eine neue Frage mit Details zu Ihren Versuchen, bestimmten Versionen und etwaigen Fehlermeldungen zu veröffentlichen. Beispiel: stackoverflow.com/questions/10388137/…
kaliatech
51

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

}
Abdull
quelle
2
Oder verwenden Sie das spezialisiertere JndiDataSourceLookup
Arend v. Reinersdorff
21

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"
melihcelik
quelle
15

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 .

Skaffman
quelle
8

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>
Evgen
quelle
5

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

Antonio
quelle
4

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.

Toumi
quelle
1

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.

user3892286
quelle
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.
user3892286
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.
Sergio A.