Mapping objet-relationnel

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

Un mapping objet-relationnel (en anglais object-relational mapping ou ORM) est une technique de programmation informatique qui crée l'illusion d'une base de données orientée objet à partir d'une base de données relationnelle en définissant des correspondances entre cette base de données et les objets du langage utilisé. On pourrait le désigner par « correspondance entre monde objet et monde relationnel »


Explication du problème[modifier | modifier le code]

L'utilisation de la programmation orientée objet avec une base de données relationnelle nécessite de convertir les données relationnelles en objets et vice-versa. Ceci conduit à programmer cette conversion pour chaque objet et donc à dupliquer énormément de code similaire.

Exemple de code Java qui utilise l'API JDBC pour récupérer les données relationnelles d'un client (customer en anglais) pour les transformer en un objet Java :

public Customer loadCustomer(long customerId, Connection connection) {
    if (0 == customerId || connection == null) {
        return null;
    }
 
    PreparedStatement stmt = null;
    try {
        // preparation de la requete à la base de données
        stmt = connection.prepareStatement(
                " SELECT CUSTOMER_ID, CUSTOMER_NAME, CUSTOMER_ADDRESS "
                + " FROM CUSTOMER WHERE CUSTOMER_ID = ? ");
        stmt.setLong(1, customerId);
        ResultSet rs = stmt.executeQuery();
        if (rs.next()) {
            // transformation des données relationnelles en objet "Customer"
            Customer customer = new Customer();
            int index = 1;
            customer.setCustomerId(rs.getLong(index++));
            customer.setCustomerName(rs.getString(index++));
            customer.setCustomerAddress(rs.getString(index++));
            return customer;
        }
    } catch (final Exception e) {
        log.info("", e);
    } finally {
        // nettoyage
        if (stmt != null) {
            try {
                stmt.close();
            } catch (final SQLException e) {
                log.info("", e);
            }
        }
    }
    return null;
}

Un code source très similaire est utilisé pour récupérer les informations des autres tables et les transformer en objet. Les parties du code qui changent sont : le SQL, l'affectation des paramètres sur l'objet PreparedStatement et la récupération des résultats et leur affectation sur l'objet. La structure générale du code reste toujours la même. En fait, le code permettant de réaliser toutes les opérations de CRUD (création, lecture, mise à jour, suppression) se ressemblent énormément d'une table à l'autre et d'un objet à l'autre.

Les frameworks de mapping objet-relationnel permettent d'éliminer la duplication de code dans les opérations CRUD.

Description[modifier | modifier le code]

Le mapping objet-relationnel consiste à associer une ou plusieurs classes avec une table, et chaque attribut de la classe avec un champ de la table.

Par exemple, la classe Customer est associée avec la table CUSTOMER, et les attributs sont associés comme suit :

  • Customer.customerId est associée avec CUSTOMER.CUSTOMER_ID
  • Customer.customerName est associée avec CUSTOMER.CUSTOMER_NAME
  • Customer.customerAddress est associée avec CUSTOMER.CUSTOMER_ADDRESS

En Java, il est alors possible d'utiliser l'introspection pour récupérer les informations sur les attributs lors de l'exécution (type, valeur, etc.) et pouvoir construire dynamiquement les requête SQL de CRUD. Des mécanismes similaires existent pour les autres langages disposant de frameworks de mapping objet-relationnel.

Le mapping objet-relationnel est considéré comme une méthode de programmation pour la traduction des données entre les systèmes de bases de données relationnelles et des langages de programmation orientés objet. Le résultat finit par être une base de données "objet", "virtuelle", qui peut être utilisée au sein du langage de programmation.

Il existe de nombreux outils d'ORM payants, gratuits ou même en licence libre.

Habituellement les tâches de gestion des données dans un programme d'ORM sont exécutées en contrôlant des objets qui sont généralement des valeurs non scalaires. Par exemple, considérons une entrée d'agenda qui représente une personne seule avec zéro ou plusieurs anniversaires et zéro ou plusieurs anniversaires. Cela pourrait alors être modélisé sous la forme d'un objet "personne" comprenant lui-même des objets correspondants aux données qui constituent l'entrée d'agenda. Par exemple, l'objet "personne" inclurait un ou plusieurs objets "anniversaire", eux-mêmes pouvant d'ailleurs contenir à leur tour des objets "personne" Les anniversaires peuvent alors être traités comme des valeurs/entités individuelles par le langage de programmation, différenciés des entrées personnes. De plus, différentes méthodes peuvent être liés aux objets.

Cependant un problème se pose : de nombreux SGBD populaires ne peuvent que stocker et manipuler des valeurs scalaires tels que les entiers et les chaînes structurées dans des tableaux normalisés. Un exemple typique d'un tel produit système serait un SGBD Structured Query Language (SQL). Le programmeur doit donc faire un choix : il peut soit convertir les valeurs objets de son programme en groupes de valeurs simples pour le stockage dans la base de données et de les re-convertir en objets lors de leur récupération ultérieure, soit décider de n'utiliser que des valeurs scalaires dans le programme, ce qui peut avoir un très fort impact sur la structure du programme. Les ORM sont utilisés pour mettre en œuvre la première solution.

Il y a des avantages et des inconvénients à l'utilisation d'ORM. Un des avantages est que cela réduit la quantité de code qui doit être écrit et permet une homogénéité avec le reste du code pour les langages orientés objets. Cependant, parfois des outils ORM ne fonctionnent pas bien lors de la suppression de données en vrac. En outre, une base de donnée mal conçue peut induire une forte dépendance à un système ORM, et réciproquement.

Frameworks de mapping objet-relationnel[modifier | modifier le code]

Voici quelques frameworks de mapping objet-relationnel :

férences[modifier | modifier le code]