Français
Français
Dans le développement d'applications PHP moderne, le cadre ORM (Mappage relationnel d'objet) est devenu un pont important pour les opérations de base de données. Il simplifie l'écriture SQL et améliore l'expérience orientée objet des opérations de données. PDOSTATION :: FetchObject est une méthode pratique fournie par PDO, qui peut dire directement les résultats de la requête dans les objets PHP. La combinaison raisonnable des deux peut considérablement améliorer les performances de la couche d'accès aux données et la maintenabilité du code.
La méthode FetchObject permet aux développeurs de saisir une ligne de données directement à partir de l'ensemble de résultats et de les encapsuler dans un objet. La syntaxe est la suivante:
public PDOStatement::fetchObject(string $class_name = "stdClass", array $constructor_args = []): object|false
class_name spécifie le nom de classe qui doit être instancié.
Constructor_args est utilisé pour transmettre un tableau d'arguments au constructeur de classe.
Si class_name n'est pas spécifié, un objet STDClass est renvoyé par défaut.
Exemple:
$stmt = $pdo->query('SELECT id, name, email FROM users');
$user = $stmt->fetchObject();
echo $user->name;
Dans la plupart des cadres ORM (tels que la doctrine, éloquente, propuls), la cartographie des objets est obtenue grâce à des mécanismes d'hydratation complexes. Framework Habituellement:
Obtenez le tableau des résultats de requête.
Itérer dans le tableau et attribuer manuellement chaque colonne aux propriétés de l'objet.
Soutient le chargement d'association, le chargement paresseux, etc.
Bien qu'il ait des fonctionnalités riches, cette méthode de cartographie peut être un peu lourde dans les scénarios simples, et les performances ne sont pas aussi efficaces que d'utiliser FetchObject directement.
Afin d'améliorer l'efficacité de l'exécution, nous pouvons utiliser directement FetchObject dans la couche ORM pour injecter rapidement des données dans l'objet d'entité correspondant, plutôt que de construire manuellement l'objet à chaque fois.
Définissez la classe d'entité correspondante pour chaque table de base de données.
Utilisez PDO pour interroger et appeler FetchObject pour renvoyer directement l'instance d'entité.
Gérez-le conjointement avec d'autres fonctions ORM (telles que la sauvegarde, la mise à jour, la suppression).
class User
{
public int $id;
public string $name;
public string $email;
public function getProfileUrl(): string
{
return 'https://gitbox.net/user/' . $this->id;
}
}
class UserRepository
{
private PDO $pdo;
public function __construct(PDO $pdo)
{
$this->pdo = $pdo;
}
public function find(int $id): ?User
{
$stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => $id]);
$user = $stmt->fetchObject(User::class);
return $user ?: null;
}
}
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'root', '');
$repository = new UserRepository($pdo);
$user = $repository->find(1);
if ($user) {
echo $user->name . "'s profile: " . $user->getProfileUrl();
} else {
echo "User not found.";
}
Dans cet exemple, les données de requête sont directement mappées sur l'instance de classe utilisateur et aucune opération d'attribution supplémentaire n'est requise. La méthode de l'objet peut être utilisée immédiatement après la requête, comme l'obtention de l'URL de la page de profil utilisateur ( https://gitbox.net/user/1 ).
Les noms de champ et d'attribut doivent être cohérents : FetchObject correspond aux attributs de classe par les noms de colonne par défaut.
Problème du paramètre du constructeur : Si le constructeur de classe d'entité a des paramètres, n'oubliez pas de le passer par le deuxième paramètre de fetchObject .
Sécurité des données : si une entrée externe est impliquée, des instructions de prétraitement sont toujours nécessaires pour empêcher l'injection SQL.
En combinant FetchObject , nous pouvons facilement réaliser:
Collection de traction par lots d'objets
Chargement basé sur des objets paresseux
Liaison des relations simples (comme l'association un-à-plusieurs)
Coopérez en outre avec des stratégies telles que la génération automatique de cours d'entités et les opérations par lots, une couche ORM efficace et légère peut être construite sans introduire un grand cadre ORM.
