Introduction
JDBC
Pour se connecter à une base de données avec Java
Il nous faut un JDBC (qui varie selon le SGBD utilisé)
JDBC : Java DataBase Connectivity
SGBD : Système de Gestion de Bases de données
Introduction
JDBC
Pour se connecter à une base de données avec Java
Il nous faut un JDBC (qui varie selon le SGBD utilisé)
JDBC : Java DataBase Connectivity
SGBD : Système de Gestion de Bases de données
JDBC ?
API (interface d’application) créée par Sun Microsystems
Permettant de communiquer avec les bases de données
Introduction
JDBC
JDBC
API de JSE
Permettant la connexion et l’exécution de requêtes SQL depuis un programme
Java
Composé de
Driver
DriverManager
Connection
Statement
ResultSet
SQLException
...
Mise en place
JDBC
JDBC 8.0.31
Aller à
https://dev.mysql.com/downloads/file/?id=513754
Télécharger et Décompresser l’archive .zip
Mise en place
JDBC
Intégrer le driver dans votre projet
Faire un clic droit sur le nom du projet et aller dans New >
Folder
Renommer le répertoire lib puis valider
Copier le .jar de l’archive décompressée dans lib
Mise en place
Ajouter JDBC au path du projet
Faire clic droit sur .jar qu’on a placé dans lib
Aller dans Build Path et choisir Add to Build Path
Mise en place
Ajouter JDBC au path du projet
Faire clic droit sur .jar qu’on a placé dans lib
Aller dans Build Path et choisir Add to Build Path
Ou aussi
Faire clic droit sur le projet dans Package Explorer et aller dans
Properties Properties
Dans Java Build Path, aller dans l’onglet Libraries
Cliquer sur Add JARs
Indiquer le chemin du .jar qui se trouve dans le répertoire lib du projet
Appliquer
Mise en place
Ajouter JDBC au path du projet
Faire clic droit sur .jar qu’on a placé dans lib
Aller dans Build Path et choisir Add to Build Path
Ou aussi
Faire clic droit sur le projet dans Package Explorer et aller dans
Properties Properties
Dans Java Build Path, aller dans l’onglet Libraries
Cliquer sur Add JARs
Indiquer le chemin du .jar qui se trouve dans le répertoire lib du projet
Appliquer
Vérifier qu’une section Referenced Libraries a apparu.
Utilisation
JDBC
Avant de commencer, voici le script SQL qui permet de créer la base de
données utilisée dans ce cours
CREATE DATABASE cours_jdbc;
USE cours_jdbc;
CREATE TABLE personne (
num INT PRIMARY KEY AUTO_INCREMENT,
nom VARCHAR(30),
prenom VARCHAR(30)
)ENGINE = InnoDB;
SHOW TABLES;
INSERT INTO personne (nom, prenom) VALUES ("Wick", "John"),
("Dalton", "Jack");
SELECT * FROM personne;
Utilisation
JDBC
Trois étapes
Charger le driver JDBC (pour MySQL dans notre cas)
Établir la connexion avec la base de données
Créer et exécuter des requêtes SQL
Utilisation
JDBC
Avant de commencer
Tous les imports de ce chapitre sont de java.sql.*;
Utilisation
JDBC
Chargement du driver 5
try {
Class.forName("com.mysql.jdbc.Driver");
}
catch (ClassNotFoundException e){
System.out.println("Erreur " + e.getMessage());
}
Ou
try {
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
}
catch (ClassNotFoundException e) {
System.out.println("Erreur " + e.getMessage());
}
Utilisation
JDBC
Chargement du driver 8
try {
Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e){
System.out.println("Erreur " + e.getMessage());
}
Ou
try {
DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
}
catch (ClassNotFoundException e) {
System.out.println("Erreur " + e.getMessage());
}
Utilisation
JDBC
Se connecter à la base de données
Pour se connecter à la base de données, il faut spécifier une URL de la forme
jdbc:mysql://hote:port/nombd
hote : adresse du serveur MySQL (dans notre cas localhost ou
127.0.0.1)
port : port TCP/IP utilisé par MySQL (par défaut est 3306)
nombd : le nom de la base de données MySQL
Il faut aussi le nom d’utilisateur et son mot de passe (qui permettent de se
connecter à la base de données MySQL)
Utilisation
JDBC
Connexion à la base
String url = "jdbc:mysql://localhost:3306/cours_jdbc";
String user = "root";
String password = "";
Connection connexion = null;
try {
connexion = DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (connexion != null)
try {
connexion.close();
} catch (SQLException ignore) {
ignore.printStackTrace();}
}
Utilisation
JDBC
En cas de problème avec le chargement du driver, modifier l’URL
de connexion ainsi :
String url =
"jdbc:mysql://localhost:3306/jdbc?useSSL=false&
serverTimezone=UTC";
Utilisation
JDBC
Préparation et exécution de la requête
// création de la requête (statement)
Statement statement = connexion.createStatement();
// Préparation de la requête
String request = "SELECT * FROM Personne;";
// Exécution de la requête
ResultSet result = statement.executeQuery(request);
Utilisation
JDBC
Préparation et exécution de la requête
// création de la requête (statement)
Statement statement = connexion.createStatement();
// Préparation de la requête
String request = "SELECT * FROM Personne;";
// Exécution de la requête
ResultSet result = statement.executeQuery(request);
On utilise
execute() pour les requêtes de création : CREATE.
executeQuery() pour les requêtes de lecture : SELECT.
executeUpdate() pour les requêtes d’écriture : INSERT, UPDATE et DELETE.
Restructuration du code Classes connexion et dao
JDBC
ResultSet
C'est une classe qui représente une abstraction d'une table qui se
compose de plusieurs enregistrements constitués de colonnes qui
contiennent les données.
Les
l
principales méthodes pour obtenir des données sont :
- Pour parcourir les résultats stockées dans ResultSet on utilise la
méthode next()
- La méthode next()déplace le curseur sur le prochain enregistrement.
- Le curseur pointe initialement juste avant le premier enregistrement
- Les méthodes getXXX() permettent d'extraire les données selon leur
type spécifié par XXX tel que getString(),getFloat(),getInt()
Utilisation
JDBC
Récupération des données
Statement statement = connexion.createStatement();
String request = "SELECT * FROM Personne;";
ResultSet result = statement.executeQuery(request);
while (result.next()) {
// on indique chaque fois le nom de la colonne
et le type
int num = result.getInt("num");
String nom = result.getString("nom");
String prenom = result.getString("prenom");
System.out.println(num + " " + nom + " " + prenom);
}
Utilisation
JDBC
Ou aussi son indice dans la table
while (result.next()) {
int num = result.getInt(1);
String nom = result.getString(2);
String prenom = result.getString(3);
System.out.println(num + " " + nom + " " + prenom);
}
Utilisation
JDBC
Pour faire une insertion
Statement statement = connexion.createStatement();
String request = "INSERT INTO Personne (nom,prenom)
VALUES('Wick','John');";
int nbr = statement.executeUpdate(request);
if (nbr!=0){
System.out.println("insertion réussie");
}
Utilisation
JDBC
Pour faire une insertion
Statement statement = connexion.createStatement();
String request = "INSERT INTO Personne (nom,prenom)
VALUES('Wick','John');";
int nbr = statement.executeUpdate(request);
if (nbr!=0){
System.out.println("insertion réussie");
}
La méthode executeUpdate()retourne
0 en cas d’échec de la requête
Le nombre de lignes respectivement inserées, mises à jour ou
supprimées
Utilisation
JDBC
Pour récupérer la valeur de la clé primaire auto-générée
Statement statement = connexion.createStatement();
String request = "INSERT INTO Personne(nom,prenom)VALUES
('Wick','John');";
// on demande le renvoi des valeurs attribuées à la clé primaire
statement.executeUpdate(request,
Statement.RETURN_GENERATED_KEYS);
//on parcourt les valeurs attribuées à l'ensemble de tuples ajoutés
ResultSet resultat = statement.getGeneratedKeys();
//on vérifie s'il contient au moins une valeur
if(resultat.next()){
System.out.println("Identifiant généré pour la personne:"
+resultat.getInt(1));
}
Utilisation
JDBC
Pour éviter les injections SQL, il faut utiliser les requêtes préparées
String request = "INSERT INTO Personne (nom,prenom) VALUES
(?,?);";
PreparedStatement ps = connexion.prepareStatement
(request,PreparedStatement.RETURN_GENERATED_KEYS);
ps.setString(1,"Wick");
ps.setString(2,"John");
ps.executeUpdate();
ResultSet resultat = ps.getGeneratedKeys();
if(resultat.next()){
System.out.println("Identifiant genere pour la personne:"
+resultat.getInt(1));
}
Attention à l’ordre des attributs
Restructuration du code Classes connexion et DAO
JDBC
Organisation du code
Il faut mettre toutes les données (url, user, password...) relatives
à notre connexion dans une classe connexion
Pour chaque table de la base de données, on crée une classe
java ayant comme attributs les colonnes de cette table
Il faut mettre tout le code correspondant à l’accès aux données
(de la base de données) dans des nouvelles classes et interfaces
(qui constitueront la couche DAO : Data Access Object)
Restructuration du code Classes connexion et DAO
JDBC
La classe MyConnection
package org.eclipse.config;
import java.sql.Connection;
import java.sql.DriverManager;
public class MyConnection {
private static Connection connexion = null;
public static Connection getConnection() {
try{
String url = "jdbc:mysql://localhost:3306/cours_jdbc?";
String user = "root";
String pw = "";
Class.forName("com.mysql.cj.jdbc.Driver");
connexion = DriverManager.getConnection(url,user,pw);
}catch(Exception e){
e.printStackTrace();
}
return connexion;
}
}
Restructuration du code Classes connexion et DAO
JDBC
La classe Personne
package org.eclipse.model;
public class Personne {
private int num;
private String nom;
private String prenom;
// + getters + setters + constructeur sans param
ètre + constructeur avec 2 paramètres nom et
prénom + constructeur avec 3 paramètres
}
Restructuration du code Classes connexion et DAO
JDBC
L’interface PersonneDao
package org.eclipse.dao;
import java.util.List;
import org.eclipse.model.Personne;
public interface PersonneDao {
Personne save(Personne personne);
boolean remove(Personne personne);
boolean update(Personne personne);
Personne findById(int id);
ArrayList<Personne> getAll();
}
Restructuration du code Classes connexion et DAO
JDBC
Déclarons une classe PersonneDaoImpl dans org.eclipse.dao
public class PersonneDaoImpl implements PersonneDao {
}
Restructuration du code Classes connexion et DAO
JDBC
Implémentons la méthode save
@Override
public Personne save(Personne personne) {
Connection c = MyConnection.getConnection();
try {
PreparedStatement ps = c.prepareStatement("INSERT INTO personne (nom,
prenom) VALUES (?,?); ", PreparedStatement.RETURN_GENERATED_KEYS);
ps.setString(1, personne.getNom());
ps.setString(2, personne.getPrenom());
ps.executeUpdate();
ResultSet resultat = ps.getGeneratedKeys();
if (resultat.next()) {
personne.setNum(resultat.getInt(1));
return personne;
}
} catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
c.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
Restructuration du code Classes connexion et DAO
JDBC
La méthode findById
@Override
public Personne findById(int id) {
Personne personne = null;
Connection c = MyConnection.getConnection();
if (c != null) {
try {
String request = "SELECT * FROM personne WHERE num = ?;";
PreparedStatement ps = c.prepareStatement(request);
ps.setInt(1, id);
ResultSet r = ps.executeQuery();
if (r.next())
personne = new Personne(r.getInt("num"), r.getString("nom"), r.
getString("prenom"));
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
c.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return personne;
}
Restructuration du code Classes connexion et DAO
Le Main pour tester toutes ces classes
package org.eclipse.classes;
import org.eclipse.dao.PersonneDaoImpl;
import org.eclipse.model.Personne;
public class Main {
public static void main(String args []) {
PersonneDaoImpl personneDaoImpl = new PersonneDaoImpl();
Personne personne = new Personne ("Wick", "John");
Personne insertedPersonne = personneDaoImpl.save(personne);
if (insertedPersonne != null) {
System.out.println("personne numéro " + insertedPersonne.getNum()
+ " a été insérée");
} else {
System.out.println("problème d'insertion");
}
}
}
