D14 - TP6 - JDBC

Ce TP peut être fait en utilisant en particulier postgresql (installé en salle de TP) ou la base de données h2 (http://www.h2database.com/html/cheatSheet.html) que vous ferez fonctionner en serveur.

Il est aussi possible d’utiliser très simplement un serveur mysql (ou postgresql) avec Docker :

sous linux mint en root

export http_proxy=‘http://user:password@proxy-host:proxy-port’ export https_proxy=‘http://user:password@proxy-host:proxy-port’

# Add the repository to your APT sources sudo echo deb https://get.docker.com/ubuntu docker main > /etc/apt/sources.list.d/docker.list

sudo apt-get update sudo apt-get install -y docker.io cgroup-lite apparmor

sudo usermod -a -G docker $USER

Edit /etc/defaults/docker and add the following lines: export http_proxy=‘http://user:password@proxy-host:proxy-port’

service docker restart

docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=ArraujUrb4 -d mysql

Pour éditer la base de données vous pouvez utiliser pgadmin3, installer http://sqldeveloper.solyp.com/ ou utiliser directement Intellij Idea (http://www.jetbrains.com/idea/webhelp/configuring-a-db-data-source.html).

1. Avec le script journal.sql.tgz créer les tables qui représentent des journaux.
2. Créer une classe que se connecte à votre base de donnée. Pensez à mettre en place correctement les librairies nécessaires. Pour le moment, la connexion sera représentée par une variable d’instance.
3. Ajouter une méthode qui affiche la liste des journaux en utilisant un Statment
4. Créer une méthode ajouterJournal(…) qui permet d’insérer un journal dans la base de données
5. En utilisant un PreparedStamement, lire un code de Journal au clavier et afficher les informations correspondantes tant que l’on ne rentre pas 0.

1. Ajouter une méthode qui affiche les métadonnées correspondant à la base de données
2. Ajouter une méthode qui afficher les métadonnées correspondant à la requête select * from journal

1. Utiliser les batch update pour ajouter des journaux en lisant un fichier texte formaté (code_j:titre:prix:type:periode::adr_j).

// Création d'un requete
PreparedStatemen pstmt = 
  conn.prepareStatement("INSERT INTO EMPLOYE (email, nom, prenom) VALUES(?, ?, ?)");
 
//On ajoute les exécution une à une ...
conn.setAutoCommit(false);
 
// On fixe les paramètres de la première requête à exécuter
pstmt.setString( 1, "...@...");
pstmt.setString( 2, "..." );
pstmt.setString( 3, "..." );
// Et on l'ajoute au batch
pstmt.addBatch();
 
// On fixe les paramètres de la seconde requête à exécuter
pstmt.setString( 1, "...@...");
pstmt.setString( 2, "..." );
pstmt.setString( 3, "..." );
// Et on l'ajoute au batch
pstmt.addBatch();
 
// On ajoute autant de requêtes que nécessaire
//Par exemple en lisant un flux de données.
.
.
.
.
//On créée un tableau d'entiers pour recevoir les résultats.
//et on execute toutes les mises à jour en une fois.
int[] count = stmt.executeBatch();
 
//On valide les changements.
conn.commit();

En utilisant la classe suivante, utiliser maintenant un pool de connexion au lieu d’une variable globale. L’objet de cet exercice est de comprendre le fonctionnement jdbc propose maintenant ce mécanisme (http://docs.oracle.com/javase/tutorial/jdbc/basics/sqldatasources.html).

DatabaseManager.java

package fr.univ_tln.bruno.mycompany.jdbc.pool;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Queue;
 
/**
 * The Class DatabaseManager.
 */
public class DatabaseManager {
 
	/** The Constant freeConnections. */
	private static final Queue<Connection> freeConnections = new LinkedList<Connection>();
 
	/** The Constant numberOfInitialConnections. */
	private static final int numberOfInitialConnections = 5;
 
	/** The Constant password. */
	private static final String password = System
			.getProperty("MyCompany.database.password");
 
	/** The Constant url. */
	private static final String url = System
			.getProperty("MyCompany.database.url");
 
	/** The Constant user. */
	private static final String user = System
			.getProperty("MyCompany.database.user");
 
	static {
		for (int i = 0; i < numberOfInitialConnections; i++) {
			try {
				freeConnections.add(DriverManager.getConnection(url, user,
						password));
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
 
	/**
	 * Gets the connection.
	 * 
	 * @return the connection
	 * 
	 * @throws SQLException
	 *             the SQL exception
	 */
	public static synchronized Connection getConnection() throws SQLException {
		Connection connection = null;
		if (freeConnections.isEmpty()) {
			connection = DriverManager.getConnection(url, user, password);
		} else {
			connection = freeConnections.remove();
		}
		return connection;
	}
 
	/**
	 * Release connection.
	 * 
	 * @param connection
	 *            the connection
	 */
	public static synchronized void releaseConnection(Connection connection) {
		if (freeConnections.size() < numberOfInitialConnections) {
			freeConnections.add(connection);
		} else {
			try {
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

Attention, les login et password doivent être définit pas des “properties” (cf System.setProperty()). Ensuite, ils pourront être lus dans un fichier de configuration.

• Mettez en place un pool de connections avec Apache Commons DBCP : https://www.baeldung.com/java-connection-pooling
• Créer une interface générique paramétrée par le type qui sera celui de votre entité (Personne, Chien, …) cette interface proposera par exemple les methodes : T find(long id), List<T> findAll(), persist(T), update(T), remove(T). Vous pourrez ensuite améliorer cette interface.
• Créer une classe d’entité Personne, une classe DAOPersonne qui implante DAO<Personne>.
• Ajouter des méthodes spécifiques à la DAO.