3 files changed, 216 insertions, 0 deletions

diff --git a/src/modele/dao/JDBC.java b/src/modele/dao/JDBC.java
new file mode 100644
index 0000000..3e05865
--- /dev/null
+++ b/src/modele/dao/JDBC.java
@@ -0,0 +1,92 @@
+package modele.dao;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+/**
+ * connexion avec JDBC pour utilisation par la classe fille: SQLexecutor,
+ * les paramètres de connexion et les setters sont statiques
+ *  
+ */
+abstract public class JDBC
+{
+        private static String dbms="mysql";
+        private static String strClassName = "com.mysql.cj.jdbc.Driver";
+        private static String port = "3306";
+        private static String dbname;
+        private static String login;
+        private static String password;
+        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);
+        }
+        
+        // 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;
+        }
+        public static void setDBMS(String dbms) {
+                JDBC.dbms = dbms;
+                if(dbms == "mysql")
+                {
+                        JDBC.strClassName = "com.mysql.cj.jdbc.Driver";
+                        JDBC.port = "3306";
+                }
+                else if(dbms == "mariadb")
+                {
+                        JDBC.strClassName = "org.mariadb.jdbc.Driver";
+                        JDBC.port = "3306";
+                }
+        }
+        public static void setDbName(String dbName) {
+                JDBC.dbname = dbName;
+        }
+        public static void setLogin(String login) {
+                JDBC.login = login;
+        }
+        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;
+                JDBC.login = login;
+                JDBC.password = password;
+                JDBC.host = host;
+                setDBMS(dbms);
+                JDBC.setStrUrl();
+        }
+}
diff --git a/src/modele/dao/ResultObject.java b/src/modele/dao/ResultObject.java
new file mode 100644
index 0000000..7f91824
--- /dev/null
+++ b/src/modele/dao/ResultObject.java
@@ -0,0 +1,46 @@
+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
new file mode 100644
index 0000000..484f52e
--- /dev/null
+++ b/src/modele/dao/SQLexecutor.java
@@ -0,0 +1,78 @@
+package modele.dao;
+
+import java.sql.Connection;
+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 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
+        {
+                Connection connection = null;
+            PreparedStatement statement = null;
+            ResultSet resultSet = null;
+            
+            try {
+                connection = getConnection();
+                boolean isSelect = sql.trim().toLowerCase().startsWith("select");
+                
+                statement = connection.prepareStatement(sql);
+                        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;
+                    }
+                        else {
+                                statement.executeUpdate();
+                                return null;
+                    }
+                }
+            finally {
+                        statement.close();
+            connection.close();
+            }
+        }
+        
+        /**
+         * Affecte les paramètres aux requêtes préparées.
+         * @param statement
+         * @param params Object... permet d'ajouter autant de paramètres qu'on veut et ça fait un tableau
+         * @throws SQLException en cas d'erreur SQL
+         */
+        private void setParameters(PreparedStatement statement, Object... params) throws SQLException
+        {
+                for (int i = 0; i < params.length; i++) {
+                        statement.setObject(i + 1, params[i]);
+                }
+        }
+}