DataSource Java, exemple de DataSource JDBC

Tutoriels

Java

La programmation Java DataSource et JDBC DataSource est la manière de travailler avec les bases de données dans nos programmes Java. Nous avons déjà vu que JDBC DriverManager peut être utilisé pour obtenir des connexions de base de données relationnelle. Mais lorsqu’il s’agit de programmation réelle, nous voulons plus que des connexions.

Java DataSource

La plupart du temps, nous recherchons un couplage lâche pour la connectivité afin de pouvoir changer facilement de base de données, un pooling de connexions pour la gestion des transactions et une prise en charge des systèmes distribués. JDBC DataSource est l’approche préférée si vous recherchez l’une de ces fonctionnalités dans votre application. L’interface Java DataSource est présente dans le package javax.sql et ne déclare que deux méthodes surchargées getConnection() et getConnection(String str1,String str2).

JDBC DataSource

Il incombe à différents fournisseurs de bases de données de fournir différents types d’implémentations de l’interface DataSource. Par exemple, le pilote JDBC MySQL fournit une implémentation de base de l’interface DataSource avec la classe `com.mysql.jdbc.jdbc2.optional.MysqlDataSource`, tandis que le pilote de base de données Oracle l’implémente avec la classe `oracle.jdbc.pool.OracleDataSource`. Ces classes d’implémentation fournissent des méthodes à travers lesquelles nous pouvons fournir les détails du serveur de base de données avec les informations d’identification de l’utilisateur. Certaines des autres fonctionnalités courantes fournies par ces classes d’implémentation JDBC DataSource sont :

Mise en cache des PreparedStatement pour un traitement plus rapide
Paramètres de délai d’expiration de la connexion
Fonctionnalités de journalisation
Seuil de taille maximale du ResultSet

Exemple de DataSource JDBC

Créons un projet d’exemple simple de DataSource JDBC et apprenons comment utiliser les classes d’implémentation de base de MySQL et Oracle DataSource pour obtenir la connexion à la base de données. Notre projet final ressemblera à l’image ci-dessous.

Java JDBC DataSource – Configuration de la base de données

Avant de passer à nos programmes d’exemple, nous avons besoin d’une configuration de base de données avec une table et des données d’exemple. L’installation de la base de données MySQL ou Oracle est hors de portée de ce tutoriel, donc je vais simplement configurer la table avec des données d’exemple.

-- Créer la table Employee
CREATE TABLE `Employee` (
  `empId` int(10) unsigned NOT NULL,
  `name` varchar(10) DEFAULT NULL,
  PRIMARY KEY (`empId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- insérer quelques données d'exemple
INSERT INTO `Employee` (`empId`, `name`)
VALUES
	(1, 'Pankaj'),
	(2, 'David');

commit;

CREATE TABLE "EMPLOYEE"
  (
    "EMPID"   NUMBER NOT NULL ENABLE,
    "NAME"    VARCHAR2(10 BYTE) DEFAULT NULL,
    PRIMARY KEY ("EMPID")
  );

Insert into EMPLOYEE (EMPID,NAME) values (10,'Pankaj');
Insert into EMPLOYEE (EMPID,NAME) values (5,'Kumar');
Insert into EMPLOYEE (EMPID,NAME) values (1,'Pankaj');
commit;

Maintenant, passons à nos programmes Java. Pour avoir une configuration de base de données peu couplée, je les lirai à partir du fichier de propriétés. fichier db.properties:

# Propriétés de la base de données MySQL
MYSQL_DB_DRIVER_CLASS=com.mysql.jdbc.Driver
MYSQL_DB_URL=jdbc:mysql://localhost:3306/UserDB
MYSQL_DB_USERNAME=pankaj
MYSQL_DB_PASSWORD=pankaj123

# Propriétés de la base de données Oracle
ORACLE_DB_DRIVER_CLASS=oracle.jdbc.driver.OracleDriver
ORACLE_DB_URL=jdbc:oracle:thin:@localhost:1521:orcl
ORACLE_DB_USERNAME=hr
ORACLE_DB_PASSWORD=oracle

Assurez-vous que les configurations ci-dessus correspondent à votre configuration locale. Assurez-vous également d’avoir les jars JDBC MySQL et Oracle DB inclus dans le chemin de construction du projet.

Java JDBC DataSource – Exemple MySQL, Oracle

Écrivons une classe factory que nous pouvons utiliser pour obtenir MySQL ou Oracle DataSource.

package com.journaldev.jdbc.datasource;

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import oracle.jdbc.pool.OracleDataSource;

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

public class MyDataSourceFactory {

	public static DataSource getMySQLDataSource() {
		Properties props = new Properties();
		FileInputStream fis = null;
		MysqlDataSource mysqlDS = null;
		try {
			fis = new FileInputStream("db.properties");
			props.load(fis);
			mysqlDS = new MysqlDataSource();
			mysqlDS.setURL(props.getProperty("MYSQL_DB_URL"));
			mysqlDS.setUser(props.getProperty("MYSQL_DB_USERNAME"));
			mysqlDS.setPassword(props.getProperty("MYSQL_DB_PASSWORD"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return mysqlDS;
	}
	
	public static DataSource getOracleDataSource(){
		Properties props = new Properties();
		FileInputStream fis = null;
		OracleDataSource oracleDS = null;
		try {
			fis = new FileInputStream("db.properties");
			props.load(fis);
			oracleDS = new OracleDataSource();
			oracleDS.setURL(props.getProperty("ORACLE_DB_URL"));
			oracleDS.setUser(props.getProperty("ORACLE_DB_USERNAME"));
			oracleDS.setPassword(props.getProperty("ORACLE_DB_PASSWORD"));
		} catch (IOException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return oracleDS;
	}
		
}

Remarquez que les classes d’implémentation DataSource Oracle et MySQL sont très similaires, écrivons un programme de test simple pour utiliser ces méthodes et exécuter quelques tests.

package com.journaldev.jdbc.datasource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

public class DataSourceTest {

	public static void main(String[] args) {
		
		testDataSource("mysql");
		System.out.println("**********");
		testDataSource("oracle");

	}

	private static void testDataSource(String dbType) {
		DataSource ds = null;
		if("mysql".equals(dbType)){
			ds = MyDataSourceFactory.getMySQLDataSource();
		}else if("oracle".equals(dbType)){
			ds = MyDataSourceFactory.getOracleDataSource();
		}else{
			System.out.println("invalid db type");
			return;
		}
		
		Connection con = null;
		Statement stmt = null;
		ResultSet rs = null;
		try {
			con = ds.getConnection();
			stmt = con.createStatement();
			rs = stmt.executeQuery("select empid, name from Employee");
			while(rs.next()){
				System.out.println("Employee ID="+rs.getInt("empid")+", Name="+rs.getString("name"));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
				try {
					if(rs != null) rs.close();
					if(stmt != null) stmt.close();
					if(con != null) con.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
		}
	}

}

Remarquez que la classe cliente est totalement indépendante de toutes les classes spécifiques à la base de données. Cela nous aide à cacher les détails de l’implémentation sous-jacente du programme client et à obtenir des avantages de couplage lâche et d’abstraction. Lorsque nous exécutons le programme de test ci-dessus, nous obtenons la sortie suivante.

Employee ID=1, Name=Pankaj
Employee ID=2, Name=David
**********
Employee ID=10, Name=Pankaj
Employee ID=5, Name=Kumar
Employee ID=1, Name=Pankaj

Exemple Apache Commons DBCP

Si vous regardez la classe de fabrique de source de données Java ci-dessus, il y a deux problèmes majeurs avec celle-ci.

Les méthodes de la classe de fabrique pour créer les sources de données MySQL et Oracle sont étroitement couplées avec l’API du pilote respectif. Si nous voulons supprimer la prise en charge de la base de données Oracle à l’avenir ou si nous voulons ajouter une prise en charge pour une autre base de données, cela nécessitera une modification du code.
La plupart du code pour obtenir les sources de données MySQL et Oracle est similaire, la seule différence étant la classe d’implémentation que nous utilisons.

L’API Apache Commons DBCP nous aide à nous débarrasser de ces problèmes en fournissant une implémentation de source de données Java qui fonctionne comme une couche d’abstraction entre notre programme et différents pilotes JDBC. La bibliothèque Apache DBCP dépend de la bibliothèque Commons Pool, alors assurez-vous qu’elles sont toutes les deux dans le chemin de construction comme indiqué dans l’image. Voici la classe de fabrique de source de données utilisant BasicDataSource qui est l’implémentation simple de DataSource.

package com.journaldev.jdbc.datasource;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

public class DBCPDataSourceFactory {

	public static DataSource getDataSource(String dbType){
		Properties props = new Properties();
		FileInputStream fis = null;
		BasicDataSource ds = new BasicDataSource();
		
		try {
			fis = new FileInputStream("db.properties");
			props.load(fis);
		}catch(IOException e){
			e.printStackTrace();
			return null;
		}
		if("mysql".equals(dbType)){
			ds.setDriverClassName(props.getProperty("MYSQL_DB_DRIVER_CLASS"));
            ds.setUrl(props.getProperty("MYSQL_DB_URL"));
            ds.setUsername(props.getProperty("MYSQL_DB_USERNAME"));
            ds.setPassword(props.getProperty("MYSQL_DB_PASSWORD"));
		}else if("oracle".equals(dbType)){
			ds.setDriverClassName(props.getProperty("ORACLE_DB_DRIVER_CLASS"));
            ds.setUrl(props.getProperty("ORACLE_DB_URL"));
            ds.setUsername(props.getProperty("ORACLE_DB_USERNAME"));
            ds.setPassword(props.getProperty("ORACLE_DB_PASSWORD"));
		}else{
			return null;
		}
		
		return ds;
	}
}

Comme vous pouvez le voir, en fonction de l’entrée de l’utilisateur, une source de données MySQL ou Oracle est créée. Si vous ne prenez en charge qu’une seule base de données dans l’application, vous n’avez même pas besoin de cette logique. Il suffit de modifier les propriétés et vous pouvez passer d’un serveur de base de données à un autre. Le point clé à travers lequel Apache DBCP fournit une abstraction est la méthode setDriverClassName(). Voici le programme client utilisant la méthode de fabrique ci-dessus pour obtenir différents types de connexion.

package com.journaldev.jdbc.datasource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

public class ApacheCommonsDBCPTest {

	public static void main(String[] args) {
		testDBCPDataSource("mysql");
		System.out.println("**********");
		testDBCPDataSource("oracle");
	}

	private static void testDBCPDataSource(String dbType) {
		DataSource ds = DBCPDataSourceFactory.getDataSource(dbType);
		
		Connection con = null;
		Statement stmt = null;
		ResultSet rs = null;
		try {
			con = ds.getConnection();
			stmt = con.createStatement();
			rs = stmt.executeQuery("select empid, name from Employee");
			while(rs.next()){
				System.out.println("Employee ID="+rs.getInt("empid")+", Name="+rs.getString("name"));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
				try {
					if(rs != null) rs.close();
					if(stmt != null) stmt.close();
					if(con != null) con.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
		}
	}

}

Lorsque vous exécutez le programme ci-dessus, la sortie sera la même que celle du programme précédent. Si vous regardez la source de données Java JDBC et l’utilisation ci-dessus, cela peut également être fait avec le DriverManager normal. Le principal avantage de Java DataSource est lorsqu’il est utilisé dans un contexte et avec JNDI. Avec des configurations simples, nous pouvons créer un pool de connexions de base de données maintenu par le conteneur lui-même. La plupart des conteneurs de servlets tels que Tomcat et JBoss fournissent leur propre implémentation de Java DataSource et tout ce dont nous avons besoin est de le configurer à l’aide de configurations simples basées sur XML, puis d’utiliser la recherche de contexte JNDI pour obtenir le Java DataSource et travailler avec celui-ci. Cela nous aide en prenant en charge la mise en pool et la gestion des connexions du côté de notre application vers le serveur, nous donnant ainsi plus de temps pour écrire la logique métier de l’application. Dans le prochain tutoriel, nous apprendrons comment configurer DataSource dans le conteneur Tomcat et l’utiliser dans une application Web.

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