Comment utiliser l'interface jsonserialisable

Au cours des dernières années, JSON a pris le relais en tant que formats King of Data Interchange. Avant JSON, XML a gouverné le perchoir. C'était génial pour modéliser des données complexes, mais il est difficile à analyser et est très verbeux. JSON a vraiment décollé avec la prolifération de riches sites axés sur l'Ajax car il s'agit d'un format lisible très humain, rapide à analyser et sa représentation simple / valeur clé supprime toute la verbosité de XML.

Je pense que nous pourrions tous convenir que écrire moins de code qui nécessite à son tour moins de maintenance et introduit moins de bogues est un objectif que nous aimerions tous atteindre. Dans cet article, je voudrais vous présenter une interface peu connue qui a été introduite dans PHP 5.4.0 appelée jsonSerializable.

Avant que l'interface JSonSerialisable ne soit disponible, le retour d'une représentation codée JSON d'un objet pour un service consommé signifiait l'une des deux choses.

Les plats clés

• L'interface JSonSerialisable dans PHP 5.4.0 offre un moyen plus efficace de renvoyer une représentation codée JSON d'un objet, éliminant la nécessité de construire une structure de données en dehors de l'objet ou d'internaliser la fonctionnalité de codage au sein de l'objet.
• L'interface jsonSerializable permet la mise en œuvre d'une méthode jsonserialize au sein de la classe, qui est automatiquement déclenchée lorsqu'une instance de la classe est encodée JSON. Cette méthode renvoie un tableau des données de l'objet, simplifiant le processus de mise à jour des données si des modifications sont nécessaires.
• La mise en œuvre de l'interface JSonSerializable améliore la maintenabilité du code et réduit les chances d'introduire des bogues, car il supprime la duplication et permet aux autres de tester plus facilement la capacité de l'objet à être encodé en vérifiant s'il s'agit d'une instance de JSonSerializable.

le laid

La première approche a été de construire une structure de données en dehors de l'objet qui contenait toutes les données que nous voulions exposer.

<span><span><?php
</span></span><span>
</span><span><span>class Customer
</span></span><span><span>{
</span></span><span>
</span><span>    <span>private $email = null;
</span></span><span>    <span>private $name = null;
</span></span><span>
</span><span>    <span>public function __construct($email, $name)
</span></span><span>    <span>{
</span></span><span>        <span>$this->email = $email;
</span></span><span>        <span>$this->name = $name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getName()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getEmail()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->email;
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>$customer = new Customer('customer@sitepoint.com', 'Joe');
</span></span><span>
</span><span><span>$data = [
</span></span><span>    <span>'customer' => [
</span></span><span>        <span>'email' => $customer->getEmail(),
</span></span><span>        <span>'name' => $customer->getName()
</span></span><span>    <span>]
</span></span><span><span>];
</span></span><span>
</span><span><span>echo json_encode($data);</span></span>

Nous avons utilisé un tableau ici pour maintenir les données de l'objet client que nous voulions encoder, mais cela aurait tout aussi facilement pu être une STDClass.

Cette approche était flexible et a servi son objectif dans des situations très simples où nous savions que l'objet client n'allait pas changer et nous n'allions que les données des clients dans ce format, à cet endroit. Nous avions également la possibilité d'ajouter des données à ce tableau à partir d'autres sources si nous en avions besoin.

Cependant, comme nous l'avons tous vécu à un moment ou à un autre, les hypothèses que nous avons faites peuvent être prouvées fausses à un préavis des instants. Nous pourrions obtenir une exigence qui nous demande d'ajouter plus de données à la classe client. Ces nouvelles données devront être renvoyées au service consommé et nous voulons le faire dans de nombreux endroits.

Comme vous pouvez l'imaginer, cette approche devient rapidement gênante. Non seulement nous devons dupliquer ce code de tableau partout dans notre application, mais nous devons nous rappeler de mettre à jour tous ces cas où davantage de changements entrent inévitablement. Il existe cependant un autre moyen, cela nous aidera à annuler certains de ces problèmes.

le mauvais

Heureusement, nous étions intelligents lorsque la première demande de changement est arrivée et nous avons réalisé que la duplication de notre tableau allait être un cauchemar, donc ce que nous avons décidé de faire était d'internaliser cette fonctionnalité de codage dans notre objet, en supprimant les problèmes de maintenance et en réduisant le la probabilité d'introduire des bugs.

<span><span><?php
</span></span><span>
</span><span><span>class Customer
</span></span><span><span>{
</span></span><span>
</span><span>    <span>private $email = null;
</span></span><span>    <span>private $name = null;
</span></span><span>
</span><span>    <span>public function __construct($email, $name)
</span></span><span>    <span>{
</span></span><span>        <span>$this->email = $email;
</span></span><span>        <span>$this->name = $name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getName()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getEmail()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->email;
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>$customer = new Customer('customer@sitepoint.com', 'Joe');
</span></span><span>
</span><span><span>$data = [
</span></span><span>    <span>'customer' => [
</span></span><span>        <span>'email' => $customer->getEmail(),
</span></span><span>        <span>'name' => $customer->getName()
</span></span><span>    <span>]
</span></span><span><span>];
</span></span><span>
</span><span><span>echo json_encode($data);</span></span>

Maintenant, si d'autres demandes de modification viennent qui veulent que plus de données soient ajoutées et renvoyées de l'objet client, nous pouvons simplement mettre à jour la méthode TOJSON.

Cette approche présente ses propres inconvénients, cependant. Quiconque vient et veut utiliser notre client doit être conscient de cette méthode Tojson, car ce n'est pas quelque chose qui est facilement vérifié, nous aurions donc besoin de documentation précise. Nous devons également nous rappeler que cette méthode renvoie JSON maintenant (bien que nous puissions déplacer la sérialisation en dehors de la méthode). Cela rend la combinaison des données des clients avec d'autres sources de données plus maladroites, car nous devons faire attention à ne pas coder à nouveau le résultat de cette méthode car cela provoquerait des bogues désagréables.

le bon

Enfin, entrez l'interface JSonSerializable. Cela nous donne toute la flexibilité du scénario laid avec les avantages de maintenabilité du mauvais scénario. Bien que pour utiliser cette interface, vous devrez exécuter PHP 5.4.0 que vous devriez vraiment faire de toute façon, car il existe de nombreuses améliorations par rapport aux versions plus anciennes.

ainsi, aux affaires.

<span><span><?php
</span></span><span>
</span><span><span>class Customer
</span></span><span><span>{
</span></span><span>
</span><span>    <span>public $email = null;
</span></span><span>    <span>public $name = null;
</span></span><span>
</span><span>    <span>public function __construct($email, $name)
</span></span><span>    <span>{
</span></span><span>        <span>$this->email = $email;
</span></span><span>        <span>$this->name = $name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getName()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->name;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function getEmail()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->email;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function toJson()
</span></span><span>    <span>{
</span></span><span>        <span>return json_encode([
</span></span><span>            <span>'customer' => [
</span></span><span>                <span>'email' => $this->getEmail(),
</span></span><span>                <span>'name' => $this->getName()
</span></span><span>            <span>]
</span></span><span>        <span>]);
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>$customer = new Customer('customer@sitepoint.com', 'Joe');
</span></span><span>
</span><span><span>echo $customer->toJson();</span></span>

Comme vous pouvez le voir, nous implémentons JSonSerializable en ajoutant l'interface à notre classe, puis en ajoutant une méthode jsonSerialize au corps de notre classe pour satisfaire le contrat d'interfaces.

Dans la méthode JSonSerialize, nous construisons et renvoyons un tableau des données d'objet, tout comme nous l'avons fait avec les autres exemples. Encore une fois, si quelque chose change, nous pouvons simplement mettre à jour cette seule méthode. Vous remarquerez que la méthode jsonserialize ne renvoie qu'un tableau.

La magie vient lorsque vous souhaitez déclencher cette méthode, tout ce que nous avons à faire maintenant, c'est que JSON encode une instance de cette classe et cette méthode sera appelée automatiquement, le tableau de données renvoyé puis encodé! Maintenant que la classe implémente une interface, nous bénéficions de la possibilité de vérifier si cette classe est une instance de jsonserializable. Si vous le vouliez, vous pouvez également taper un indice des méthodes pour vous assurer qu'une interface jsonSerialisable est passée.

Résumé

Avec cette implémentation simple, nous avons supprimé la duplication, diminué la quantité de maintenance et réduit les chances d'introduire des bogues. Nous avons également rendu trivial pour qu'une autre personne utilise notre code pour tester la capacité de l'objet à être codé en vérifiant s'il s'agit d'une instance de jsonSerialisable.

Les exemples ci-dessus sont bien sûr artificiels, cependant, j'espère que j'ai réussi à démontrer les avantages de l'utilisation de cette interface et de vous inspirer à aller de l'avant et à l'utiliser vous-même.

Questions fréquemment posées (FAQ) sur l'interface jsonsérialisable

Quel est le but principal de l'interface JSonSerialisable dans PHP?

L'interface jsonSerialisable dans PHP est principalement utilisée pour personnaliser la représentation JSON d'un objet. Lorsqu'un objet est transmis à la fonction json_encode (), s'il implémente l'interface jsonSerializable, la méthode jsonSerialize () sera appelée, permettant à l'objet de dicter comment il doit être sérialisé. Cela fournit un niveau élevé de contrôle sur la sortie JSON, ce qui facilite la gestion des structures de données complexes ou effectuer des transformations sur les données avant qu'elle ne soit codée.

Comment fonctionne la méthode jNonSerialize ()?

La méthode jsonSerialize () fait partie de l'interface JSonSerializable. Lorsqu'un objet implémentant cette interface est transmis à json_encode (), la méthode jsonSerialize () est automatiquement appelée. Cette méthode doit renvoyer une structure de données prête à être sérialisée en JSON. Il peut s'agir d'un tableau, d'une chaîne, d'un nombre ou même d'un autre objet. Les données renvoyées seront ensuite codées par JSON_Encode () dans une chaîne JSON.

Puis-je utiliser une interface JSonSerializable avec des propriétés privées?

Oui, vous pouvez utiliser l'interface JSonSerialisable avec des propriétés privées. La méthode jsonSerialize () a accès aux propriétés privées et protégées de l'objet, vous permettant de les inclure dans les données renvoyées pour la sérialisation. Cela peut être utile lorsque vous souhaitez encoder l'état interne d'un objet en JSON, mais gardez toujours les propriétés privées ou protégées au sein de la classe.

Comment puis-je gérer les exceptions dans la méthode jsonSerialize ()?

Si une exception est jetée dans la méthode jsonSerialize (), elle ne sera pas capturée par JSON_ENCODOD (). Au lieu de cela, json_encode () reviendra faux, et l'exception devra être capturée et gérée séparément. Pour gérer les exceptions dans jSonSerialize (), vous pouvez utiliser un bloc d'essai dans la méthode elle-même, vous permettant de gérer l'exception et de renvoyer une structure de données valide pour la sérialisation.

Puis-je utiliser l'interface jsonSerialisable pour décoder JSON ?

Non, l'interface JSonSerialisable n'est utilisée que pour coder des objets en JSON. Pour décoder JSON, vous utiliseriez la fonction json_decode (). Cependant, vous pouvez créer une méthode au sein de votre classe pour gérer le décodage et la reconstruction d'un objet à partir d'une chaîne JSON.

Comment puis-je utiliser une interface JSonSerializable avec des objets imbriqués?

Si vous avez un objet qui contient d'autres objets et que vous souhaitez coder toute la structure en JSON, chaque objet imbriqué doit également implémenter l'interface JSonSerialisable. Lorsque JSON_ENCODE () est appelé sur l'objet parent, il appellera également jSonSerialize () sur chaque objet imbriqué, permettant à chacun de dicter comment il devrait être sérialisé.

Puis-je utiliser une interface jsonSerialisable avec les tableaux?

Oui, vous pouvez utiliser l'interface jsonSerialisable avec les tableaux. Si le tableau contient des objets, chaque objet doit implémenter l'interface jsonSerializable. Lorsque json_encode () est appelé sur le tableau, il appellera jsonSerialize () sur chaque objet dans le tableau, permettant à chacun de dicter comment il doit être sérialisé.

Comment puis-je personnaliser la sortie JSON avec JSONSerializable Interface Interface ?

Vous pouvez personnaliser la sortie JSON en renvoyant une structure de données personnalisée à partir de la méthode jsonSerialize (). Il peut s'agir d'un tableau avec des touches personnalisées, une chaîne, un nombre ou un autre objet. La structure de données que vous retournez de jSonSerialize () sera les données qui sont codées en JSON.

Puis-je utiliser une interface JSonSerializable avec des tableaux multidimensionnels?

Oui, vous pouvez utiliser l'interface JSonSerialisable avec Tableaux multidimensionnels. Si les tableaux contiennent des objets, chaque objet doit implémenter l'interface jsonSerializable. Lorsque JSON_ENCODE () est appelé sur le tableau multidimensionnel, il appellera JSonSerialize () sur chaque objet dans le tableau, permettant à chacun de dicter comment il doit être sérialisé.

Puis-je utiliser JsonSerialidable Interface avec non assocatif tableaux?

Oui, vous pouvez utiliser l'interface JSonSerializable avec des tableaux non associatifs. Si le tableau contient des objets, chaque objet doit implémenter l'interface jsonSerializable. Lorsque JSON_ENCODE () est appelé sur le tableau non associatif, il appellera JSonSerialize () sur chaque objet dans le tableau, permettant à chacun de dicter comment il doit être sérialisé.

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!