Terokai Kelebihan Objek Pemindahan Data (DTO) dan Bagaimana Kelas Baca Sahaja PHP Boleh Meningkatkan Kod Laravel Anda

Dalam pembangunan aplikasi web moden, pengurusan dan pemindahan data dengan cekap dan selamat adalah penting. Satu corak reka bentuk yang sangat membantu dalam proses ini ialah Objek Pemindahan Data (DTO). Siaran ini akan menyelidiki kelebihan menggunakan DTO, terutamanya dalam aplikasi Laravel, dan menunjukkan cara kelas baca sahaja PHP 8.2 boleh meningkatkan lagi faedahnya.

Apakah itu Objek Pemindahan Data (DTO)?

Objek Pemindahan Data (DTO) ialah objek ringkas yang direka untuk membawa data antara proses atau sistem. Tidak seperti model atau entiti biasa, DTO bebas daripada logik perniagaan. Ia merangkum data, menyediakan cara yang jelas dan berstruktur untuk memindahkan maklumat antara lapisan aplikasi yang berbeza atau antara pelbagai sistem.

Corak DTO

Corak DTO digunakan untuk memindahkan data merentas subsistem yang berbeza dalam aplikasi perisian. Objektif utama penggunaan DTO adalah untuk meminimumkan bilangan panggilan kaedah, mengagregatkan data yang diperlukan dan menawarkan pendekatan berstruktur untuk mengurus transformasi dan pengesahan data.

Faedah Menggunakan DTO

• Pengasingan Kebimbangan: DTO mengasingkan logik perniagaan daripada perwakilan data, menghasilkan kod yang lebih bersih dan boleh diselenggara yang lebih mudah difahami.

• Pengesahan Data: DTO membenarkan pengesahan data sebelum ia diproses oleh lapisan aplikasi lain, memastikan hanya data yang sah digunakan.

• Ketekalan: Dengan menyediakan struktur yang konsisten untuk pemindahan data, DTO memudahkan pengurusan dan pemprosesan data daripada pelbagai sumber.

• Keselamatan: DTO boleh melindungi aplikasi anda daripada manipulasi data yang tidak dibenarkan dengan mengawal data yang boleh diakses dan diubah suai.

• Pengujian: Memandangkan DTO ialah objek mudah tanpa logik perniagaan terbenam, ia lebih mudah untuk dipermainkan dan diuji.

• Transformasi: DTO memudahkan transformasi data kepada format yang diperlukan oleh lapisan aplikasi yang berbeza.

• Ketidakbolehubah: DTO selalunya menggalakkan kebolehubah, bermakna setelah dibuat, keadaannya tidak boleh berubah. Ciri ini membawa beberapa kelebihan:

  • Kebolehramalan: Objek tidak berubah boleh diramal dan lebih mudah untuk difikirkan, kerana keadaannya kekal berterusan selepas penciptaan.
  • Keselamatan Benang: Ketidakbolehubahan sememangnya menyokong keselamatan benang, memudahkan pemprosesan serentak.
  • Nyahpepijat: Nyahpepijat lebih mudah dengan objek tidak berubah kerana keadaannya dijamin kekal tidak berubah sepanjang kitaran hayatnya.

Kelas PHP 8.2 dan Baca Sahaja

Dengan PHP 8.2, pengenalan kelas baca sahaja meningkatkan penggunaan DTO. Kelas baca sahaja menghapuskan keperluan untuk mentakrifkan sifat secara eksplisit sebagai baca sahaja, memudahkan pelaksanaan DTO anda. Begini cara kelas baca sahaja PHP 8.2 meningkatkan DTO:

• Kod Ringkas: Kelas baca sahaja secara automatik menjadikan sifat tidak berubah, mengurangkan kod plat dandang dan meningkatkan kejelasan.
• Keselamatan Dipertingkat: Dengan memastikan sifat tidak boleh diubah suai setelah ditetapkan, kelas baca sahaja meningkatkan integriti dan keselamatan data.
• Kebolehselenggaraan yang Dipertingkatkan: Penggunaan kelas baca sahaja membawa kepada kod yang lebih bersih dan boleh diselenggara, kerana data yang tidak boleh diubah dikuatkuasakan oleh bahasa itu sendiri.

Contoh: Menggunakan DTO dalam Sistem Pengurusan Harta

Mari kita pertimbangkan sistem pengurusan hartanah di mana hartanah boleh datang daripada pelbagai sumber seperti import API dan CSV. Kami boleh menggunakan DTO untuk mencipta model Harta, Langganan, Aset, dsb., memastikan data itu konsisten dan disahkan merentas aplikasi.

Mentakrifkan PropertyDTO

Pertama, mari kita tentukan kelas PropertyDTO:

app/DTO/PropertyDTO.php

namespace App\DTO;

/**
 * Class PropertyDTO
 *
 * Represents a Data Transfer Object for property data.
 */
readonly class PropertyDTO extends AbstractDTO
{
    /**
     * The name of the property.
     *
     * @var string
     */
    public string $name;

    /**
     * The address of the property.
     *
     * @var string
     */
    public string $address;

    /**
     * The price of the property.
     *
     * @var float
     */
    public float $price;

    /**
     * The subscription status of the property, if applicable.
     *
     * @var string|null
     */
    public ?string $subscription;

    /**
     * The list of assets associated with the property.
     *
     * @var array|null
     */
    public ?array $assets;

    /**
     * Set the properties from a model instance.
     *
     * @param $model The model instance.
     * @return $this
     */
    public function setFromModel($model): self
    {
        $this->name = $model->name;
        $this->address = $model->address;
        $this->price = $model->price;
        $this->subscription = $model->subscription;
        $this->assets = $model->assets;

        return $this;
    }

    /**
     * Set the properties from API data.
     *
     * @param array $data The API data.
     * @return $this
     */
    public function setFromAPI(array $data): self
    {
        $this->name = $data['property_name'];
        $this->address = $data['property_address'];
        $this->price = $data['property_price'];
        $this->subscription = $data['subscription'] ?? null;
        $this->assets = $data['assets'] ?? null;

        return $this;
    }

    /**
     * Set the properties from CSV data.
     *
     * @param array $data The CSV data.
     * @return $this
     */
    public function setFromCSV(array $data): self
    {
        $this->name = $data[0];
        $this->address = $data[1];
        $this->price = (float) $data[2];
        $this->subscription = $data[3] ?? null;
        $this->assets = explode(',', $data[4] ?? '');

        return $this;
    }
}

Menggunakan PropertyDTO

Berikut ialah cara anda boleh menggunakan PropertyDTO untuk mengendalikan sifat daripada sumber yang berbeza:

// From a Model
$model = Property::find(1);
$propertyDTO = (new PropertyDTO([]))->setFromModel($model);

// From an API
$apiData = [
    'property_name' => 'Beautiful House',
    'property_address' => '1234 Elm Street',
    'property_price' => 450000,
    'subscription' => 'Premium',
    'assets' => ['pool', 'garden']
];
$propertyDTO = (new PropertyDTO([]))->setFromAPI($apiData);

// From a CSV
$csvData = ['Beautiful House', '1234 Elm Street', 450000, 'Premium', 'pool,garden'];
$propertyDTO = (new PropertyDTO([]))->setFromCSV($csvData);

// Convert to Array
$arrayData = $propertyDTO->toArray();

// Convert to JSON
$jsonData = $propertyDTO->toJson();

Ringkasan

Objek Pemindahan Data (DTO) menawarkan banyak kelebihan dalam aplikasi Laravel dengan memastikan ketekalan data, pengesahan dan pengasingan kebimbangan. Dengan melaksanakan DTO, anda boleh menjadikan aplikasi anda lebih mudah diselenggara, selamat dan lebih mudah untuk diuji. Dalam sistem pengurusan hartanah, DTO membantu dalam mengendalikan data daripada pelbagai sumber seperti API dan import CSV dengan cekap, memastikan logik perniagaan anda kekal bersih dan memfokuskan pada pemprosesan data yang disahkan.

Moreover, embracing immutability within DTOs enhances predictability, thread-safety, and simplifies debugging.

Extending DTOs with Abstract Classes for Consistency

To streamline the creation of DTOs and promote code reuse, we can use an abstract class or base class. This approach allows us to define common methods and properties in the abstract class and extend it for specific data sources.

Defining the AbstractDTO

app/DTO/AbstractDTO.php

namespace App\DTO;

/**
 * AbstractDTO
 *
 * An abstract base class for Data Transfer Objects (DTOs).
 * Provides common methods and properties for DTO implementations.
 */
abstract class AbstractDTO
{
    /**
     * AbstractDTO constructor.
     *
     * Initialises the DTO with data from an associative array.
     *
     * @param array $data The data array to initialize the DTO.
     */
    public function __construct(array $data)
    {
        $this->setFromArray($data);
    }

    /**
     * Set the properties of the DTO from a model instance.
     *
     * @param $model The model instance from which to populate the DTO.
     * @return $this
     */
    abstract public function setFromModel($model): self;

    /**
     * Set the properties of the DTO from API data.
     *
     * @param array $data The data array from the API.
     * @return $this
     */
    abstract public function setFromAPI(array $data): self;

    /**
     * Set the properties of the DTO from CSV data.
     *
     * @param array $data The data array from the CSV.
     * @return $this
     */
    abstract public function setFromCSV(array $data): self;

    /**
     * Convert the DTO to an associative array.
     *
     * @return array The DTO data as an associative array.
     */
    public function toArray(): array
    {
        $properties = get_object_vars($this);
        return array_filter($properties, function ($property) {
            return $property !== null;
        });
    }

    /**
     * Convert the DTO to a JSON string.
     *
     * @return string The DTO data as a JSON string.
     */
    public function toJson(): string
    {
        return json_encode($this->toArray());
    }

    /**
     * Set the properties of the DTO from an associative array.
     *
     * @param array $data The data array to populate the DTO.
     */
    protected function setFromArray(array $data): void
    {
        foreach ($data as $key => $value) {
            if (property_exists($this, $key)) {
                $this->$key = $value;
            }
        }
    }
}

Final Thoughts

Using an abstract or base class for DTOs not only ensures consistency across different DTO implementations but also promotes code reuse and maintainability. By defining common methods and properties in an abstract class, you can create a structured and efficient way to manage data transfer within your application. This approach aligns well with the principles of clean code and helps in building scalable and robust applications.

Here’s a revised phrase that includes a call to action:

"By leveraging DTOs and abstract classes together, you can refine your Laravel application's design, improving how data is managed and ensuring a more organised and efficient data flow. If you want to further encapsulate and enhance your DTOs with traits and interfaces, explore our guide on Enhancing Object-Oriented Design with Traits, Interfaces, and Abstract Classes."

Atas ialah kandungan terperinci Terokai Kelebihan Objek Pemindahan Data (DTO) dan Bagaimana Kelas Baca Sahaja PHP Boleh Meningkatkan Kod Laravel Anda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!