Tomcat DataSource JNDI Voorbeeld in Java

Java

Welkom bij de Tomcat DataSource JNDI Voorbeeldhandleiding. We hebben in de vorige handleiding gekeken naar de JDBC DataSource en geleerd hoe we die kunnen gebruiken in een op zichzelf staande Java-toepassing.

Tomcat DataSource JNDI

Het werkelijke voordeel van DataSource komt naar voren wanneer we het gebruiken met een JNDI-context. Bijvoorbeeld, een verbindingenpool in een webtoepassing die is ingezet in een servletcontainer. De meeste populaire servletcontainers bieden ingebouwde ondersteuning voor DataSource via bronconfiguratie en JNDI-context. Dit helpt ons bij het maken en gebruiken van een DataSource-verbindingenpool met slechts een paar regels configuratie. Deze handleiding heeft als doel een voorbeeld te geven van de configuratie van Tomcat DataSource JNDI. Apache Tomcat biedt drie manieren om DataSource te configureren in een JNDI-context.

Toepassingscontext.xml – Dit is de eenvoudigste manier om DataSource te configureren, alles wat we nodig hebben is een context.xml-bestand in de META-INF-map. We moeten het Resource-element definiëren in het contextbestand en de container zal zorgen voor het laden en configureren ervan. De aanpak is eenvoudig maar heeft enkele nadelen;
- Aangezien het contextbestand gebundeld is met het WAR-bestand, moeten we een nieuwe WAR bouwen en implementeren voor elke kleine configuratiewijziging. Hetzelfde probleem doet zich voor als uw toepassing werkt in een gedistribueerde omgeving of als uw toepassing moet worden geïmplementeerd in verschillende testomgevingen zoals QA, IT, PROD, enz.
- De datasource wordt door de container alleen gemaakt voor het gebruik van de toepassing, dus het kan niet wereldwijd worden gebruikt. We kunnen de datasource niet delen tussen meerdere toepassingen.
- Als er een wereldwijde datasource (server.xml) is gedefinieerd met dezelfde naam, wordt de datasourcenaam van de toepassing genegeerd.
Server context.xml – Als er meerdere toepassingen op de server zijn en u DataSource over hen wilt delen, kunnen we dat definiëren in het servercontext.xml-bestand. Dit bestand bevindt zich in de apache-tomcat/conf-directory. De reikwijdte van het servercontext.xml-bestand is de toepassing, dus als u een DataSource-verbindingenpool van 100 verbindingen definieert en er zijn 20 toepassingen, dan wordt de gegevensbron gemaakt voor elke toepassing. Dit zal resulteren in 2000 verbindingen die natuurlijk alle database server resources zullen verbruiken en de prestaties van de toepassing zullen schaden.
server.xml en context.xml – We kunnen DataSource op het wereldwijde niveau definiëren door ze te definiëren in het server.xml-GlobalNamingResources-element. Als we deze benadering gebruiken, moeten we een ResourceLink definiëren vanuit het context.xml-bestand van de server of specifiek voor de toepassing. Dit is de voorkeursmethode wanneer u een gemeenschappelijke resourcepool wilt delen over meerdere toepassingen die op de server worden uitgevoerd. Wat betreft de bronkoppeling, of u deze op serverniveau in het context xml-bestand of op toepassingsniveau moet definiëren, hangt af van uw vereiste.

Laten we naar het voorbeeld van de Tomcat DataSource JNDI gaan in de Java-webtoepassing. Voor de testgegevensinstellingen, verwijs alstublieft naar mijn laatste artikel over JDBC DataSource Example.

Tomcat DataSource JNDI Configuratie Voorbeeld – server.xml

Voeg onderstaande code toe in het tomcat server.xml-bestand. De code moet worden toegevoegd binnen het GlobalNamingResources-element. Zorg er ook voor dat de database-driver aanwezig is in de tomcat lib-map, dus in dit geval moet de mysql jdbc jar aanwezig zijn in de tomcat lib.

<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 creëren we een JNDI-context met de naam jdbc/MyDB, die een type DataSource is. We geven databaseconfiguraties door in de url, gebruikersnaam, wachtwoord en driverClassName-attributen. Verbindingspoolingseigenschappen zijn gedefinieerd in de maxActive, maxIdle en minIdle-attributen.

Tomcat DataSource JNDI Resource Link Configuratie – context.xml

Voeg onderstaande code toe in het server context.xml-bestand.

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

Let op dat de naam van de resourcelink verschilt van de globale link; we moeten deze naam gebruiken in ons javaprogramma om de DataSource te verkrijgen.

Voorbeeld van Tomcat DataSource JNDI

Maak een dynamische webtoepassing met de naam JDBCDataSourceTomcat en maak vervolgens een Servlet met onderstaande 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") + "

");
            
            // laten we wat DB-informatie afdrukken
            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") + "

Merk op dat ik gebruik maak van Servlet 3 op annotaties gebaseerde configuratie en dat het zal werken in Tomcat 7 of hogere versies. Als je een lagere versie van Tomcat gebruikt, moet je enkele wijzigingen aanbrengen in de servletcode, om de WebServlet-annotatie te verwijderen en te configureren in het web.xml-bestand. Het gedeelte van de servletcode waarin we geïnteresseerd zijn;

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

Dit is de manier om de JNDI-resources te verkrijgen die zijn gedefinieerd om door de toepassing te worden gebruikt. We hadden het ook op deze manier kunnen schrijven;

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

En wanneer we de server herstarten en de toepassing uitvoeren, maakt deze verbinding met de Oracle-database en produceert het onderstaande resultaat. Dat is alles voor het voorbeeld van Tomcat DataSource JNDI-configuratie, je kunt de resource op een vergelijkbare manier definiëren in context.xml-bestanden.

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