Français
Français
Dans le développement de la base de données PHP, Pdostatement :: FetchObject est une méthode très pratique qui peut dire directement les résultats de la requête en objets. Si le mécanisme de réflexion de PHP est combiné, un mode d'accès aux données plus flexible et dynamique peut être réalisé davantage. Cet article expliquera en détail comment procéder et donnera des exemples pratiques.
Généralement, FetchObject peut convertir directement une ligne de résultats de requête en une instance d'une classe spécifiée. Par exemple:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'user', 'password');
$stmt = $pdo->query('SELECT id, name, email FROM users');
$user = $stmt->fetchObject('User');
Si la classe d'utilisateurs définit les attributs publics tels que l'ID , le nom et l'e-mail , PDO attribue automatiquement des valeurs.
Mais lorsque notre structure de classe est complexe, comme si nous devons passer des paramètres dans le constructeur, ou que les propriétés sont privées, le simple fait d'utiliser FetchObject n'est pas assez flexible.
Le mécanisme de réflexion de PHP nous permet de vérifier les propriétés, les méthodes de classes et même les objets instanciels dynamiquement au moment de l'exécution, ce qui nous donne beaucoup de place pour le fonctionnement.
<?php
class User
{
private int $id;
private string $name;
private string $email;
public function __construct(int $id, string $name, string $email)
{
$this->id = $id;
$this->name = $name;
$this->email = $email;
}
public function getProfileUrl(): string
{
return 'https://gitbox.net/user/' . $this->id;
}
}
// Créer une connexion de base de données
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'user', 'password');
$stmt = $pdo->query('SELECT id, name, email FROM users');
// Obtenez les résultats de la requête
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
$reflectionClass = new ReflectionClass(User::class);
$user = $reflectionClass->newInstanceArgs([
(int)$row['id'],
(string)$row['name'],
(string)$row['email']
]);
echo $user->getProfileUrl() . PHP_EOL;
}
Dans cet exemple, ReflectionClass :: NewInStanceargs nous permet de passer directement les paramètres du tableau pour créer des objets, ne s'appuyant plus sur l'attribution directe des propriétés publiques. Cette approche peut répondre aux besoins de construction plus complexes.
Afin d'améliorer la réutilisation du code, nous pouvons encapsuler la logique ci-dessus dans une fonction générale:
<?php
function fetchAllAsObjects(PDOStatement $stmt, string $className): array
{
$results = [];
$reflectionClass = new ReflectionClass($className);
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
$object = $reflectionClass->newInstanceArgs(array_values($row));
$results[] = $object;
}
return $results;
}
// Exemple d'utilisation
$stmt = $pdo->query('SELECT id, name, email FROM users');
$users = fetchAllAsObjects($stmt, User::class);
foreach ($users as $user) {
echo $user->getProfileUrl() . PHP_EOL;
}
Avis:
Pour s'assurer que l'ordre de colonne des résultats de la requête est cohérent avec l'ordre des paramètres du constructeur, un traitement supplémentaire est requis.
Pour des situations plus complexes, la liaison des paramètres peut être finement contrôlée par la réflexion de réflexion .
Lorsque vous utilisez la réflexion , assurez-vous de faire attention aux performances, en particulier dans de grandes quantités de traitement des données, les instances de classe de réflexion devraient être mises en cache autant que possible.
Si le nom de colonne et l'attribut de classe sont incohérents, un mappage de colonne à paramètre est requis. À l'heure actuelle, l'encapsulation supplémentaire peut être encore encapsulée, comme l'ajout de la correspondance entre le nom du paramètre et le nom de la colonne.
Si vous utilisez ce modèle largement dans votre application, envisagez de combiner des bibliothèques de mappage automatiques telles que Automapper ou développer un petit outil ORM.
En combinant le mécanisme PDOSTATION :: FetchObject et la réflexion, nous pouvons facilement convertir les résultats de la requête de la base de données en objets complexes, en réduisant une grande quantité de code d'attribution répété et en améliorant l'évolutivité et le maintien du projet. Si vous souhaitez en savoir plus de pratiques approfondies, vous pouvez visiter https://gitbox.net/blog/pdo-reflection-example .
