Membina Aplikasi PHP CRUD dengan OOP dan MySQL: Panduan Amalan Terbaik

Mengurus operasi pangkalan data dengan cekap adalah penting untuk pembangunan aplikasi PHP. CRUD (Buat, Baca, Kemas Kini, Padam) ialah salah satu operasi pangkalan data yang paling biasa. Mengguna pakai prinsip pengaturcaraan berorientasikan objek (OOP) boleh membantu menjadikan kod anda lebih mudah dan lebih mudah untuk digunakan semula dan dikembangkan. Menggunakan MySQL dengan PHP juga memastikan aplikasi anda boleh mengendalikan penyimpanan data dengan cekap.

Siaran blog ini akan membimbing anda melalui cara membina aplikasi PHP CRUD menggunakan OOP dan MySQL. Kami akan mengikuti amalan terbaik dan corak reka bentuk untuk menyusun kod supaya ia mesra pemula namun cukup berkuasa untuk digunakan pada projek yang lebih besar.

Selepas membaca panduan ini, anda akan mempunyai asas yang kukuh untuk bekerja dengan pangkalan data menggunakan prinsip OOP dalam PHP.

Jadual Kandungan

1. Kepentingan OOP dalam PHP
2. Tetapan Projek
3. Buat pangkalan data
4. Struktur folder
5. Sambung ke pangkalan data
6. Buat operasi CRUD
   • Buat
   • Baca
   • Kemas kini
   • Padam
7. Ringkasan

1. Kepentingan OOP dalam PHP

Pengaturcaraan berorientasikan objek (OOP) ialah paradigma pengaturcaraan yang menggunakan "objek" untuk menyusun kod. Dalam PHP, OOP membolehkan anda membuat kelas yang mewakili entiti dunia sebenar, menjadikan kod anda lebih modular, lebih mudah untuk digunakan semula dan lebih mudah untuk diurus.

Menggunakan prinsip OOP apabila bekerja dengan pangkalan data bermakna:

• Pemisahan Kebimbangan: Logik pangkalan data dikapsulkan dalam kelas, berasingan daripada logik aplikasi yang lain.
• Kebolehgunaan semula: Anda boleh menggunakan semula kelas pangkalan data dalam berbilang bahagian aplikasi anda.
• Kebolehselenggaraan: Apabila aplikasi anda berkembang, kod anda lebih mudah untuk dikemas kini dan dilanjutkan.

2. Tetapan projek

Sebelum kita memulakan pengekodan, mari sediakan struktur folder yang mudah diselenggara. Projek anda hendaklah disusun seperti berikut:

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

• config/Database.php: Mengandungi logik sambungan pangkalan data.
• pengawal/UserController.php: Mengendalikan operasi CRUD dan berkomunikasi dengan model.
• model/User.php: Mengandungi logik untuk berinteraksi dengan jadual pengguna dalam MySQL.
• views/user_list.php: Paparkan data pengguna dalam bentuk jadual.
• public/index.php: Titik masuk permohonan.

3. Cipta pangkalan data

Mari mulakan dengan mencipta pangkalan data dan jadual pengguna dalam MySQL. Anda boleh melaksanakan pertanyaan SQL berikut untuk menyediakan pangkalan data:

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
);

Jadual ini akan menyimpan maklumat pengguna asas seperti nama, e-mel dan tarikh penciptaan.

4. Struktur folder

Kami telah menyediakan struktur folder asas. Berikut ialah pecahan perkara yang dilakukan oleh setiap folder:

• config/: Mengandungi konfigurasi pangkalan data dan logik sambungan.
• pengawal/: Kendalikan permintaan dan panggil kaedah yang sepadan dalam model.
• model/: Mewakili logik perniagaan dan interaksi pangkalan data.
• pandangan/: Paparkan data kepada pengguna.
• awam/: Folder awam mengandungi fail index.php, yang akan berfungsi sebagai titik masuk ke aplikasi.

5. Sambung ke pangkalan data

Mari mulakan dengan mencipta kelas sambungan pangkalan data dalam config/Database.php:

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

Kelas ini mencipta sambungan PDO ke MySQL dan boleh digunakan semula dalam projek anda.

6. Cipta operasi CRUD

Mari kita cipta model untuk mengendalikan data pengguna. Kelas ini akan berinteraksi dengan jadual pengguna dan melaksanakan operasi CRUD.

Buat model (User.php)

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
);

Buat Pengawal (UserController.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());
        }
    }
}

Buat paparan (senarai_pengguna.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();
    }
}

Buat titik masuk (index.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);
    }
}

Ringkasan

Dengan mengikut prinsip OOP dan menggunakan amalan terbaik dalam PHP, kami membina aplikasi CRUD yang mudah dan berskala. Pendekatan ini membolehkan anda dengan mudah memanjangkan projek anda dengan fungsi baharu atau menambah baik interaksi pangkalan data.

Dalam panduan ini, kami meliputi:

• Mudah dan mudah untuk mengekalkan struktur folder.
• Kelas Pangkalan Data boleh guna semula untuk sambungan MySQL.
• Model pengguna yang merangkumi semua operasi CRUD.
• Pengawal Pengguna untuk mengendalikan logik perniagaan.

Struktur ini menjadikan aplikasi PHP anda lebih bersih, lebih modular dan lebih mudah untuk dikembangkan. Anda kini boleh menggunakan pendekatan ini untuk membina aplikasi yang lebih besar dan lebih kompleks menggunakan OOP dan MySQL.

Selamat pengekodan! ?

Atas ialah kandungan terperinci Membina Aplikasi PHP CRUD dengan OOP dan MySQL: Panduan Amalan Terbaik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!