Tomcat DataSource JNDI Beispiel in Java

Tutorials

Java

Willkommen beim Tutorial für das Tomcat DataSource JNDI-Beispiel. Im letzten Tutorial haben wir uns das JDBC DataSource angesehen und gelernt, wie man es in einer eigenständigen Java-Anwendung verwendet.

Tomcat DataSource JNDI

Der eigentliche Nutzen von DataSource zeigt sich, wenn wir es mit einem JNDI-Kontext verwenden, zum Beispiel einem Verbindungspool in einer in einem Servlet-Container bereitgestellten Webanwendung. Die meisten bekannten Servlet-Container bieten integrierte Unterstützung für DataSource durch Ressourcenkonfiguration und JNDI-Kontext. Dies ermöglicht es uns, einen DataSource-Verbindungspool mit nur wenigen Konfigurationszeilen zu erstellen und zu verwenden. Dieses Tutorial soll ein Beispiel für die Konfiguration von Tomcat DataSource JNDI bieten. Apache Tomcat bietet drei Möglichkeiten zur Konfiguration von DataSource im JNDI-Kontext.

Application context.xml – Dies ist der einfachste Weg, um DataSource zu konfigurieren, alles was wir benötigen, 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 ein neues WAR bauen und deployen. Das gleiche Problem tritt auf, wenn Ihre Anwendung in einer verteilten Umgebung arbeitet oder Ihre Anwendung in verschiedenen Testumgebungen wie QA, IT, PROD usw. deployt werden muss.
- Der Datenquellen wird vom Container nur für die Anwendungsnutzung erstellt, daher kann er 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-Kontext.xml – Wenn es mehrere Anwendungen auf dem Server gibt und Sie DataSource zwischen ihnen teilen möchten, können wir das in der Datei server-Kontext.xml definieren. Diese Datei befindet sich im Verzeichnis apache-tomcat/conf. Der Geltungsbereich der Server-Kontext.xml-Datei ist die Anwendung, daher wird bei Definition eines DataSource-Verbindungspools von 100 Verbindungen und 20 Anwendungen der Datenquelle für jede Anwendung erstellt. Dies führt zu 2000 Verbindungen, die offensichtlich alle Ressourcen des Datenbankservers 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 eine ResourceLink aus der context.xml-Datei des Servers oder der Anwendung spezifisch definieren. Dies ist der bevorzugte Weg, wenn Sie einen gemeinsamen Ressourcenpool über mehrere auf dem Server ausgeführte Anwendungen teilen möchten. In Bezug auf den Resourcenlink hängt die Definition, ob er in der Kontext-XML-Datei auf Serverebene oder Anwendungsebene definiert werden soll, von Ihren Anforderungen ab.

Lassen Sie uns zum Tomcat DataSource JNDI-Beispiel in der Java-Webanwendung gehen. Für die Einrichtung der Testdaten verweisen Sie bitte auf meinen letzten Artikel über JDBC-DataSource-Beispiel.

Tomcat DataSource JNDI Konfigurationsbeispiel – server.xml

Fügen Sie den folgenden Code in die Datei server.xml von Tomcat ein. Der Code sollte im Element GlobalNamingResources hinzugefügt werden. Stellen Sie außerdem sicher, dass der Datenbanktreiber im Tomcat-Lib-Verzeichnis vorhanden ist. In diesem Fall muss das MySQL JDBC JAR im Tomcat-Lib vorhanden 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 eine DataSource ist. Wir übergeben Datenbankkonfigurationen in den Attributen URL, Benutzername, Passwort und driverClassName. Die Eigenschaften für die Verbindungspoolung sind in den Attributen maxActive, maxIdle und minIdle definiert.

Tomcat DataSource JNDI Ressourcen-Link-Konfiguration – context.xml

Fügen Sie den folgenden Code in die Datei context.xml des Servers ein.

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

Beachten Sie, dass der Ressourcenlinkname vom globalen Link abweicht. 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("Employee Details");
            out.print("");
            out.print("");
            out.print("");
            
            while(rs.next())
            {
                out.print("");
                out.print("");
                out.print("");
                out.print("");
            }
            out.print("Employee ID Employee Name
" + rs.getInt("empid") + " " + rs.getString("name") + "

");
            
            // lassen Sie einige DB-Informationen ausdrucken
            out.print("Database Details");
            out.print("Database Product: "+con.getMetaData().getDatabaseProductName()+"
");
            out.print("Database Driver: "+con.getMetaData().getDriverName());
            out.print("");
            
		}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");
			}
			
		}
	}

}

Employee ID	Employee Name
" + rs.getInt("empid") + "	" + rs.getString("name") + "

Beachten Sie, dass ich die Servlet 3 Annotation basierte Konfiguration verwende und es wird in Tomcat 7 oder höheren Versionen funktionieren. 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, an dem wir interessiert sind;

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

Dies ist die Möglichkeit, auf die von der Anwendung verwendeten JNDI-Ressourcen zuzugreifen. 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");

I am also printing some database information to check which database we are connected. Now when you will run the application, you will see following output. Let’s see how easy it is to switch the database server because we are using Tomcat DataSource. All you need is to change the Database properties. So if we have to switch to Oracle database, my Resource configuration will look like below.

<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 alles für das Tomcat DataSource JNDI Konfigurationsbeispiel-Tutorial, Sie können die Ressource auch ähnlich in den context.xml-Dateien definieren.

Source:
https://www.digitalocean.com/community/tutorials/tomcat-datasource-jndi-example-java