Dans le développement d'applications Web modernes, la gestion et le transfert de données efficaces et sécurisés sont essentiels. Un modèle de conception qui facilite considérablement ce processus est l'objet de transfert de données (DTO). Cet article approfondira les avantages de l'utilisation des DTO, en particulier dans une application Laravel, et montrera comment les classes PHP 8.2 en lecture seule peuvent améliorer encore leurs avantages.
Un objet de transfert de données (DTO) est un objet simple conçu pour transporter des données entre des processus ou des systèmes. Contrairement aux modèles ou entités classiques, les DTO sont exempts de logique métier. Ils encapsulent les données, offrant un moyen clair et structuré de transférer des informations entre différentes couches d'une application ou entre différents systèmes.
Le modèle DTO est utilisé pour transférer des données entre différents sous-systèmes au sein d'une application logicielle. Les principaux objectifs de l'utilisation des DTO sont de minimiser le nombre d'appels de méthode, d'agréger les données nécessaires et d'offrir une approche structurée pour gérer les transformations et les validations des données.
Séparation des préoccupations : Les DTO isolent la logique métier de la représentation des données, ce qui donne lieu à un code plus propre, plus maintenable et plus facile à comprendre.
Validation des données : Les DTO permettent la validation des données avant qu'elles ne soient traitées par d'autres couches d'application, garantissant ainsi que seules les données valides sont utilisées.
Cohérence : En fournissant une structure cohérente pour le transfert de données, les DTO simplifient la gestion et le traitement des données provenant de diverses sources.
Sécurité : Les DTO peuvent protéger votre application contre toute manipulation non autorisée de données en contrôlant quelles données sont accessibles et modifiables.
Test : Étant donné que les DTO sont des objets simples sans logique métier intégrée, ils sont plus simples à simuler et à tester.
Transformation : Les DTO facilitent la transformation des données dans les formats requis par différentes couches d'application.
Immuabilité : Les DTO favorisent souvent l'immuabilité, ce qui signifie qu'une fois créés, leur état ne peut pas changer. Cette fonctionnalité apporte plusieurs avantages :
Avec PHP 8.2, l'introduction de classes en lecture seule améliore l'utilisation des DTO. Les classes en lecture seule éliminent le besoin de définir explicitement les propriétés en lecture seule, simplifiant ainsi vos implémentations DTO. Voici comment les classes en lecture seule de PHP 8.2 améliorent les DTO :
Considérons un système de gestion immobilière où les propriétés peuvent provenir de diverses sources telles qu'une API et des importations CSV. Nous pouvons utiliser des DTO pour créer le modèle de propriété, les abonnements, les actifs, etc., en garantissant que les données sont cohérentes et validées dans toute l'application.
Tout d'abord, définissons une classe 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;
}
}
Voici comment utiliser PropertyDTO pour gérer des propriétés provenant de différentes sources :
// 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();
Les objets de transfert de données (DTO) offrent de nombreux avantages dans les applications Laravel en garantissant la cohérence, la validation et la séparation des préoccupations des données. En implémentant des DTO, vous pouvez rendre votre application plus maintenable, plus sécurisée et plus facile à tester. Dans un système de gestion immobilière, les DTO aident à gérer efficacement les données provenant de diverses sources telles que les API et les importations CSV, garantissant ainsi que votre logique métier reste propre et axée sur le traitement des données validées.
Moreover, embracing immutability within DTOs enhances predictability, thread-safety, and simplifies debugging.
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.
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;
}
}
}
}
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."
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!
Comparez les similitudes et les différences entre deux colonnes de données dans Excel
nouvelles fonctionnalités de jdk8
Quels sont les logiciels bureautiques
Comment entrer les privilèges root sous Linux
Supprimer l'historique de recherche
erreur de script
La différence entre les serveurs d'applications légers et les serveurs cloud
Utilisation de console.log
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
