2 modes connexion qui reste ouverte ou fermeture immédiateHEADmaster

3 files changed, 133 insertions, 86 deletions

diff --git a/src/modele/DAO_Test.java b/src/modele/DAO_Test.java
index bf38d97..98180ad 100644
--- a/src/modele/DAO_Test.java
+++ b/src/modele/DAO_Test.java
@@ -1,12 +1,13 @@
-/* pour tester les classes, fichier à supprimer */
+/* pour tester les classes */
 
 package modele;
 
+import java.sql.ResultSet;
+//import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.HashMap;
-
 import modele.dao.JDBC;
-import modele.dao.ResultObject;
 import modele.dao.SQLexecutor;
 
 /*
@@ -16,11 +17,12 @@ public class DAO_Test
 {
         public static void main(String[] args) throws SQLException, ClassNotFoundException
         {
-                // envoie de tous les paramètres en même temps
+                /* paramètres de la BDD à envoyer une fois au début*/
+                
+                // version envoi tout en même temps
                 JDBC.setInfos("localhost", "mysql", "tp", "root", "");
                 
-                // même chose avec envoie un par un
-                // si un paramètre doit être modifié à la volée, faire un JDBC.setStrUlr(); après 
+                // version envoie un par un, finir par un JDBC.setStrUlr(); 
                 JDBC.setHost("localhost");
                 JDBC.setDBMS("mysql");
                 JDBC.setDbName("tp");
@@ -28,27 +30,50 @@ public class DAO_Test
                 JDBC.setPassword("");
                 JDBC.setStrUrl();
                 
+                
+                /* début du contrôleur */
                 SQLexecutor executor = new SQLexecutor();
                 
-                // SELECT
-                ResultObject result = executor.executeQuery("SELECT * FROM acces WHERE id = ?", 1);
-                for(HashMap<String, Object> row : result.getData()) // foreach sur les entrées
+                
+                executor.setCopyMode(false); // mode copie désactivé (= mode normal)
+                // un SELECT produit un ResultSet
+                // ne pas oublier de fermer la connexion à la fin du contrôleur
+                executor.executeQuery("SELECT * FROM acces WHERE id = ?", 1);
+                ResultSet result1 = executor.getResultSet();
+                while(result1.next())
                 {
-                    System.out.println("prénom: " + row.get("prenom")); //un champ d'une entrée
+                        System.out.println("prénom: " + result1.getString("prenom"));
+                }
+                
+                // les requêtes INSERT, UPDATE et DELETE utilise la connexion ouverte et la laissent ouverte
+                executor.executeQuery("INSERT INTO acces (prenom, login, password, statut, age) VALUES (?, ?, ?, ?, ?)", "Dylan", "Toto", "Titi", "Etudiant", 22);
+                executor.executeQuery("UPDATE acces SET statut = ? WHERE prenom = ?", "joue à fortnite", "Dylan");
+                executor.executeQuery("DELETE FROM acces WHERE prenom = ?", "Dylan");
+
+                executor.close(); // fermeture !!
+                
+                
+                
+                executor.setCopyMode(true); // mode copie activé
+                // un SELECT produit une copie dans une array list d'hashmap
+                // la connexion est fermée automatiqument après chaque requête
+                executor.executeQuery("SELECT * FROM acces WHERE id = ?", 2);
+                ArrayList<HashMap<String, Object>> result2 = executor.getResultCopy();
+                
+                for(HashMap<String, Object> row : result2) // foreach sur les entrées
+                {
+                        // obtenir un champ d'une entrée
+                    System.out.println("prénom: " + row.get("prenom"));
                     
-                    for(HashMap.Entry<String, Object> one_field : row.entrySet()) // foreach sur les champs
+                    // tout afficher avec "foreach"
+                    for(HashMap.Entry<String, Object> one_field : row.entrySet())
                         {
                                 System.out.print(one_field.getKey() + ": " + one_field.getValue() + "\n");
                         }
                 }
 
-                // INSERT
                 executor.executeQuery("INSERT INTO acces (prenom, login, password, statut, age) VALUES (?, ?, ?, ?, ?)", "Dylan", "Toto", "Titi", "Etudiant", 22);
-
-                // UPDATE
                 executor.executeQuery("UPDATE acces SET statut = ? WHERE prenom = ?", "joue à fortnite", "Dylan");
-
-                // DELETE
                 executor.executeQuery("DELETE FROM acces WHERE prenom = ?", "Dylan");
         }
 }
diff --git a/src/modele/dao/ResultObject.java b/src/modele/dao/ResultObject.java
deleted file mode 100644
index 7f91824..0000000
--- a/src/modele/dao/ResultObject.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package modele.dao;
-
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.HashMap;
-
-/**
- * conteneur pour ResultSet dans le cas d'un SELECT,
- * les valeurs des HashMap sont des "Object" pour gérer tous les types de données
- */
-public class ResultObject
-{
-    private final ArrayList<HashMap<String, Object>> data = new ArrayList<>();
-
-    /**
-     * copie du ResultSet dans une ArrayList composée d'HashMap
-     * @param rs instance de ResultSet
-     * @throws SQLException en cas d'erreur avec le ResultSet 
-     */
-    public ResultObject(ResultSet rs) throws SQLException
-    {
-        ResultSetMetaData metaData = rs.getMetaData();
-        int columnCount = metaData.getColumnCount();
-
-        while(rs.next())
-        {
-            HashMap<String, Object> row = new HashMap<>();
-            for (int i = 1; i <= columnCount; i++)
-            {
-                row.put(metaData.getColumnName(i), rs.getObject(i));
-            }
-            data.add(row);
-        }        
-    }
-
-    /**
-     * à utiliser dans la boucle permettant de parcourir la liste
-     * @return retourne la liste encapsulée
-     */
-    public ArrayList<HashMap<String, Object>> getData()
-    {
-        return data;
-    }
-}
diff --git a/src/modele/dao/SQLexecutor.java b/src/modele/dao/SQLexecutor.java
index 484f52e..686928a 100644
--- a/src/modele/dao/SQLexecutor.java
+++ b/src/modele/dao/SQLexecutor.java
@@ -3,7 +3,10 @@ package modele.dao;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
 
 /**
  * exécuter des requêtes SQL:
@@ -12,54 +15,83 @@ import java.sql.SQLException;
  */
 public class SQLexecutor extends JDBC
 {
-        // constructeur par défaut
+        Connection connection = null;
+    PreparedStatement statement = null;
+    ResultSet resultSet = null;
+    
+        private boolean copy_mode = false;
+        ArrayList<HashMap<String, Object>> result_copy = null;
+        
+        // utilise le contructeur par défaut de java
+        
+        /**
+         * retourne un ResultSet
+         * @return ResultSet
+         */
+        public ResultSet getResultSet()
+        {
+                return resultSet;
+        }
+        /**
+         * retourne une ArrayList d'HashMap
+         * @return ArrayList d'HashMap
+         */
+        public ArrayList<HashMap<String, Object>> getResultCopy()
+        {
+                return result_copy;
+        }
+        
+        /**
+         * choisir si dans le cas d'un SELECT executeQuery doit retourner une copie du ResultSet
+         * @param rc copy_mode
+         */
+        public void setCopyMode(boolean rc)
+        {
+                copy_mode = rc;
+        }
         
         /**
          * Exécute une requête SQL et retourne le résultat si applicable.
          * @param sql requête avec des ?
          * @param params nombre libre de paramètres, "Object..." permet de créer un tableau à partir des paramètres
-         * @return ResultSet si la requête est un SELECT, null sinon
          * @throws SQLException en cas d'erreur SQL
          * @throws ClassNotFoundException pour DriverManager.getConnection
          */
-        public ResultObject executeQuery(String sql, Object... params) throws SQLException, ClassNotFoundException
+        public void executeQuery(String sql, Object... params) throws SQLException, ClassNotFoundException
         {
-                Connection connection = null;
-            PreparedStatement statement = null;
-            ResultSet resultSet = null;
-            
+                boolean isSelect = sql.trim().toLowerCase().startsWith("select");
             try {
-                connection = getConnection();
-                boolean isSelect = sql.trim().toLowerCase().startsWith("select");
+                if(connection == null)
+                {
+                        connection = getConnection();
+                }
                 
                 statement = connection.prepareStatement(sql);
-                        if (params.length > 0)
+                        if(params.length > 0)
                         {
-// if(isSelect)
-// => ResultSet.TYPE_SCROLL_INSENSITIVE;
-// navigation possible dans le ResultSet: next(), previous(), absolute();
-// ResultSet non modifiable en cas d'accès concurrent en mémoire
-// => PreparedStatement.NO_GENERATED_KEYS;
-// optimisation en ne retournant pas les clé générés lors d'un INSERT (RETURN_GENERATED_KEYS)
-// statement = connection.prepareStatement(sql, isSelect ? ResultSet.TYPE_SCROLL_INSENSITIVE : PreparedStatement.NO_GENERATED_KEYS);
-                                
                                 this.setParameters(statement, params);
                         }
                         
                         if(isSelect) {
                                 resultSet = statement.executeQuery();
-                                ResultObject result = new ResultObject(resultSet);
-                                resultSet.close();
-                                return result;
+                                if(copy_mode)
+                                {
+                                        result_copy = null;
+                                        result_copy = copyInArrayListHashMap(resultSet);
+                                        resultSet.close();
+                                }
                     }
                         else {
                                 statement.executeUpdate();
-                                return null;
                     }
                 }
             finally {
-                        statement.close();
-            connection.close();
+                if(copy_mode)
+                    {
+                        statement.close();
+                    connection.close();
+                    connection = null;
+                    }
             }
         }
         
@@ -75,4 +107,40 @@ public class SQLexecutor extends JDBC
                         statement.setObject(i + 1, params[i]);
                 }
         }
+        
+        /**
+         * copie du ResultSet dans une ArrayList de HashMap
+         * @param rs
+         * @return
+         * @throws SQLException
+         */
+        private ArrayList<HashMap<String, Object>> copyInArrayListHashMap(ResultSet rs) throws SQLException
+    {
+        ResultSetMetaData metaData = rs.getMetaData();
+        int columnCount = metaData.getColumnCount();
+        ArrayList<HashMap<String, Object>> result = new ArrayList<HashMap<String, Object>>();
+
+        while(rs.next())
+        {
+            HashMap<String, Object> row = new HashMap<>();
+            for (int i = 1; i <= columnCount; i++)
+            {
+                row.put(metaData.getColumnName(i), rs.getObject(i));
+            }
+            result.add(row);
+        }
+        return result;
+    }
+        
+        /**
+         * fermeture de la connexion et effacement de l'objet pour réutilisation
+         * @throws SQLException
+         */
+        public void close() throws SQLException
+        {
+                resultSet.close();
+                statement.close();
+                connection.close();
+                connection = null;
+        }
 }