523 lines
13 KiB
Java
523 lines
13 KiB
Java
package com.gestionnaires;
|
|
|
|
/*
|
|
* Remarque : Type de caractères utilisés dans ce fichier : UTF-8
|
|
*/
|
|
|
|
//JDBC
|
|
import java.sql.*;
|
|
import java.util.Vector;
|
|
|
|
|
|
|
|
/**
|
|
* Opérations possibles avec GestionConnexion.
|
|
* @author 3fvorillion
|
|
*/
|
|
enum OperationBDD
|
|
{
|
|
/**
|
|
* opération de sélection .
|
|
*/
|
|
OP_BDD_SELECTION,
|
|
/**
|
|
* opération de création de table.
|
|
*/
|
|
OP_BDD_CREER_TABLE,
|
|
/**
|
|
* opération de suppression de table.
|
|
*/
|
|
OP_BDD_SUPPR_TABLE
|
|
}
|
|
|
|
/**
|
|
* Gestionnaire d'une connexion à une base de données.
|
|
* @author 3fvorillion
|
|
*/
|
|
public class GestionConnexion
|
|
{
|
|
/*
|
|
* VARIABLES
|
|
*/
|
|
// paramètres
|
|
private ParametresConnexion paramsConn;
|
|
|
|
// connexion
|
|
private Connection connection = null;
|
|
private Statement statement = null;
|
|
|
|
// requête SQL
|
|
private String requeteSQL = "";
|
|
private ResultSet resultSet = null;
|
|
|
|
// erreurs - anomalies
|
|
private Vector<String> vs_erreurs = null;
|
|
private Vector<String> vs_anomalies = null;
|
|
|
|
|
|
/*
|
|
* CONSTRUCTEUR
|
|
*/
|
|
/**
|
|
* Constructeur par défaut.<br>
|
|
* Instancie le gestionnaire d'une connexion à une base de données.
|
|
* @exception ClassNotFoundException La classe n'a pas été trouvée
|
|
*/
|
|
public GestionConnexion()
|
|
throws ClassNotFoundException, Exception
|
|
{
|
|
/*
|
|
* Init les autres variables
|
|
*/
|
|
this.statement = null;
|
|
this.resultSet = null;
|
|
this.requeteSQL = "";
|
|
|
|
this.paramsConn = new ParametresConnexion();
|
|
|
|
//init la gestion des erreurs - anomalies
|
|
this.vs_erreurs = new Vector<String>();
|
|
this.vs_anomalies = new Vector<String>();
|
|
|
|
try
|
|
{
|
|
// Récupération du driver
|
|
Class.forName(ParametresConnexion.CLASSE).newInstance();
|
|
}
|
|
catch (ClassNotFoundException ex)
|
|
{
|
|
//remonte l'exception
|
|
throw new ClassNotFoundException("La classe '"+ParametresConnexion.CLASSE+"' n'a pas été trouvée.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//remonte l'exception
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* METHODES D'INSTANCES
|
|
*/
|
|
/**
|
|
* Ouvre une connexion avec les paramètres spécifiés.
|
|
* @param params Objet contenant les paramètres à appliquer pour la connexion.
|
|
*/
|
|
public void ouvrir(ParametresConnexion params)
|
|
{
|
|
//Vérifie le paramètre
|
|
if (params == null)
|
|
throw new NullPointerException();
|
|
|
|
//Copie les paramètres
|
|
this.paramsConn.CopierDepuis(params);
|
|
|
|
//Appelle la méthode sans paramètres
|
|
this.ouvrir();
|
|
}
|
|
/**
|
|
* Ouvre une connexion avec les paramètres déjà chargés.<br>
|
|
* Note : si aucun paramètre n'a été chargé, utilise les paramètres de connexion par défaut (cf classe ParametresConnexion).
|
|
*/
|
|
public void ouvrir()
|
|
{
|
|
try
|
|
{
|
|
// ferme la conexion précédente
|
|
this.fermerConnexion();
|
|
|
|
// init la nouvelle connexion
|
|
this.connection = DriverManager.getConnection(this.paramsConn.Url,
|
|
this.paramsConn.Utilisateur, this.paramsConn.Pwd);
|
|
|
|
this.traiterWarning(this.connection.getWarnings());
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
|
|
this.fermerConnexion();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Donne l'état de la connexion en cours.
|
|
* @return true si la connexion est ouverte; false si fermée.
|
|
*/
|
|
public boolean estOuverte()
|
|
{
|
|
boolean bOuverte = false;
|
|
|
|
try
|
|
{
|
|
if (this.connection != null)
|
|
bOuverte = !this.connection.isClosed();
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
}
|
|
|
|
return bOuverte;
|
|
}
|
|
|
|
/**
|
|
* Ferme les ressources utilisées par la requête:<br>
|
|
* - ferme le ResultSet et le Statement;<br>
|
|
* - vide le contenu de la requête.
|
|
*/
|
|
public void fermerRessourcesRequete()
|
|
{
|
|
try
|
|
{
|
|
// Ferme le resultSet
|
|
if (this.resultSet != null)
|
|
{
|
|
this.resultSet.close();
|
|
this.resultSet = null;
|
|
}
|
|
|
|
// Ferme le statement
|
|
if (this.statement != null)
|
|
{
|
|
this.statement.close();
|
|
this.statement = null;
|
|
}
|
|
|
|
// Vide la requête
|
|
this.requeteSQL = "";
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ferme la connexion et libère les autres ressources qui ont pu être utilisées.
|
|
*/
|
|
public void fermerConnexion()
|
|
{
|
|
try
|
|
{
|
|
// Ferme le statement
|
|
this.fermerRessourcesRequete();
|
|
|
|
// Ferme la connexion
|
|
if (this.connection != null)
|
|
{
|
|
this.connection.close();
|
|
this.connection = null;
|
|
}
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lance la requête SQL de sélection spécifiée.
|
|
* @param query Requête SQL de type SELECT à exécuter.
|
|
* @return true si la requête a réussie; false sinon.
|
|
*/
|
|
public boolean lancerRequeteSelection(String query)
|
|
{
|
|
boolean res = true;
|
|
|
|
try
|
|
{
|
|
// verifie la connexion
|
|
if (this.connection != null)
|
|
{
|
|
// libère les ressources de la précédente requête
|
|
this.fermerRessourcesRequete();
|
|
|
|
// prepare la requete
|
|
this.statement = this.connection.createStatement();
|
|
this.traiterWarning(this.statement.getWarnings());
|
|
|
|
// emet la requete
|
|
this.resultSet = this.statement.executeQuery(query);
|
|
this.traiterWarning(this.resultSet.getWarnings());
|
|
|
|
// si on est arrivé jusqu'ici, c'est qu'il n'y a pas eu de levée d'exception
|
|
// =>actualise la requête
|
|
this.requeteSQL = query;
|
|
}
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
|
|
// libère les ressources utilisées
|
|
this.fermerRessourcesRequete();
|
|
|
|
//annonce l'échec de la requête SQL
|
|
res = false;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Lance la requête SQL spécifiée qui modifie la base de donnée.
|
|
* @param query Requête SQL de type DELETE, UPDATE, INSERT à exécuter.
|
|
* @return nombre de lignes modifiées pour requête DDL;<br>
|
|
* 0 pour requête ne donnant aucun réeacute;sultat;<br>
|
|
* -1 si une erreur est survenue lors de l'exécution de la requête;
|
|
*/
|
|
public int lancerRequeteModifBDD(String query)
|
|
{
|
|
int res = 0;
|
|
|
|
try
|
|
{
|
|
// verifie la connexion
|
|
if (this.connection != null)
|
|
{
|
|
// libère les ressources de la précédente requête
|
|
this.fermerRessourcesRequete();
|
|
|
|
// prepare la requete
|
|
this.statement = this.connection.createStatement();
|
|
|
|
// emet la requete
|
|
res = this.statement.executeUpdate(query);
|
|
this.traiterWarning(this.statement.getWarnings());
|
|
|
|
// si on est arrivé jusqu'ici, c'est qu'il n'y a pas eu de levée d'exception
|
|
// =>actualise la requête
|
|
this.requeteSQL = query;
|
|
}
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
this.traiterSQLException(ex);
|
|
|
|
// libère les ressources utilisées
|
|
this.fermerRessourcesRequete();
|
|
|
|
//annonce l'échec de la requête SQL
|
|
res = -1;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Retourne une copie de l'objet contenant les paramètres de la connexion courante.
|
|
* @return Copie de l'objet contenant les paramètres de connexion.
|
|
*/
|
|
public ParametresConnexion getParametresConnexion()
|
|
{
|
|
//Retourne une copie de l'objet contenant les paramètres de connexion
|
|
return new ParametresConnexion(this.paramsConn);
|
|
}
|
|
|
|
/**
|
|
* Retourne la requête SQL qui a été lancée avec succès.
|
|
* @return Requête SQL qui a été exécutée.<br>Si pas de résultats disponibles, renvoie une chaîne vide.
|
|
*/
|
|
public String getRequeteSQL()
|
|
{
|
|
return this.requeteSQL;
|
|
}
|
|
|
|
/**
|
|
* Donne les infos sur la connexion courante.
|
|
* @return Liste des infos de la connexion en cours.
|
|
*/
|
|
public Vector<String> getInfosConnexion()
|
|
{
|
|
Vector<String> vs_infosConn = new Vector<String>();
|
|
DatabaseMetaData dmd;
|
|
|
|
try
|
|
{
|
|
// Vérifie que la connexion soit ouverte
|
|
if (this.estOuverte())
|
|
{
|
|
// Etat de la connexion
|
|
vs_infosConn.add("Etat de la connexion : ouverte");
|
|
vs_infosConn.add("------------------------------");
|
|
|
|
// Obtient les meta-datas de la base
|
|
dmd = this.connection.getMetaData();
|
|
|
|
vs_infosConn.add("Connexion : " + dmd.getURL());
|
|
vs_infosConn.add("Driver : " + dmd.getDriverName());
|
|
vs_infosConn.add("Version : " + dmd.getDriverVersion());
|
|
}
|
|
else
|
|
{
|
|
// Etat de la connexion
|
|
vs_infosConn.add("Etat de la connexion : fermée");
|
|
vs_infosConn.add("------------------------------");
|
|
|
|
vs_infosConn.add("Connexion : " + this.paramsConn.Url);//contient le Serveur, le Port et la Base
|
|
vs_infosConn.add("Utilisateur : " + this.paramsConn.Utilisateur);
|
|
vs_infosConn.add("Mot de passe : " + this.paramsConn.Pwd.length() + " caractère(s)");
|
|
}
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
// Erreur lors de l'obtention du nom des colonnes
|
|
this.traiterSQLException(ex);
|
|
}
|
|
|
|
return vs_infosConn;
|
|
}
|
|
|
|
/**
|
|
* Récupère la liste des noms des colonnes issues du résultat de la requête SQL précédemment lancée.
|
|
* @return Liste des noms des colonnes issues du résultat de la requête SQL.
|
|
*/
|
|
public Vector<String> getNomsColonnes()
|
|
{
|
|
Vector<String> vs_cols = new Vector<String>();
|
|
ResultSetMetaData rsmd;
|
|
|
|
try
|
|
{
|
|
// Vérifie si la requête a déjà été lancée
|
|
if (this.resultSet != null)
|
|
{
|
|
rsmd = this.resultSet.getMetaData(); // obtient les meta-datas de la requête
|
|
int nbrCols = rsmd.getColumnCount();
|
|
|
|
for (int idCol = 1; idCol <= nbrCols; idCol++)
|
|
if (rsmd.isSearchable(idCol))
|
|
vs_cols.add(rsmd.getColumnName(idCol));
|
|
}
|
|
else if (this.statement == null)
|
|
// anomalie
|
|
this.vs_anomalies.add("Vous n'avez pas encore lancé la requête!!");
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
// Erreur lors de l'obtention du nom des colonnes
|
|
this.traiterSQLException(ex);
|
|
}
|
|
|
|
return vs_cols;
|
|
}
|
|
|
|
/**
|
|
* Récupère le résultat de la requête SQL précédemment lancée dans un tableau d'objets.<br>
|
|
* Note : Ce tableau est composé d'une liste de lignes.<br>Ces lignes sont elles-mêmes composées d'une liste d'objets.
|
|
* @return Tableau d'objets correspondant au résultat de la requête SQL.
|
|
*/
|
|
public Vector<Vector<Object>> getDataVector()
|
|
{
|
|
Vector<Vector<Object>> v_datas = new Vector<Vector<Object>>();
|
|
ResultSetMetaData rsmd;
|
|
|
|
try
|
|
{
|
|
rsmd = this.resultSet.getMetaData();
|
|
// Vérifie qu'il y ai un résultat et place le curseur au début
|
|
if (rsmd.getColumnCount() > 0)
|
|
{
|
|
while (this.resultSet.next())
|
|
{
|
|
Vector<Object> vo_ligne = new Vector<Object>();
|
|
// créé la ligne
|
|
for (int idCol = 1; idCol <= rsmd.getColumnCount(); idCol++)
|
|
vo_ligne.add(this.resultSet.getObject(idCol));
|
|
// ajoute la ligne au vecteur principal
|
|
v_datas.add(vo_ligne);
|
|
}
|
|
}
|
|
|
|
if (v_datas.isEmpty()) // anomalie
|
|
this.vs_anomalies.add("Aucune donnée trouvée!!");
|
|
}
|
|
catch (SQLException ex)
|
|
{
|
|
// Probleme lors de l'obtention des donnees
|
|
this.traiterSQLException(ex);
|
|
}
|
|
|
|
return v_datas;
|
|
}
|
|
|
|
/*
|
|
* GESTION DES ERREURS - ANOMALIES
|
|
*/
|
|
/**
|
|
* Trace les erreurs SQL qui ont été levées par une exception donnée.
|
|
* @param ex SQLException à tracer.
|
|
*/
|
|
public void traiterSQLException(SQLException ex)
|
|
{
|
|
String str_ex;
|
|
|
|
str_ex = "********* SQLException *********\n";
|
|
while (ex != null)
|
|
{
|
|
str_ex = "SQLState : " + ex.getSQLState() + "\n";
|
|
str_ex += "Message : " + ex.getMessage() + "\n";
|
|
str_ex += "------------------------------\n";
|
|
this.vs_erreurs.add(str_ex);
|
|
|
|
ex = ex.getNextException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Trace les anomalies SQL données.
|
|
* @param warn Anomalies SQL à tracer.
|
|
*/
|
|
public void traiterWarning(SQLWarning warn)
|
|
{
|
|
String str_an;
|
|
|
|
str_an = "********* SQLWarning *********\n";
|
|
while (warn != null)
|
|
{
|
|
str_an = "SQLState : " + warn.getSQLState() + "\n";
|
|
str_an += "Message : " + warn.getMessage() + "\n";
|
|
str_an += "------------------------------\n";
|
|
this.vs_anomalies.add(str_an);
|
|
|
|
warn = warn.getNextWarning();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère la liste des erreurs tracées.
|
|
* @return Liste des erreurs tracées.<br>Note : retourne une copie du vecteur interne pour empêcher la modification directe de celui-ci.
|
|
*/
|
|
public Vector<String> getErreurs()
|
|
{
|
|
return new Vector<String>(this.vs_erreurs);
|
|
}
|
|
|
|
/**
|
|
* Récupère la liste des anomalies tracées.
|
|
* @return Liste des anomalies tracées.<br>Note : retourne une copie du vecteur interne pour empêcher la modification directe de celui-ci.
|
|
*/
|
|
public Vector<String> getAnomalies()
|
|
{
|
|
return new Vector<String>(this.vs_anomalies);
|
|
}
|
|
|
|
/**
|
|
* Efface la liste des erreurs tracées.
|
|
*/
|
|
public void effaceErreurs()
|
|
{
|
|
this.vs_erreurs.clear();
|
|
}
|
|
|
|
/**
|
|
* Efface la liste des anomalies tracées.
|
|
*/
|
|
public void effaceAnomalies()
|
|
{
|
|
this.vs_anomalies.clear();
|
|
}
|
|
}
|