Créer une application PHP CRUD avec POO et MySQL : un guide des meilleures pratiques

La gestion efficace des opérations de base de données est cruciale pour le développement d'applications PHP. CRUD (Créer, Lire, Mettre à jour, Supprimer) est l'une des opérations de base de données les plus courantes. L'adoption des principes de programmation orientée objet (POO) peut contribuer à rendre votre code plus simple et plus facile à réutiliser et à étendre. L'utilisation de MySQL avec PHP garantit également que votre application peut gérer efficacement le stockage des données.

Cet article de blog vous expliquera comment créer une application PHP CRUD en utilisant OOP et MySQL. Nous suivrons les meilleures pratiques et les modèles de conception pour organiser le code de manière à ce qu'il soit convivial pour les débutants mais suffisamment puissant pour être utilisé sur des projets plus importants.

Après avoir lu ce guide, vous disposerez d'une base solide pour travailler avec des bases de données utilisant les principes de la POO en PHP.

Table des matières

1. L'importance de la POO en PHP
2. Paramètres du projet
3. Créer une base de données
4. Structure des dossiers
5. Se connecter à la base de données
6. Créer des opérations CRUD
   • Créer
   • Lire
   • Mise à jour
   • Supprimer
7. Résumé

1. L'importance de la POO en PHP

La programmation orientée objet (POO) est un paradigme de programmation qui utilise des « objets » pour organiser le code. En PHP, la POO vous permet de créer des classes qui représentent des entités du monde réel, rendant votre code plus modulaire, plus facile à réutiliser et à gérer.

Appliquer les principes de la POO lorsque vous travaillez avec des bases de données signifie :

• Séparation des préoccupations : la logique de la base de données est encapsulée dans une classe, distincte du reste de la logique de l'application.
• Réutilisabilité : Vous pouvez réutiliser les classes de base de données dans plusieurs parties de votre application.
• Maintenabilité : à mesure que votre application se développe, votre code est plus facile à mettre à jour et à étendre.

2. Paramètres du projet

Avant de commencer à coder, mettons en place une structure de dossiers facile à gérer. Votre projet doit être organisé comme suit :

<code>php-crud/
├── config/
│   └── Database.php
├── controllers/
│   └── UserController.php
├── models/
│   └── User.php
├── views/
│   └── user_list.php
├── public/
│   └── index.php
└── .gitignore</code>

• config/Database.php : Contient la logique de connexion à la base de données.
• controllers/UserController.php : gère les opérations CRUD et communique avec le modèle.
• models/User.php : Contient la logique pour interagir avec la table des utilisateurs dans MySQL.
• views/user_list.php : Afficher les données utilisateur sous forme de tableau.
• public/index.php : Le point d'entrée de l'application.

3. Créer une base de données

Commençons par créer la base de données et la table des utilisateurs dans MySQL. Vous pouvez exécuter la requête SQL suivante pour configurer la base de données :

<code class="language-sql">CREATE DATABASE php_crud;

USE php_crud;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);</code>

Ce tableau stockera les informations de base sur l'utilisateur telles que le nom, l'e-mail et la date de création.

4. Structure des dossiers

Nous avons mis en place la structure de base des dossiers. Voici un aperçu de ce que fait chaque dossier :

• config/ : Contient la configuration de la base de données et la logique de connexion.
• controllers/ : Gère la requête et appelle la méthode correspondante dans le modèle.
• models/ : représente la logique métier et l'interaction avec la base de données.
• views/ : Afficher les données à l'utilisateur.
• public/ : Le dossier public contient le fichier index.php, qui servira de point d'entrée à l'application.

5. Connectez-vous à la base de données

Commençons par créer une classe de connexion à la base de données dans config/Database.php :

<code>php-crud/
├── config/
│   └── Database.php
├── controllers/
│   └── UserController.php
├── models/
│   └── User.php
├── views/
│   └── user_list.php
├── public/
│   └── index.php
└── .gitignore</code>

Cette classe crée une connexion PDO à MySQL et est réutilisable dans votre projet.

6. Créer des opérations CRUD

Créons un modèle pour gérer les données utilisateur. Cette classe interagira avec la table des utilisateurs et effectuera des opérations CRUD.

Créer un modèle (User.php)

<code class="language-sql">CREATE DATABASE php_crud;

USE php_crud;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);</code>

Créer un contrôleur (UserController.php)

<code class="language-php"><?php namespace Config;

use PDO;

class Database
{
    private $host = '127.0.0.1';
    private $dbName = 'php_crud';
    private $username = 'root';
    private $password = '';
    private $connection;

    public function connect()
    {
        try {
            $this->connection = new PDO(
                "mysql:host={$this->host};dbname={$this->dbName}",
                $this->username,
                $this->password
            );
            $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            return $this->connection;
        } catch (PDOException $e) {
            die("Database connection failed: " . $e->getMessage());
        }
    }
}</code>

Créer une vue (user_list.php)

<code class="language-php"><?php namespace Models;

use Config\Database;

class User
{
    private $conn;

    public function __construct()
    {
        $database = new Database();
        $this->conn = $database->connect();
    }

    public function create($name, $email)
    {
        $sql = "INSERT INTO users (name, email) VALUES (:name, :email)";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':name', $name);
        $stmt->bindParam(':email', $email);
        return $stmt->execute();
    }

    public function read()
    {
        $sql = "SELECT * FROM users";
        $stmt = $this->conn->prepare($sql);
        $stmt->execute();
        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    public function update($id, $name, $email)
    {
        $sql = "UPDATE users SET name = :name, email = :email WHERE id = :id";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':name', $name);
        $stmt->bindParam(':email', $email);
        $stmt->bindParam(':id', $id);
        return $stmt->execute();
    }

    public function delete($id)
    {
        $sql = "DELETE FROM users WHERE id = :id";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':id', $id);
        return $stmt->execute();
    }
}</code>

Créer un point d'entrée (index.php)

<code class="language-php"><?php namespace Controllers;

use Models\User;

class UserController
{
    public function createUser($name, $email)
    {
        $user = new User();
        return $user->create($name, $email);
    }

    public function getUsers()
    {
        $user = new User();
        return $user->read();
    }

    public function updateUser($id, $name, $email)
    {
        $user = new User();
        return $user->update($id, $name, $email);
    }

    public function deleteUser($id)
    {
        $user = new User();
        return $user->delete($id);
    }
}</code>

Résumé

En suivant les principes de la POO et en appliquant les meilleures pratiques en PHP, nous avons construit une application CRUD simple et évolutive. Cette approche vous permet d'étendre facilement votre projet avec de nouvelles fonctionnalités ou d'améliorer l'interaction avec la base de données.

Dans ce guide, nous couvrons :

• Structure de dossiers simple et facile à gérer.
• Classe de base de données réutilisable pour les connexions MySQL.
• Modèle utilisateur qui encapsule toutes les opérations CRUD.
• UserController pour gérer la logique métier.

Cette structure rend vos applications PHP plus propres, plus modulaires et plus faciles à étendre. Vous pouvez désormais utiliser cette approche pour créer des applications plus volumineuses et plus complexes à l'aide de la POO et de MySQL.

Bon codage ! ?

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!