Exemple de Tomcat DataSource JNDI en Java

Tutoriels

Java

Bienvenue dans le tutoriel sur l’exemple d’utilisation de Tomcat DataSource JNDI. Nous avons examiné le JDBC DataSource dans le dernier tutoriel et appris comment l’utiliser dans une application Java autonome.

Tomcat DataSource JNDI

L’avantage réel de DataSource se manifeste lorsque nous l’utilisons avec un contexte JNDI. Par exemple, un pool de connexions dans une application web déployée dans un conteneur de servlet. La plupart des conteneurs de servlet populaires offrent une prise en charge intégrée de DataSource via la configuration des ressources et du contexte JNDI. Cela nous aide à créer et à utiliser un pool de connexions DataSource avec seulement quelques lignes de configuration. Ce tutoriel vise à fournir un exemple de configuration de Tomcat DataSource JNDI. Apache Tomcat propose trois façons de configurer DataSource dans un contexte JNDI.

Fichier context.xml de l’application – C’est la manière la plus simple de configurer le DataSource, tout ce dont nous avons besoin est un fichier context.xml dans le répertoire META-INF. Nous devons définir l’élément Resource dans le fichier de contexte et le conteneur se chargera de le charger et de le configurer. L’approche est simple mais elle présente quelques inconvénients ;
- Comme le fichier de contexte est regroupé avec le fichier WAR, nous devons construire et déployer un nouveau WAR pour chaque petite modification de configuration. Le même problème se pose si votre application fonctionne dans un environnement distribué ou si votre application doit être déployée dans différents environnements de test tels que QA, IT, PROD, etc.
- Le DataSource est créé par le conteneur uniquement pour l’utilisation de l’application, donc il ne peut pas être utilisé globalement. Nous ne pouvons pas partager le DataSource entre plusieurs applications.
- Si un DataSource global (server.xml) est défini avec le même nom, le DataSource de l’application est ignoré.
Contexte du serveur context.xml – S’il y a plusieurs applications sur le serveur et que vous souhaitez partager DataSource entre elles, vous pouvez le définir dans le fichier context.xml du serveur. Ce fichier est situé dans le répertoire apache-tomcat/conf. La portée du fichier context.xml du serveur est l’application, donc si vous définissez un pool de connexions DataSource de 100 connexions et qu’il y a 20 applications, le DataSource sera créé pour chacune des applications. Cela entraînera 2000 connexions qui consommeront évidemment toutes les ressources du serveur de base de données et nuiront aux performances de l’application.
server.xml et context.xml – Nous pouvons définir DataSource au niveau global en les définissant dans l’élément GlobalNamingResources du server.xml. Si nous utilisons cette approche, nous devons définir un ResourceLink à partir du fichier context.xml du serveur ou spécifique à l’application. C’est la méthode préférée lorsque vous souhaitez partager un pool de ressources commun entre plusieurs applications s’exécutant sur le serveur. En ce qui concerne le lien de ressource, que vous le définissiez au niveau du fichier contextuel du serveur ou au niveau de l’application, dépend de vos besoins.

Passons à l’exemple JNDI de Tomcat DataSource dans une application web Java. Pour la configuration des données de test, veuillez vous référer à mon dernier article sur Exemple de DataSource JDBC.

Exemple de configuration JNDI de la source de données Tomcat – server.xml

Ajoutez le code ci-dessous dans le fichier server.xml de Tomcat. Le code doit être ajouté dans l’élément GlobalNamingResources. Assurez-vous également que le pilote de base de données est présent dans le répertoire lib de Tomcat, donc dans ce cas, le fichier jar jdbc de mysql doit être présent dans le répertoire lib de 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"/>

Ici, nous créons un contexte JNDI avec le nom jdbc/MyDB qui est un type de DataSource. Nous passons les configurations de la base de données dans les attributs url, nom d’utilisateur, mot de passe et driverClassName. Les propriétés de mise en pool de connexion sont définies dans les attributs maxActive, maxIdle et minIdle.

Configuration du lien de ressource JNDI Tomcat DataSource – context.xml

Ajoutez le code ci-dessous dans le fichier context.xml du serveur.

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

Remarquez que le nom du lien de ressource est différent du lien global, nous devons utiliser ce nom dans notre programme Java pour obtenir le DataSource.

Exemple de JNDI de DataSource Tomcat

Créez une application web dynamique avec le nom JDBCDataSourceTomcat, puis créez un servlet avec le code ci-dessous.

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

");
            
            // Imprimons quelques informations sur la base de données
            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") + "

Remarquez que j’utilise la configuration basée sur les annotations Servlet 3 et cela fonctionnera dans Tomcat 7 ou des versions ultérieures. Si vous utilisez une version inférieure de Tomcat, vous devrez apporter des modifications au code du servlet pour supprimer l’annotation WebServlet et le configurer dans le fichier web.xml. La partie du code du servlet qui nous intéresse est;

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

Voici la manière d’obtenir les ressources JNDI définies pour être utilisées par l’application. Nous aurions pu l’écrire de cette manière aussi;

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

Et lorsque nous redémarrons le serveur et exécutons l’application, elle se connectera à la base de données Oracle et produira le résultat ci-dessous. C’est tout pour l’exemple de configuration JNDI de Tomcat DataSource, vous pouvez définir la ressource de manière similaire dans les fichiers context.xml également.

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