Comment implémenter la couche de persistance des objets en php

Le mappage objet-relationnel (ORM) est un modèle de conception essentiel dans le développement de logiciels modernes. L'idée principale du modèle ORM est de mapper les objets du programme aux tables de la base de données relationnelle, réalisant ainsi une intégration transparente entre le programme et la base de données. L'implémentation du modèle ORM peut utiliser les frameworks ORM existants, tels que Hibernate, Django ORM et Active Record dans Ruby on Rails. Cependant, en PHP, nous pouvons utiliser du code PHP natif pour implémenter la couche de persistance des objets sans nécessiter de frameworks supplémentaires. Cet article explique comment implémenter la couche de persistance des objets à l'aide du code PHP natif.

1. Notions de base de la base de données relationnelle

Avant de comprendre comment utiliser PHP pour implémenter la couche de persistance des objets, nous devons comprendre certains concepts de base des bases de données relationnelles.

1. Table de base de données

La base de données relationnelle est composée de nombreuses tables de données. Chaque tableau de données se compose d'une ou plusieurs colonnes. Chaque colonne a un type de données correspondant, tel qu'un entier, une chaîne, une date, etc.

2. Clé primaire

Chaque table de données doit avoir une clé primaire. La clé primaire est un champ qui identifie de manière unique chaque enregistrement de la table. La clé primaire doit être unique et ne peut pas être NULL.

3. Clés étrangères

Les clés étrangères sont utilisées pour établir des relations entre deux ou plusieurs tables. Les clés étrangères définissent l'association entre une table et une autre table, nous permettant d'obtenir des informations des deux tables et de les fusionner via une requête conjointe.

2. Utilisez PDO pour accéder à la base de données

PDO (PHP Data Objects) est le moyen standard d'accéder aux bases de données en PHP Nous pouvons utiliser PDO pour accéder à diverses bases de données relationnelles (telles que MySQL, PostgreSQL, etc.). L'utilisation de PDO pour faire fonctionner la base de données peut améliorer la portabilité du programme et augmenter la sécurité du programme.

En PHP, nous pouvons utiliser la classe PDO pour initialiser une connexion à une base de données. Parmi eux, les paramètres que l'utilisateur doit fournir incluent le type de base de données, le nom d'hôte, le nom de la base de données, le nom d'utilisateur et le mot de passe, etc. Après l'initialisation, nous pouvons utiliser l'instance PDO pour exécuter des requêtes SQL et traiter les résultats de la requête.

Ce qui suit est un exemple d'utilisation de PDO pour accéder à la base de données MySQL :

<?php
try {
    $dbh = new PDO(&#39;mysql:host=localhost;dbname=test&#39;, $user, $pass);
    foreach($dbh->query('SELECT * from FOO') as $row) {
        print_r($row);
    }
    $dbh = null;
} catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
}
?>

L'exécution du code ci-dessus sélectionnera la table FOO dans MySQL et imprimera les résultats de la requête.

3. Utilisez PHP pour implémenter le mode ORM

Lors de l'implémentation du mode ORM, nous devons utiliser des objets et des classes PHP pour décrire les tables et les colonnes de la base de données. Nous devons définir une classe correspondante pour chaque table et convertir les colonnes de la table en attributs de la classe. Afin d'implémenter le mode ORM, nous devons également introduire une couche d'accès à la base de données pour faire fonctionner la base de données et convertir les résultats des requêtes en objets de classe PHP. Voici les étapes de développement pour implémenter le mode ORM à l'aide de PHP :

1. Créer une connexion à la base de données MySQL

En PHP, nous pouvons utiliser PDO pour nous connecter à la base de données MySQL. Voici un exemple de code pour ouvrir une connexion à la base de données MySQL :

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDBPDO";

try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Connected successfully";
} catch(PDOException $e) {
    echo "Connection failed: " . $e->getMessage();
}
?>

Dans le code ci-dessus, nous créons une connexion à la base de données MySQL et définissons le mode d'erreur de PDO en mode exception. Lors de l'utilisation de PDO, le mode d'exception nous permet de gérer plus facilement les erreurs pouvant survenir dans le programme.

2. Définir les classes ORM

Afin d'implémenter le mode ORM, nous devons définir la classe ORM correspondant à la table et convertir les colonnes de la table en attributs de la classe. Voici un exemple de code pour une classe ORM :

<?php
class User {
    private $id;
    private $name;
    private $email;
    private $password;

    public function __construct($id, $name, $email, $password) {
        $this->id = $id;
        $this->name = $name;
        $this->email = $email;
        $this->password = $password;
    }

    public function getId() {
        return $this->id;
    }

    public function setId($id) {
        $this->id = $id;
    }

    public function getName() {
        return $this->name;
    }

    public function setName($name) {
        $this->name = $name;
    }

    public function getEmail() {
        return $this->email;
    }

    public function setEmail($email) {
        $this->email = $email;
    }

    public function getPassword() {
        return $this->password;
    }

    public function setPassword($password) {
        $this->password = $password;
    }
}
?>

Dans le code ci-dessus, nous créons une classe User et convertissons les colonnes identifiant, nom, e-mail et mot de passe du tableau en attributs de la classe. Nous définissons également le constructeur de la classe et une série de méthodes getter et setter.

3. Implémenter la couche d'accès aux données ORM

Afin d'implémenter le mode ORM, nous devons également implémenter une couche d'accès aux données pour faire fonctionner la base de données. Voici un exemple de code simple de couche d'accès aux données :

<?php
class UserDAO {
    private $pdo;

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function getUserById($id) {
        $stmt = $this->pdo->prepare('SELECT * FROM user WHERE id = :id');
        $stmt->execute(array('id' => $id));
        $data = $stmt->fetch();
        if ($data) {
            return new User($data['id'], $data['name'], $data['email'], $data['password']);
        }else{
            return null;
        }
    }

    public function saveUser(User $user) {
        if ($user->getId()) {
            // update
            $stmt = $this->pdo->prepare('UPDATE user SET name = :name, email = :email, password = :password WHERE id = :id');
            $stmt->execute(array('name' => $user->getName(), 'email' => $user->getEmail(), 'password' => $user->getPassword(), 'id' => $user->getId()));
        } else {
            // insert
            $stmt = $this->pdo->prepare('INSERT INTO user (name, email, password) VALUES (:name, :email, :password)');
            $stmt->execute(array('name' => $user->getName(), 'email' => $user->getEmail(), 'password' => $user->getPassword()));
            $user->setId($this->pdo->lastInsertId());
        }
    }

    public function deleteUser(User $user) {
        $stmt = $this->pdo->prepare('DELETE FROM user WHERE id = :id');
        $stmt->execute(array('id' => $user->getId()));
    }
}
?>

Dans le code ci-dessus, nous avons créé une classe UserDAO, qui est utilisée pour faire fonctionner la base de données et renvoyer des objets User. La méthode getUserById de cette classe obtient les informations utilisateur avec un identifiant spécifié à partir de la base de données, la méthode saveUser met à jour ou insère les informations utilisateur dans la base de données et la méthode deleteUser est utilisée pour supprimer les informations utilisateur.

4. Utilisation des classes ORM

Après avoir implémenté le modèle ORM, nous pouvons utiliser les objets ORM comme des objets normaux sans écrire manuellement de requêtes SQL. Vous trouverez ci-dessous un exemple de code pour une classe ORM :

<?php
// create a new user
$user = new User(null, &#39;John Doe&#39;, &#39;john@example.com&#39;, &#39;password&#39;);
$userDAO = new UserDAO($pdo);
$userDAO->saveUser($user);

// find a user by id
$user = $userDAO->getUserById(1);

// update a user's name
$user->setName('Jane Doe');
$userDAO->saveUser($user);

// delete a user
$userDAO->deleteUser($user);
?>

Dans le code ci-dessus, nous créons un nouvel utilisateur et insérons l'utilisateur dans la base de données. Ensuite, nous utilisons la méthode getUserById pour trouver les informations utilisateur avec l’ID 1. Nous pouvons mettre à jour le nom de cet utilisateur à l'aide de la méthode setter, puis enregistrer les modifications dans la base de données à l'aide de la méthode saveUser. Enfin, nous supprimons l'utilisateur à l'aide de la méthode deleteUser.

Conclusion

Dans cet article, nous avons présenté comment implémenter le modèle Object Persistence Layer à l'aide de PHP. Tout d’abord, nous avons appris les bases des bases de données relationnelles, puis avons examiné de plus près l’utilisation par PHP de PDO pour se connecter à la base de données. En comprenant la base de données relationnelle et les méthodes de connexion PDO, nous pouvons implémenter manuellement le mode ORM nous-mêmes. En définissant les classes ORM et les couches d'accès aux données, nous pouvons intégrer de manière transparente les opérations de base de données dans notre code PHP. L'utilisation du mode ORM peut simplifier considérablement notre code et gérer plus facilement les opérations de base de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!