Entdecken Sie die Vorteile von Data Transfer Objects (DTOs) und wie PHP Readonly-Klassen Ihren Laravel-Code verbessern können-PHP-Tutorial-php.cn

Explore the Advantages of Data Transfer Objects (DTOs) and How PHP Readonly Classes Can Elevate Your Laravel Code

In der modernen Webanwendungsentwicklung ist die effiziente und sichere Verwaltung und Übertragung von Daten von entscheidender Bedeutung. Ein Entwurfsmuster, das diesen Prozess erheblich unterstützt, ist das Data Transfer Object (DTO). Dieser Beitrag befasst sich mit den Vorteilen der Verwendung von DTOs, insbesondere in einer Laravel-Anwendung, und zeigt, wie schreibgeschützte PHP 8.2-Klassen ihre Vorteile weiter verbessern können.

Was ist ein Data Transfer Object (DTO)?

Ein Data Transfer Object (DTO) ist ein einfaches Objekt, das dazu dient, Daten zwischen Prozessen oder Systemen zu übertragen. Im Gegensatz zu typischen Modellen oder Entitäten sind DTOs frei von Geschäftslogik. Sie kapseln Daten und bieten eine klare und strukturierte Möglichkeit, Informationen zwischen verschiedenen Schichten einer Anwendung oder zwischen verschiedenen Systemen zu übertragen.

DTO-Muster

Das DTO-Muster wird verwendet, um Daten über verschiedene Subsysteme innerhalb einer Softwareanwendung zu übertragen. Die Hauptziele der Verwendung von DTOs bestehen darin, die Anzahl der Methodenaufrufe zu minimieren, die erforderlichen Daten zu aggregieren und einen strukturierten Ansatz für die Verwaltung von Datentransformationen und -validierungen anzubieten.

Vorteile der Verwendung von DTOs

Trennung von Belangen: DTOs isolieren Geschäftslogik von der Datendarstellung, was zu saubererem, besser wartbarem Code führt, der leichter zu verstehen ist.
Datenvalidierung: DTOs ermöglichen die Validierung von Daten, bevor sie von anderen Anwendungsschichten verarbeitet werden, und stellen so sicher, dass nur gültige Daten verwendet werden.
Konsistenz: Durch die Bereitstellung einer konsistenten Struktur für die Datenübertragung vereinfachen DTOs die Verwaltung und Verarbeitung von Daten aus verschiedenen Quellen.
Sicherheit: DTOs können Ihre Anwendung vor unbefugter Datenmanipulation schützen, indem sie steuern, welche Daten zugänglich und änderbar sind.
Testen: Da DTOs einfache Objekte ohne eingebettete Geschäftslogik sind, sind sie einfacher zu simulieren und zu testen.
Transformation: DTOs erleichtern die Transformation von Daten in Formate, die von verschiedenen Anwendungsschichten benötigt werden.
Unveränderlichkeit: DTOs fördern oft Unveränderlichkeit, was bedeutet, dass sich ihr Zustand nach ihrer Erstellung nicht mehr ändern kann. Diese Funktion bringt mehrere Vorteile mit sich:
- Vorhersagbarkeit: Unveränderliche Objekte sind vorhersehbar und leichter zu begründen, da ihr Zustand nach der Erstellung konstant bleibt.
- Thread-Sicherheit: Unveränderlichkeit unterstützt von Natur aus die Thread-Sicherheit und vereinfacht die gleichzeitige Verarbeitung.
- Debugging: Das Debuggen ist bei unveränderlichen Objekten einfacher, da ihr Zustand während ihres gesamten Lebenszyklus garantiert unverändert bleibt.

PHP 8.2 und Readonly-Klassen

Mit PHP 8.2 verbessert die Einführung von schreibgeschützten Klassen die Verwendung von DTOs. Bei schreibgeschützten Klassen entfällt die Notwendigkeit, Eigenschaften explizit als schreibgeschützt zu definieren, was Ihre DTO-Implementierungen vereinfacht. So verbessern die schreibgeschützten Klassen von PHP 8.2 DTOs:

Vereinfachter Code: Schreibgeschützte Klassen machen Eigenschaften automatisch unveränderlich, wodurch der Boilerplate-Code reduziert und die Klarheit verbessert wird.
Erhöhte Sicherheit: Indem sichergestellt wird, dass Eigenschaften nach dem Festlegen nicht mehr geändert werden können, verbessern schreibgeschützte Klassen die Datenintegrität und -sicherheit.
Verbesserte Wartbarkeit: Die Verwendung von schreibgeschützten Klassen führt zu saubererem, besser wartbarem Code, da die Unveränderlichkeit von Daten durch die Sprache selbst erzwungen wird.

Beispiel: Verwendung von DTOs in einem Property-Management-System

Betrachten wir ein Immobilienverwaltungssystem, bei dem Eigenschaften aus verschiedenen Quellen wie einer API und CSV-Importen stammen können. Wir können DTOs verwenden, um das Immobilienmodell, Abonnements, Assets usw. zu erstellen und so sicherzustellen, dass die Daten in der gesamten Anwendung konsistent und validiert sind.

Definieren des PropertyDTO

Zuerst definieren wir eine PropertyDTO-Klasse:

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

Nach dem Login kopieren

Verwenden des PropertyDTO

So können Sie PropertyDTO verwenden, um Eigenschaften aus verschiedenen Quellen zu verwalten:

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

Nach dem Login kopieren

Zusammenfassung

Data Transfer Objects (DTOs) bieten zahlreiche Vorteile in Laravel-Anwendungen, indem sie Datenkonsistenz, Validierung und Trennung von Bedenken gewährleisten. Durch die Implementierung von DTOs können Sie Ihre Anwendung wartbarer, sicherer und einfacher zu testen machen. In einem Immobilienverwaltungssystem helfen DTOs dabei, Daten aus verschiedenen Quellen wie APIs und CSV-Importen effizient zu verarbeiten und sicherzustellen, dass Ihre Geschäftslogik sauber bleibt und sich auf die Verarbeitung validierter Daten konzentriert.

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

Nach dem Login kopieren

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."

Das obige ist der detaillierte Inhalt vonEntdecken Sie die Vorteile von Data Transfer Objects (DTOs) und wie PHP Readonly-Klassen Ihren Laravel-Code verbessern können. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!