release candidate 2

4 files changed, 88 insertions, 68 deletions

diff --git a/src/DAO_Test.java b/src/DAO_Test.java
index aa6a0af..673f2b7 100644
--- a/src/DAO_Test.java
+++ b/src/DAO_Test.java
@@ -6,21 +6,34 @@ import dao.JDBC;
 import dao.ResultObject;
 import dao.SQLexecutor;
 
+/*
+ * fonction main pour tester des commandes
+ */
 public class DAO_Test
 {
         public static void main(String[] args) throws SQLException, ClassNotFoundException
         {
+                // envoie de tous les paramètres 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 
+                JDBC.setHost("localhost");
+                JDBC.setDBMS("mysql");
+                JDBC.setDbName("tp");
+                JDBC.setLogin("root");
+                JDBC.setPassword("");
+                JDBC.setStrUrl();
+                
                 SQLexecutor executor = new SQLexecutor();
                 
                 // SELECT
                 ResultObject result = executor.executeQuery("SELECT * FROM acces WHERE id = ?", 1);
-                for(HashMap<String, Object> row : result.getData())
+                for(HashMap<String, Object> row : result.getData()) // foreach sur les entrées
                 {
-                    System.out.println("prenom: " + row.get("prenom")); // une entrée
+                    System.out.println("prénom: " + row.get("prenom")); //un champ d'une entrée
                     
-                    // foreach sur toutes les entrées
-                    for(HashMap.Entry<String, Object> one_field : row.entrySet())
+                    for(HashMap.Entry<String, Object> one_field : row.entrySet()) // foreach sur les champs
                         {
                                 System.out.print(one_field.getKey() + ": " + one_field.getValue() + "\n");
                         }
diff --git a/src/dao/JDBC.java b/src/dao/JDBC.java
index 714803e..324ff2d 100644
--- a/src/dao/JDBC.java
+++ b/src/dao/JDBC.java
@@ -5,9 +5,9 @@ import java.sql.DriverManager;
 import java.sql.SQLException;
 
 /**
- * connexion à la BDD avec JDBC
- * tous les paramètres de connexion et les setters sont statiques
- * le nom de la table sélectionnée est dans ModelCRUD 
+ * connexion avec JDBC pour utilisation par la classe fille: SQLexecutor,
+ * les paramètres de connexion et les setters sont statiques
+ *  
  */
 abstract public class JDBC
 {
@@ -20,25 +20,31 @@ abstract public class JDBC
         private static String host= "localhost";
         private static String strUrl;
         
+        /**
+         * retourne une instance de Connection avec JDBC
+         * @return instance de Connection
+         * @throws SQLException en cas d'erreur de connexion
+         * @throws ClassNotFoundException pour Class.forName()
+         */
         protected Connection getConnection() throws SQLException, ClassNotFoundException
         {
                 Class.forName(strClassName);
                 return DriverManager.getConnection(strUrl, login, password);
-//              try {
-//                      Class.forName(strClassName); // chargement du driver
-//                      return DriverManager.getConnection(strUrl, login, password);
-//              }
-//              catch(ClassNotFoundException e) {  
-//                      System.err.println("Driver non chargé !");
-//                      e.printStackTrace();
-//              }
-//              catch(SQLException e) {
-//                      e.printStackTrace();
-//              }
-//              return null;
         }
         
         // setters
+        /**
+         * génère l'url utilisée par le driver,
+         * à n'exécuter que lorsque tous les paramètres ont été renseignés (en particulier dbname, login et password),
+         * certains: host, dbms, strClassName et port ont des valeurs par défaut pour un serveur mysql sur localhost
+         */
+        public static void setStrUrl() {
+                if(dbname != null && login != null && password != null) {
+                        JDBC.strUrl = "jdbc:" + dbms + "://" + host + ":" + port + "/" +  dbname;
+                }
+                else System.out.print("il manque des paramètres nécéssaires à la connexion au driver");
+        }
+        
         public static void setHost(String host) {
                 JDBC.host = host;
         }
@@ -55,18 +61,25 @@ abstract public class JDBC
                         JDBC.port = "3306";
                 }
         }
-        private static void setStrUrl() {
-                JDBC.strUrl = "jdbc:" + dbms + "://" + host + ":" + port + "/" +  dbname;
-        }
         public static void setDbName(String dbName) {
                 JDBC.dbname = dbName;
         }
         public static void setLogin(String login) {
                 JDBC.login = login;
         }
-        public static void setMotdepasse(String motdepasse) {
+        public static void setPassword(String motdepasse) {
                 JDBC.password = motdepasse;
         }
+        
+        /**
+         * donner tous les paramètres de connexion en une fois
+         * il est également possible de les donner un par un avec les setters en finissant pas JDBC.setStrUrl()
+         * @param host adresse du serveur
+         * @param dbms obtenir le nom du driver et le numéro du port à partir du nom du SGBD
+         * @param dbname de la base de données
+         * @param login nom d'utilisateur
+         * @param password mot de passe
+         */
         public static void setInfos(String host, String dbms, String dbname, String login, String password)
         {
                 JDBC.dbname = dbname;
@@ -76,15 +89,4 @@ abstract public class JDBC
                 setDBMS(dbms);
                 JDBC.setStrUrl();
         }
-        
-//      public void close()
-//      {
-//              try {
-//                      this.conn.close(); // libérer le slot (même principe que l'attaque DDOS)
-//                      this.conn = null; // pour pouvoir réinstancier avec d'autres paramètres
-//              }
-//              catch (SQLException e) {
-//                      e.printStackTrace();
-//              }
-//      }
 }
diff --git a/src/dao/ResultObject.java b/src/dao/ResultObject.java
index e41af0b..1df9d88 100644
--- a/src/dao/ResultObject.java
+++ b/src/dao/ResultObject.java
@@ -5,12 +5,20 @@ import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 
+/**
+ * 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 List<HashMap<String, Object>> data = new ArrayList<>();
+    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();
@@ -24,15 +32,14 @@ public class ResultObject
                 row.put(metaData.getColumnName(i), rs.getObject(i));
             }
             data.add(row);
-        }
-
-//        rs.close();
-//        rs.getStatement().close();
-//        rs.getStatement().getConnection().close();
-        
+        }        
     }
 
-    public List<HashMap<String, Object>> getData()
+    /**
+     * à 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/dao/SQLexecutor.java b/src/dao/SQLexecutor.java
index 8f7f130..430c1c0 100644
--- a/src/dao/SQLexecutor.java
+++ b/src/dao/SQLexecutor.java
@@ -5,13 +5,20 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
+/**
+ * exécuter des requêtes SQL:
+ * connexion avec JDBC => préparation de la requête => exécution
+ * => copie du ResultSet dans une ArrayList d'HashMap => fermeture de la connexion 
+ */
 public class SQLexecutor extends JDBC
 {
+        // constructeur par défaut
+        
         /**
          * Exécute une requête SQL et retourne le résultat si applicable.
          * @param sql requête avec des ?
-         * @param params Object... permet d'ajouter autant de paramètres qu'on veut et ça fait un tableau
-         * @return Un ResultSet si la requête est un SELECT, sinon null
+         * @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
          */
@@ -24,26 +31,19 @@ public class SQLexecutor extends JDBC
             try {
                 connection = getConnection();
                 boolean isSelect = sql.trim().toLowerCase().startsWith("select");
-        
+                
+                statement = connection.prepareStatement(sql);
                         if (params.length > 0)
                         {
-                                int option;
-                                if(isSelect)
-                                {
-                                        option = ResultSet.TYPE_SCROLL_INSENSITIVE;
-                                        // navigation possible dans le ResultSet: next(), previous(), absolute();
-                                        // ResultSet non modifiable en cas d'accès concurrent en mémoire
-                                }
-                                else
-                                {
-                                        option = 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, option);
-                                        //isSelect ? ResultSet.TYPE_SCROLL_INSENSITIVE : PreparedStatement.NO_GENERATED_KEYS);
+// 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);
-                        } else {
-                                statement = connection.prepareStatement(sql);
                         }
                         
                         if(isSelect) {
@@ -51,17 +51,15 @@ public class SQLexecutor extends JDBC
                                 ResultObject result = new ResultObject(resultSet);
                                 resultSet.close();
                                 return result;
-                    } else {
+                    }
+                        else {
                                 statement.executeUpdate();
                                 return null;
                     }
-                } finally {
+                }
+            finally {
                         statement.close();
             connection.close();
-//                  if (resultSet == null) {
-//                      statement.close();
-//                  connection.close();
-//              }
             }
         }