Esempio di Tomcat DataSource JNDI in Java

Tutorial

Java

Benvenuti al Tutorial sull’Esempio di Tomcat DataSource JNDI. Abbiamo esaminato il JDBC DataSource nell’ultimo tutorial e appreso come utilizzarlo in un’applicazione Java autonoma.

Tomcat DataSource JNDI

Il vero vantaggio di DataSource si presenta quando lo usiamo con un Context JNDI. Ad esempio, il pool di connessioni in un’applicazione web distribuita in un contenitore servlet. La maggior parte dei popolari contenitori servlet fornisce supporto integrato per DataSource attraverso la configurazione delle Risorse e il contesto JNDI. Questo ci aiuta a creare e utilizzare il pool di connessioni DataSource con solo poche righe di configurazione. Questo tutorial ha lo scopo di fornire un esempio di configurazione di Tomcat DataSource JNDI. Apache Tomcat fornisce tre modi per configurare DataSource nel contesto JNDI.

Contesto dell’applicazione context.xml – Questo è il modo più semplice per configurare il DataSource, tutto ciò di cui abbiamo bisogno è un file context.xml nella directory META-INF. Dobbiamo definire l’elemento Resource nel file di contesto e il container si occuperà del caricamento e della configurazione. L’approccio è semplice ma ha alcuni svantaggi;
- Dato che il file di contesto è incluso nel file WAR, è necessario compilare e distribuire un nuovo WAR per ogni piccolo cambiamento di configurazione. Lo stesso problema si presenta se la tua applicazione funziona in un ambiente distribuito o se la tua applicazione deve essere distribuita in diversi ambienti di test come QA, IT, PROD, ecc.
- Il datasource viene creato dal container solo per l’uso dell’applicazione, quindi non può essere utilizzato globalmente. Non possiamo condividere il datasource tra più applicazioni.
- Se esiste un datasource globale (server.xml) definito con lo stesso nome, il datasource dell’applicazione viene ignorato.
Contesto del server context.xml – Se ci sono diverse applicazioni nel server e si desidera condividere DataSource tra di esse, possiamo definirlo nel file server context.xml. Questo file si trova nella directory apache-tomcat/conf. La portata del file server context.xml è l’applicazione, quindi se si definisce un pool di connessioni DataSource di 100 connessioni e ci sono 20 applicazioni, il datasource verrà creato per ciascuna delle applicazioni. Ciò comporterà 2000 connessioni che ovviamente consumeranno tutte le risorse del server di database e danneggeranno le prestazioni dell’applicazione.
server.xml e context.xml – Possiamo definire DataSource a livello globale definendoli nell’elemento GlobalNamingResources di server.xml. Se utilizziamo questo approccio, dobbiamo definire un ResourceLink dal file context.xml del server o specifico dell’applicazione. Questo è il modo preferito quando si desidera condividere un pool di risorse comune tra diverse applicazioni in esecuzione sul server. Per quanto riguarda il resource link, se definirlo a livello di server nel file xml di contesto o a livello di applicazione dipende dai tuoi requisiti.

Passiamo all’esempio di Tomcat DataSource JNDI nell’applicazione web Java. Per la configurazione dei dati di test, fare riferimento al mio ultimo articolo su Esempio di JDBC DataSource.

Esempio di Configurazione JNDI del DataSource di Tomcat – server.xml

Aggiungi il codice seguente nel file server.xml di Tomcat. Il codice dovrebbe essere aggiunto nell’elemento GlobalNamingResources. Assicurati anche che il driver del database sia presente nella directory lib di Tomcat, quindi in questo caso il jar jdbc di mysql deve essere presente nella libreria di Tomcat.

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

Qui stiamo creando un contesto JNDI con il nome jdbc/MyDB che è un tipo di DataSource. Stiamo passando le configurazioni del database negli attributi url, username, password e driverClassName. Le proprietà del pooling di connessioni sono definite negli attributi maxActive, maxIdle e minIdle.

Configurazione del Collegamento della Risorsa JNDI del DataSource di Tomcat – context.xml

Aggiungi il codice seguente nel file context.xml del server.

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

Nota che il nome del collegamento della risorsa è diverso dal collegamento globale, dobbiamo usare questo nome nel nostro programma Java per ottenere il DataSource.

Esempio di Tomcat DataSource JNDI

Crea un’applicazione web dinamica con il nome JDBCDataSourceTomcat e poi crea un Servlet con il codice sottostante.

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") + "

");
            
            // stampiamo alcune informazioni sul database
            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") + "

Nota che sto usando la configurazione basata su annotazioni Servlet 3 e funzionerà in Tomcat 7 o versioni successive. Se stai utilizzando una versione inferiore di Tomcat, devi apportare alcune modifiche al codice del servlet, per rimuovere l’annotazione WebServlet e configurarla nel file web.xml. La parte del codice del servlet che ci interessa;

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

Questa è la modalità per ottenere le risorse JNDI definite per essere utilizzate dall’applicazione. Avremmo potuto scriverlo anche in questo modo;

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

E quando riavviamo il server ed eseguiamo l’applicazione, si connetterà al database Oracle e produrrà il risultato seguente. Questo è tutto per l’esempio di configurazione JNDI di Tomcat DataSource, puoi definire la risorsa in modo simile anche nei file context.xml.

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