Tutoriel Java JDBC

View more Tutorials:

1- La base de données utilisée dans ce document

Ce document vous donnera des instructions de l'utilisation de à la base donnée (database).
Le modèle de la base des données est utilisé dans ce document est  "simplehr".  Vous pouvez afficher le script de la création la base donnée (database) sur  :

2- Qu'est-ce que JDBC?

Java Database Connectivity ( JDBC) est un Java API standard utilisé pour interagir avec toutes les formes de bases données relationnelles. JDBC dispose d'un ensemble de classes et d'interfaces qui peuvent utiliser dans des applications Java pour communiquer avec la base des données.
Les composants de l'Api JDBC se composent essentiellement de :
  1. DriverManager:
    • Est une classe, il est utilisé pour gérer la liste de Driver (database drivers). 
  2. Driver:
    • est une Interface,il est utilisé pour relier la base de données avec des liens. Une fois le driver est téléchargé, le programmeur ne doit pas appeler ouvertement.

  3. Connection :
    • Est une Interface avec toutes les méthodes de communication avec la base de données. L'objet de connexion représente le contexte de communication i.e.,. Toutes les communications avec la base donnée se fait par l'objet de Connexion uniquement.
  4. Statement :
    • Incarne une déclaration SQL qui est envoyée à la base donnée pour analyser, compiler, planifier et mettre en oeuvre.
  5. ResultSet :
    • ResultSet représente l’ensemble des éléments récupérés par l’exécution de la requête.

3- Comment connecter l'application Java avec une base de données ?

Java  utilise JDBC pour travailler avec des bases données.
Par exemple, lorsque vous travaillez avec la base de données Oracle de Java, vous devez avoir le pilote (Driver) (qui est la classe de connexion avec les types de base de données souhaité). Dans l’ API JDBC nous avons java.sql.Driver, c’est juste une interface et elle est disponible dans le JDK. Il faut donc télécharger la bibliothèque pilote (Driver) pour le type de base donné (Database) que vous désirez.
  •   Par exemple avec Oracle, puis la classe implémente l’Interface  java.sql.Driver qui est OracleDriver
Java.sql.DriverManager est une classe dans API JDBC. Cette classe gère des pilotes (Driver).
Vous voyez l'illustration ci-dessous :
Nous avons 2 façons de travailler avec une base de données spécifique.
  • Option 1 : Vous fournissez les types de bases donnés à la bibliothèque Driver, c'est la façon directe. Si vous utilisez une DB oracle (ou autre DB) vous devez télécharger les bibliothèques pour le type DB.
  • Option 2 : Déclarez un "ODBC DataSource" et utilisez le pont JDBC-ODBC pour se connecter à la "ODBC DataSource" autre. Le pont JDBC-ODBC est disponible dans JDBC API.
Notre question est " ODBC DataSource" est quoi?

ODBC - Open Database Connectivity : il est un ensemble de bibliothèque ouverte qui est possibille de se connecter à presque tous les types de bases données différents et il est gratuit. Fourni par Microsoft.
ODBC DataSource : Sur les systèmes d'exploitation de Windows, vous pouvez déclarer une connexion ODBC à un certain type de DB. Et nous avons donc une source de données (Data Source).

Dans JDBC API, un pont JDBC-ODBC a été construit pour que JDBC puisse travailler avec ODBC Data Source.
Concernant la vitesse, la première option est plus vite que la deuxième car la deuxième doit utiliser le pont.

4- Télécharger quelques JDBC Driver importants

Si vous ne voulez pas utiliser  JDBC-ODBC, vous pouvez vous connecter directement à la base de données. Dans ce cas, vous devez télécharger le Driver compatible avec chaque catégorie de la base de données. Ici je vous donne des instructions de téléchargement un type de Driver pour une base de données courante  :
  • Oracle
  • MySQL
  • SQLServer
  • ....
Vous pouvez voir les instructions à :
Le résultat est que nous avons quelques fichiers :

5- Créer un project pour commencer avec l'exemple JDBC

Créez un projet JavaJdbcTutorial :
Créez un dossier  libs sur le projet et copiez des bibliothèques puis connectez-les directement avec les type de base donné Oracle  MySQL, SQLServer que vous venez de télécharger qui se trouve au-dessus. Vous pouvez copier toutes ou une des bibliothèques compatibles avec le type de la DB que vous utilisez.
Remarque : vous devez seulement télécharger un Driver équivalent pour le type de base de données avec laquelle vous vous familiarisez. Vous pouvez obtenir la base de données utilisée pour l'exemple dans ce document à :
Faites un clic droit  sur Project puis sélectionnez Properties :
Maintenant, vous pouvez être prêt à travailler avec une de la base de données (Database) ( Oracle, MySQL, SQLServer)

6- Connection

Dans ce document, je vous donnerai des instructions de connexion à tous les trois types de base donnés (database) :
  • MySQL
  • SQLServer
  • Oracle
En pratiquant, vous devez uniquement travailler avec un DB à laquelle vous êtes familier.
Créez la classe utilitaire  ConnectionUtils pour obtenir Connection.
ConnectionUtils.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.SQLException;

public class ConnectionUtils {

    public static Connection getMyConnection() throws SQLException,
            ClassNotFoundException {
  
        // Using Oracle
        // You may be replaced by other Database.
        return OracleConnUtils.getOracleConnection();
    }

    //
    // Test Connection ...
    //
    public static void main(String[] args) throws SQLException,
            ClassNotFoundException {

        System.out.println("Get connection ... ");

        // Get a Connection object
        Connection conn = ConnectionUtils.getMyConnection();

        System.out.println("Get connection " + conn);

        System.out.println("Done!");
    }

}
OracleConnUtils.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class OracleConnUtils {

    // Connect to Oracle.
    public static Connection getOracleConnection() throws SQLException,
            ClassNotFoundException {
        String hostName = "localhost";
        String sid = "db11g";
        String userName = "simplehr";
        String password = "1234";

        return getOracleConnection(hostName, sid, userName, password);
    }

    public static Connection getOracleConnection(String hostName, String sid,
            String userName, String password) throws ClassNotFoundException,
            SQLException {
       
        // Declare the class Driver for ORACLE DB
        // This is necessary with Java 5 (or older)
        // Java6 (or newer) automatically find the appropriate driver.
        // If you use Java> 5, then this line is not needed.        
        Class.forName("oracle.jdbc.driver.OracleDriver");

        String connectionURL = "jdbc:oracle:thin:@" + hostName + ":1521:" + sid;

        Connection conn = DriverManager.getConnection(connectionURL, userName,
                password);
        return conn;
    }
}
MySQLConnUtils.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MySQLConnUtils {


   // Connect to MySQL
   public static Connection getMySQLConnection() throws SQLException,
           ClassNotFoundException {
       String hostName = "localhost";

       String dbName = "simplehr";
       String userName = "root";
       String password = "1234";

       return getMySQLConnection(hostName, dbName, userName, password);
   }

   public static Connection getMySQLConnection(String hostName, String dbName,
           String userName, String password) throws SQLException,
           ClassNotFoundException {
       // Declare the class Driver for MySQL DB
       // This is necessary with Java 5 (or older)
       // Java6 (or newer) automatically find the appropriate driver.
       // If you use Java> 5, then this line is not needed.
       Class.forName("com.mysql.jdbc.Driver");

       String connectionURL = "jdbc:mysql://" + hostName + ":3306/" + dbName;

       Connection conn = DriverManager.getConnection(connectionURL, userName,
               password);
       return conn;
   }
}
SQLServerConnUtils_JTDS.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class SQLServerConnUtils_JTDS {


   // Connect to SQLServer
   // (Using JDBC Driver of JTDS library)
   public static Connection getSQLServerConnection()
           throws SQLException, ClassNotFoundException {
       String hostName = "localhost";
       String sqlInstanceName = "SQLEXPRESS";
       String database = "simplehr";
       String userName = "sa";
       String password = "1234";

       return getSQLServerConnection(hostName, sqlInstanceName, database,
               userName, password);
   }

   // Connect to SQLServer & using JTDS library
   public static Connection getSQLServerConnection(String hostName,
           String sqlInstanceName, String database, String userName,
           String password) throws ClassNotFoundException, SQLException {

       // Declare the class Driver for SQLServer DB
       // This is necessary with Java 5 (or older)
       // Java6 (or newer) automatically find the appropriate driver.
       // If you use Java> 5, then this line is not needed.        
       Class.forName("net.sourceforge.jtds.jdbc.Driver");

       // Example:
       // jdbc:jtds:sqlserver://localhost:1433/simplehr;instance=SQLEXPRESS
       String connectionURL = "jdbc:jtds:sqlserver://" + hostName + ":1433/"
               + database + ";instance=" + sqlInstanceName;

       Connection conn = DriverManager.getConnection(connectionURL, userName,
               password);
       return conn;
   }

}
SQLServerConnUtils_SQLJDBC.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class SQLServerConnUtils_SQLJDBC {

   // Connect to SQLServer
   // (Using JDBC Driver: SQLJDBC)
   public static Connection getSQLServerConnection()
           throws SQLException, ClassNotFoundException {
       String hostName = "localhost";
       String sqlInstanceName = "SQLEXPRESS";
       String database = "simplehr";
       String userName = "sa";
       String password = "1234";

       return getSQLServerConnection(hostName, sqlInstanceName,
               database, userName, password);
   }

   //
   // Connect to SQLServer & using SQLJDBC Library.
   public static Connection getSQLServerConnection(String hostName,
           String sqlInstanceName, String database, String userName,
           String password) throws ClassNotFoundException, SQLException {
       
       // Declare the class Driver for SQLServer DB
       // This is necessary with Java 5 (or older)
       // Java6 (or newer) automatically find the appropriate driver.
       // If you use Java> 5, then this line is not needed.        
       Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");


       // jdbc:sqlserver://ServerIp:1433/SQLEXPRESS;databaseName=simplehr
       String connectionURL = "jdbc:sqlserver://" + hostName + ":1433"
               + ";instance=" + sqlInstanceName + ";databaseName=" + database;

       Connection conn = DriverManager.getConnection(connectionURL, userName,
               password);
       return conn;
   }

}
ODBCConnUtils.java
package org.o7planning.tutorial.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ODBCConnUtils {

    // Connect to ODBC Data Source named "simplehr-ds".
    public static Connection getJdbcOdbcConnection() throws SQLException,
            ClassNotFoundException {
        String odbcDataSourceName = "simplehr-ds";
        String userName = "simplehr";
        String password = "simplehr";
        return getJdbcOdbcConnection(odbcDataSourceName, userName, password);
    }

    public static Connection getJdbcOdbcConnection(String odbcDataSourceName,
            String userName, String password) throws SQLException,
            ClassNotFoundException {
 
        // Declare the class Driver for JDBC-ODBC Bridge
        // This is necessary with Java 5 (or older)
        // Java6 (or newer) automatically find the appropriate driver.
        // If you use Java> 5, then this line is not needed.        
        Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

        String connectionURL = "jdbc:odbc:" + odbcDataSourceName;

        Connection conn = DriverManager.getConnection(connectionURL, userName,
                password);
        return conn;
    }
}
Vous pouvez modifier la classe  ConnectionUtils pour se connecter à la base de données que vous êtes habitué et exécutez cette classe pour tester la connexion.
Remarque  : Si vous utilisez MySQL ou SQL Server par défaut deux bases de données ne peuvent pas de se connecter à partir d'une adresse IP différente.. Vous devez les configurer pour que cette connexion soit autorisée. Vous pouvez voir les instructions de l'installation et de la configuration de MySQL, SQL Server sur o7planning.
Installez et configurez  MySQL Community :
Installez et configurez SQL Server :

7- Utilisation de JDBC API pour demander des données

Ceci sont des données dans le tableau Employee. Nous allons voir comment Java comment demander données à travers un exemple :
ResultSet  est un objet Java, il est renvoyé quand vous requêtez des données. Utilisez ResultSet.next() pour déplacer le curseur jusqu'à les rapports suivant (déplacer la ligne). Dans un certain enregistrement, vous utilisez des méthodes ResultSet.getXxx() pour récupérer les valeurs dans les colonnes. Les colonnes ont été arrangées par l'ordre 1,2,3...
** ResultSet **
public String getString(int columnIndex) throws SQLException;
public boolean getBoolean(int columnIndex) throws SQLException;
public int getInt(int columnIndex) throws SQLException;
public double getDouble(int columnIndex) throws SQLException;

...

public String getString(String columnLabel) throws SQLException;
public boolean getBoolean(String columnLabel) throws SQLException;
public int getInt(String columnLabel) throws SQLException;
public double getDouble(String columnLabel) throws SQLException;

....
Exemple d'illustration :
QueryDataExample.java
package org.o7planning.tutorial.jdbc.basic;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class QueryDataExample {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get Connection
        Connection connection = ConnectionUtils.getMyConnection();

        // Create statement
        Statement statement = connection.createStatement();

        String sql = "Select Emp_Id, Emp_No, Emp_Name from Employee";

        // Execute SQL statement returns a ResultSet object.
        ResultSet rs = statement.executeQuery(sql);

        // Fetch on the ResultSet        
        // Move the cursor to the next record.
        while (rs.next()) {
            int empId = rs.getInt(1);
            String empNo = rs.getString(2);
            String empName = rs.getString("Emp_Name");
            System.out.println("--------------------");
            System.out.println("EmpId:" + empId);
            System.out.println("EmpNo:" + empNo);
            System.out.println("EmpName:" + empName);
        }

        // Close connection.
        connection.close();
    }

}
Les résultats d'exécution de l'exemple :

8- Des types de ResultSet

Vous êtes habitué à  ResultSet via des exemples au-dessus. Par défaut, lorsque vous allez chercher des données, le curseur ne peut que exécuter de haut en bas, de gauche à droite. Cela signifie qu'avec le ResultSet par défaut, vous ne pouvez pas appeler:
  • ResultSet.previous()  : Reculez un enregistrement.
  • Sur le même enregistrement, vous ne pouvez pas appeler ResultSet.getXxx(4) alors appelez ResultSet.getXxx(2).
L'appel intentionel se rpoduit une  Exception.
public  Statement createStatement(int resultSetType, int resultSetConcurrency)
       throws SQLException;

// Example:
Statement statement = connection.createStatement(
               ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

// ResultSet can scroll & readonly
ResultSet rs = statement.executeQuery(sql);
resultSetType Signification
TYPE_FORWARD_ONLY - La constante indiquant le type d'un objet ResultSet dont le curseur peut uniquement se déplacer vers l'avant.
TYPE_SCROLL_INSENSITIVE - La constante indiquant le type d'un objet ResultSet déroulant mais généralement non sensible aux modifications apportées aux données sous-jacentes au ResultSet.
TYPE_SCROLL_SENSITIVE - La constante indiquant le type d'un objet ResultSet qui est défilable et généralement sensible aux modifications apportées aux données sous-jacentes au ResultSet.
resultSetConcurrency Signification
CONCUR_READ_ONLY La constante indiquant le mode de concurrence pour un objet ResultSet qui ne peut PAS être mis à jour.
CONCUR_UPDATABLE La constante indiquant le mode de concurrence pour un objet ResultSet qui peut être mis à jour.
ScrollableResultSetExample.java
package org.o7planning.tutorial.jdbc.basic;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class ScrollableResultSetExample {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get a Connection
        Connection connection = ConnectionUtils.getMyConnection();


        // Create a Statement object
        // can be srolled, but not sensitive to changes under DB.
        // ResultSet is readonly (Cannot update)
        Statement statement = connection.createStatement(
                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

        String sql = "Select Emp_Id, Emp_No, Emp_Name from Employee";


        // Execute statement, return ResultSet.
        ResultSet rs = statement.executeQuery(sql);

        
        // Jump the cursor to last record.
        boolean last = rs.last();
        
        System.out.println("last : "+ last);
        
        
        if(last) {
            // Print out data of last record
            System.out.println("EmpId:" + rs.getInt(1));
            System.out.println("EmpNo:" + rs.getString(2));
            System.out.println("EmpName:" + rs.getString(3));
        }
        
        
        System.out.println("--------------------");
        
        // Move cursor to previous record
        boolean previous =rs.previous();
        System.out.println("Previous 1: "+ previous);
        
        // Move cursor to previous record
        previous =rs.previous();
        System.out.println("Previous 2: "+ previous);       
        
        // Fetch in the ResultSet
        while (rs.next()) {
            // Get value of column 2
            String empNo = rs.getString(2);

            // Then get the value of column 1.
            int empId = rs.getInt(1);
            
            String empName = rs.getString("Emp_Name");
            
            System.out.println("--------------------");
            System.out.println("EmpId:" + empId);
            System.out.println("EmpNo:" + empNo);
            System.out.println("EmpName:" + empName);
        }

        // Close connection.
        connection.close();
    }

}
Les résultats de l'exécution de l'exemple :

9- L'exemple d'insérer des données

InsertDataExample.java
package org.o7planning.tutorial.jdbc.basic;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class InsertDataExample {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get Connection
        Connection connection = ConnectionUtils.getMyConnection();

        Statement statement = connection.createStatement();

        String sql = "Insert into Salary_Grade (Grade, High_Salary, Low_Salary) "
                + " values (2, 20000, 10000) ";
        
        // Execute statement
        // executeUpdate(String) using for Insert, Update, Delete statement.
        int rowCount = statement.executeUpdate(sql);
            
        System.out.println("Row Count affected = " + rowCount);
    }
}
Les résultats de l'exécution de l'exemple :

10- PreparedStatement

PreparedStatement est une interface étendue de  Statement.
PreparedStatement est utilisée pour préparer l'instruction SQL et réutilisée à plusieurs fois et elle permet au programme de accélérer la vitesse.
PrepareStatementExample.java
package org.o7planning.tutorial.jdbc.pareparedstatement;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class PrepareStatementExample {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get a connection
        Connection connection = ConnectionUtils.getMyConnection();

        // Create a SQL statement with two parameters (?)
        String sql = "Select emp.Emp_Id, emp.Emp_No, emp.Emp_Name,"
                + " emp.Dept_Id from Employee emp "
                + " where emp.Emp_Name like ? and emp.Dept_Id = ? ";

        // Create a PreparedStatement object.
        PreparedStatement pstm = connection.prepareStatement(sql);

        // Set value for the first parameter (First '?')
        pstm.setString(1, "%S");

        // Set value for the second parameter (Second '?')
        pstm.setInt(2, 20);

        ResultSet rs = pstm.executeQuery();

        while (rs.next()) {
            System.out.println(" ---- ");
            System.out.println("EmpId : " + rs.getInt("Emp_Id"));
            System.out.println("EmpNo : " + rs.getString(2));
            System.out.println("EmpName : " + rs.getString("Emp_Name"));
        }
        
        System.out.println();
        System.out.println("Set other parameters ..");

        // Reuse PreparedStatement
        // Set other values
        pstm.setString(1, "KI%");
        pstm.setInt(2,10);
        
        // Execute statement.
        rs = pstm.executeQuery();
        
        while (rs.next()) {
            System.out.println(" ---- ");
            System.out.println("EmpId : " + rs.getInt("Emp_Id"));
            System.out.println("EmpNo : " + rs.getString(2));
            System.out.println("EmpName : " + rs.getString("Emp_Name"));
        }
    }
}
Les résultats de l'exécution de l'exemple :

11- CallableStatement

CallableStatement a utilisé pour appeler une procédure (procédure) stockée ou des fonctions de SQL.
// Statement call procedure from Java
String sql = "{call procedure_name(?,?,?)}";

// Statement call function from Java.
String sql ="{? = call function_name(?,?,?)}";
Par exemple, avec CallableStatement nous avons besoin d'une fonction ou une procédure dans DB. Avec Oracle, MySQL ou SQLServer, vous pouvez créer une procédure rapidement comme ci-dessous:
  • ORACLE
Get_Employee_Info
-- This procedure retrieves information of an employee,
-- Input parameter: p_Emp_ID (Integer)
-- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date

Create Or Replace Procedure Get_Employee_Info(p_Emp_Id     Integer
                                           ,v_Emp_No     Out Varchar2
                                           ,v_First_Name Out Varchar2
                                           ,v_Last_Name  Out Varchar2
                                           ,v_Hire_Date  Out Date) Is
Begin
 v_Emp_No := 'E' || p_Emp_Id;
 --
 v_First_Name := 'Michael';
 v_Last_Name  := 'Smith';
 v_Hire_Date  := Sysdate;
End Get_Employee_Info;
  • MySQL
Get_Employee_Info
-- This procedure retrieves information of an employee,
-- Input parameter: p_Emp_ID (Integer)
-- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date

CREATE PROCEDURE get_Employee_Info(p_Emp_ID     Integer,
                                   out       v_Emp_No        Varchar(50) ,
                                   out       v_First_Name    Varchar(50) ,
                                   Out       v_Last_name    Varchar(50) ,
                                   Out       v_Hire_date      Date)
BEGIN
 set v_Emp_No  = concat( 'E' , Cast(p_Emp_Id as char(15)) );
--
 set v_First_Name = 'Michael';
 set v_Last_Name  = 'Smith';
 set v_Hire_date  = curdate();
END
  • SQL Server
Get_Employee_Info
-- This procedure retrieves information of an employee,
-- Input parameter: p_Emp_ID (Integer)
-- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date

CREATE PROCEDURE Get_Employee_Info
     @p_Emp_Id       Integer ,
     @v_Emp_No      Varchar(50)   OUTPUT,
     @v_First_Name  Varchar(50)   OUTPUT,
     @v_Last_Name  Varchar(50)   OUTPUT,
     @v_Hire_Date    Date             OUTPUT
AS
BEGIN
     set @v_Emp_No  =   'E' + CAST( @p_Emp_Id as varchar)  ;
     --
     set @v_First_Name = 'Michael';
     set @v_Last_Name  = 'Smith';
     set @v_Hire_date  = getdate();
END
CallableStatementExample.java
package org.o7planning.tutorial.jdbc.callablestatement;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Date;
import java.sql.SQLException;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class CallableStatementExample {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get a connection
        Connection connection = ConnectionUtils.getMyConnection();


        String sql = "{call get_Employee_Info(?,?,?,?,?)}";

        // Create a CallableStatement object.
        CallableStatement cstm = connection.prepareCall(sql);

       
        // Set parameter value for first question mark
        // (p_Emp_ID)
        cstm.setInt(1, 10);

       
        // Registers the OUT parameter for 2st question mark.
        // (v_Emp_No)
        cstm.registerOutParameter(2, java.sql.Types.VARCHAR);        
       
        // Registers the OUT parameter for 3rd question mark.
        // (v_First_Name)        
        cstm.registerOutParameter(3, java.sql.Types.VARCHAR);

        // Registers the OUT parameter for 4th question mark.
        // (v_Last_Name)        
        cstm.registerOutParameter(4, java.sql.Types.VARCHAR);


        // Registers the OUT parameter for 5th question mark.
        // (v_Hire_Date)        
        cstm.registerOutParameter(5, java.sql.Types.DATE);

        // Execute statement.
        cstm.executeUpdate();

        String empNo = cstm.getString(2);
        String firstName = cstm.getString(3);
        String lastName = cstm.getString(4);
        Date hireDate = cstm.getDate(5);

        System.out.println("Emp No: " + empNo);
        System.out.println("First Name: " + firstName);
        System.out.println("Last Name: " + lastName);
        System.out.println("Hire Date: " + hireDate);

    }
}
Les résultats de l'exécution de l'exemple :

12- Contrôle de transaction

La transaction (Transaction) est un concept important dans SQL.
Par exemple, la personne A transfère un montant de 1000 $ sur le compte de personne B donc sur Database (la base de données) il se déroule deux processus :
  • Débit 1000 $ du compte de la personne A
  • ​​​​​​​Crédit  1000 $ du compte de la personne B .
Et les transaction sont  considérée comme un succès si tous les deux étapes au-dessus soient réussie. Contrairement si une en deux sont considérées comme transaction échouée, la transaction sera échouée, nous aurons un rollback à l'état original.
TransactionExample.java
package org.o7planning.tutorial.transaction;

import java.sql.Connection;
import java.sql.SQLException;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class TransactionExample {

    private static void doJob1(Connection conn) {
        // Todo something here.
    }

    private static void doJob2(Connection conn) {
        // Todo something here.
    }

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        // Get a connection
        Connection connection = ConnectionUtils.getMyConnection();
           
        // Set auto-commit to false
        connection.setAutoCommit(false);

        try {
 
            // Do something related to the DB.
            doJob1(connection);
 
            doJob2(connection);
 
            // Explicitly commit statements to apply changes
            connection.commit();

        }
 
        // Handling exception
        catch (Exception e) {
            e.printStackTrace();
 
            // Rollback changes
            connection.rollback();
        }
 
        // Close connection.
        connection.close();
    }

}

13- Exécuter une commande (Batch)

BatchExample.java
package org.o7planning.tutorial.transaction;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class BatchExample {

    public static void main(String[] args) throws SQLException,
            ClassNotFoundException {

        Connection conn = ConnectionUtils.getMyConnection();

        try {
            // Create statement object
            Statement stmt = conn.createStatement();

            // Set auto-commit to false
            conn.setAutoCommit(false);

            // Create SQL statement to insert into Employee table.
            String sql1 = "Update Employee emp set emp.Salary = emp.Salary + 100 "
                    + " where emp.Dept_Id = 10 ";
            
            // Add above SQL statement in the batch.
            stmt.addBatch(sql1);

            // Create one more SQL statement
            String sql2 = "Update Employee emp set emp.Salary = emp.Salary + 20 "
                    + " where emp.Dept_Id = 20 ";
            
            // Add above SQL statement in the batch.
            stmt.addBatch(sql2);

            // Create one more SQL statement
            String sql3 = "Update Employee emp set emp.Salary = emp.Salary + 30 "
                    + " where emp.Dept_Id = 30 ";
            
            // Add above SQL statement in the batch.
            stmt.addBatch(sql3);

            // Create an int[] to hold returned values
            int[] counts = stmt.executeBatch();

            System.out.println("Sql1 count = " + counts[0]);
            System.out.println("Sql2 count = " + counts[1]);
            System.out.println("Sql3 count = " + counts[2]);

            // Explicitly commit statements to apply changes
              conn.commit();
        } catch (Exception e) {
            e.printStackTrace();
            conn.rollback();
        }
    }

}
Les résultats d'exécution de l'exemple :
BatchExample2.java
package org.o7planning.tutorial.transaction;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.UUID;

import org.o7planning.tutorial.jdbc.ConnectionUtils;

public class BatchExample2 {

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {

        Connection conn = ConnectionUtils.getMyConnection();

        try {
            String sql = "Insert into Timekeeper(Timekeeper_Id, Date_Time, In_Out, Emp_Id) "
                    + " values (?,?,?,?) ";
            // Create statement object
            PreparedStatement stmt = conn.prepareStatement(sql);

            // Set auto-commit to false
            conn.setAutoCommit(false);

            // Set values for parameters
            stmt.setString(1, UUID.randomUUID().toString());
            stmt.setDate(2, new Date(System.currentTimeMillis()));
            stmt.setString(3, "I");
            stmt.setInt(4, 7839);
            
            // Add to batch
            stmt.addBatch();


            // Set other values for parameters.
            stmt.setString(1, UUID.randomUUID().toString());
            stmt.setDate(2, new Date(System.currentTimeMillis()));
            stmt.setString(3, "I");
            stmt.setInt(4, 7566);

            // Add to batch.
            stmt.addBatch();
        

            // Create an int[] to hold returned values
            int[] counts = stmt.executeBatch();

            System.out.println("counts[0] = " + counts[0]);
            System.out.println("counts[1] = " + counts[1]);

            // Explicitly commit statements to apply changes
            conn.commit();
        } catch (Exception e) {
            e.printStackTrace();
            conn.rollback();
        }
    }

}
Les résultats d'exécution de l'exemple :

View more Tutorials: