Willkommen zum Tomcat DataSource JNDI Beispiel-Tutorial

Der eigentliche Nutzen von DataSource zeigt sich, wenn wir es mit einem JNDI-Kontext verwenden. Zum Beispiel ein Connection-Pool in einer Webanwendung, die in einem Servlet-Container bereitgestellt wird. Die meisten der beliebten Servlet-Container bieten eingebaute Unterstützung für DataSource durch Ressourcenkonfiguration und JNDI-Kontext. Dies hilft uns, einen DataSource-Verbindungspool mit nur wenigen Konfigurationszeilen zu erstellen und zu verwenden. Dieses Tutorial zielt darauf ab, ein Beispiel für die Konfiguration von Tomcat DataSource JNDI zu bieten. Apache Tomcat bietet drei Möglichkeiten, DataSource im JNDI-Kontext zu konfigurieren.

Application context.xml

Dies ist der einfachste Weg, DataSource zu konfigurieren, alles, was wir brauchen, ist eine context.xml-Datei im META-INF-Verzeichnis. Wir müssen das Resource-Element in der Kontextdatei definieren und der Container wird sich um das Laden und Konfigurieren kümmern. Der Ansatz ist einfach, hat aber einige Nachteile;

• Da die Kontextdatei mit der WAR-Datei gebündelt ist, müssen wir für jede kleine Konfigurationsänderung eine neue WAR erstellen und bereitstellen. Das gleiche Problem tritt auf, wenn Ihre Anwendung in einer verteilten Umgebung arbeitet oder in verschiedenen Testumgebungen wie QA, IT, PROD usw. bereitgestellt werden muss.
• Die Datenquelle wird vom Container nur für die Anwendungsnutzung erstellt, daher kann sie nicht global verwendet werden. Wir können die Datenquelle nicht über mehrere Anwendungen hinweg teilen.
• Wenn eine globale Datenquelle (server.xml) mit demselben Namen definiert ist, wird die Anwendungsdatenquelle ignoriert.

Server context.xml

Wenn es mehrere Anwendungen auf dem Server gibt und Sie DataSource zwischen ihnen teilen möchten, können wir dies in der server context.xml-Datei definieren. Diese Datei befindet sich im Verzeichnis apache-tomcat/conf. Der Geltungsbereich der server context.xml-Datei ist die Anwendung, daher wird, wenn Sie einen DataSource-Verbindungspool von 100 Verbindungen definieren und es 20 Anwendungen gibt, die Datenquelle für jede der Anwendungen erstellt. Dies führt zu 2000 Verbindungen, die offensichtlich alle Ressourcen des Datenbank-Servers verbrauchen und die Leistung der Anwendung beeinträchtigen werden.

server.xml und context.xml

Wir können DataSource auf globaler Ebene definieren, indem wir sie im Element GlobalNamingResources der server.xml definieren. Wenn wir diesen Ansatz verwenden, müssen wir einen ResourceLink aus der context.xml-Datei des Servers oder spezifisch für die Anwendung definieren. Dies ist der bevorzugte Weg, wenn Sie einen gemeinsamen Ressourcenpool für mehrere Anwendungen auf dem Server teilen möchten. Bezüglich des Ressourcenlinks hängt es von Ihren Anforderungen ab, ob Sie ihn in der server-level context xml-Datei oder auf Anwendungsebene definieren.

Tomcat DataSource JNDI-Beispiel in einer Java-Webanwendung

Für die Einrichtung der Testdaten beziehen Sie sich bitte auf meinen letzten Artikel über das JDBC DataSource-Beispiel.

Tomcat DataSource JNDI-Konfigurationsbeispiel – server.xml

Fügen Sie den folgenden Code in die server.xml-Datei von Tomcat ein. Der Code sollte im Element GlobalNamingResources hinzugefügt werden. Stellen Sie auch sicher, dass der Datenbanktreiber im Tomcat lib-Verzeichnis vorhanden ist, in diesem Fall muss das mysql jdbc jar im Tomcat lib sein.

<Resource name="jdbc/MyDB" 
      global="jdbc/MyDB" 
      auth="Container" 
      type="javax.sql.DataSource" 
      driverClassName="com.mysql.jdbc.Driver" 
      url="jdbc:mysql://localhost:3306/UserDB" 
      username="pankaj" 
      password="pankaj123" 
      maxActive="100" 
      maxIdle="20" 
      minIdle="5" 
      maxWait="10000"/>

Hier erstellen wir einen JNDI-Kontext mit dem Namen jdbc/MyDB, der ein Typ von DataSource ist. Wir übergeben die Datenbankkonfigurationen in url, Benutzername, Passwort und driverClassName-Attribut. Verbindungspool-Eigenschaften werden in den Attributen maxActive, maxIdle und minIdle definiert.

Tomcat DataSource JNDI Ressourcenlink-Konfiguration – context.xml

Fügen Sie den folgenden Code in die server context.xml-Datei ein.

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

Beachten Sie, dass der Name des Ressourcenlinks anders ist als der globale Link, wir müssen diesen Namen in unserem Java-Programm verwenden, um die DataSource zu erhalten.

Tomcat DataSource JNDI Beispiel

Erstellen Sie eine dynamische Webanwendung mit dem Namen JDBCDataSourceTomcat und erstellen Sie dann ein Servlet mit dem folgenden Code.

package com.journaldev.jdbc.datasource;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

@WebServlet("/JDBCDataSourceExample")
public class JDBCDataSourceExample extends HttpServlet {
    private static final long serialVersionUID = 1L;
       
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Context ctx = null;
        Connection con = null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            ctx = new InitialContext();
            DataSource ds = (DataSource) ctx.lookup("java:/comp/env/jdbc/MyLocalDB");
            
            con = ds.getConnection();
            stmt = con.createStatement();
            
            rs = stmt.executeQuery("select empid, name from Employee");
            
            PrintWriter out = response.getWriter();
            response.setContentType("text/html");
            out.print("<html><body><h2>Employee Details</h2>");
            out.print("<table border=\"1\" cellspacing=10 cellpadding=5>");
            out.print("<th>Employee ID</th>");
            out.print("<th>Employee Name</th>");
            
            while(rs.next())
            {
                out.print("<tr>");
                out.print("<td>" + rs.getInt("empid") + "</td>");
                out.print("<td>" + rs.getString("name") + "</td>");
                out.print("</tr>");
            }
            out.print("</table></body><br/>");
            
            //lets print some DB information
            out.print("<h3>Database Details</h3>");
            out.print("Database Product: "+con.getMetaData().getDatabaseProductName()+"<br/>");
            out.print("Database Driver: "+con.getMetaData().getDriverName());
            out.print("</html>");
            
        }catch(NamingException e){
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            try {
                rs.close();
                stmt.close();
                con.close();
                ctx.close();
            } catch (SQLException e) {
                System.out.println("Exception in closing DB resources");
            } catch (NamingException e) {
                System.out.println("Exception in closing Context");
            }
            
        }
    }

}

Beachten Sie, dass ich die Servlet 3 Annotation-basierte Konfiguration verwende und sie in Tomcat 7 oder höheren Versionen funktioniert. Wenn Sie eine niedrigere Version von Tomcat verwenden, müssen Sie einige Änderungen am Servlet-Code vornehmen, um die WebServlet-Annotation zu entfernen und in der web.xml-Datei zu konfigurieren. Der Teil des Servlet-Codes, der uns interessiert, lautet;

ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("java:/comp/env/jdbc/MyLocalDB");

So erhalten wir die JNDI-Ressourcen, die für die Anwendung definiert sind. Wir hätten es auch so schreiben können;

ctx = new InitialContext();
Context initCtx  = (Context) ctx.lookup("java:/comp/env");
DataSource ds = (DataSource) initCtx.lookup("jdbc/MyLocalDB");

Ich drucke auch einige Datenbankinformationen aus, um zu überprüfen, mit welcher Datenbank wir verbunden sind. Wenn Sie nun die Anwendung ausführen, werden Sie das folgende Ergebnis sehen.

Schauen wir uns an, wie einfach es ist, den Datenbankserver zu wechseln, da wir Tomcat DataSource verwenden. Alles, was Sie tun müssen, ist die Datenbankeigenschaften zu ändern. Wenn wir also auf eine Oracle-Datenbank umsteigen müssen, sieht meine Ressourcenkonfiguration wie folgt aus.

<Resource name="jdbc/MyDB" 
      global="jdbc/MyDB" 
      auth="Container" 
      type="javax.sql.DataSource" 
      driverClassName="oracle.jdbc.driver.OracleDriver" 
      url="jdbc:oracle:thin:@localhost:1521:orcl" 
      username="hr" 
      password="oracle" 
      
      maxActive="100" 
      maxIdle="20" 
      minIdle="5" 
      maxWait="10000"/>

Und wenn wir den Server neu starten und die Anwendung ausführen, wird sie eine Verbindung zur Oracle-Datenbank herstellen und das folgende Ergebnis produzieren.

Das ist eine Anleitung und ein Willkommen für das Tomcat DataSource JNDI-Konfigurationsbeispiel-Tutorial, Sie können die Ressource auf ähnliche Weise auch in context.xml-Dateien definieren.