Français
Français
Dans PHP, la fonction sérialisée est utilisée pour convertir une variable PHP en un format de chaîne qui peut être stocké ou transféré. Cette fonction peut sérialiser la plupart des types de données, y compris des tableaux, des objets, des chaînes, des entiers, etc.
Les types de ressources se réfèrent aux ressources externes en PHP, qui représentent des interactions avec des systèmes ou d'autres programmes, tels que des poignées de fichiers, des connexions de base de données ou des poignées de boucle. Étant donné que ces ressources sont généralement des références à des systèmes ou à des applications externes, lors de la sérialisation des ressources, PHP ne peut pas savoir les reconstruire lors de la désérialisation. Par conséquent, vous devez être très prudent lorsque vous sérialisation des types de ressources tels que les poignées de fichiers.
Le type de ressource contient un pointeur vers une ressource externe qui peut disparaître après l'exécution du script PHP. Par conséquent, PHP ne peut garantir que les ressources sérialisées sont toujours valides lorsqu'elles sont désérialisées. Par exemple, une poignée de fichier pointe vers un fichier ouvert dans le système d'exploitation. Cette poignée de fichier perd sa connexion réelle au fichier pendant la sérialisation et ne peut pas rouvrir le fichier pendant la désérialisation.
Il existe généralement deux façons courantes de gérer correctement les types de ressources: ignorer la sérialisation des types de ressources ou les traiter manuellement lors de la sérialisation.
Le moyen le plus simple est d'éviter les types de ressources de sérialisation. Cela peut être fait en remplaçant le type de ressource par d'autres structures de données avant la sérialisation, telles que le stockage du contenu du fichier sous forme de chaînes ou l'utilisation d'un chemin de fichier au lieu d'une poignée de fichier. Pendant la désérialisation, vous pouvez rouvrir le fichier ou créer une nouvelle ressource.
Exemple de code:
// Convertir la poignée du fichier en chemin de fichier
$file = fopen('/path/to/file.txt', 'r');
$data = ['file' => '/path/to/file.txt']; // Utilisez des chemins au lieu des ressources
// Sérialiser les données
$serializedData = serialize($data);
// 反Sérialiser les données
$unserializedData = unserialize($serializedData);
// Rouvrir la poignée du fichier
$fileHandle = fopen($unserializedData['file'], 'r');
De cette façon, nous convertissons la poignée du fichier en chemin de fichier et n'incluons pas le type de ressource pendant la sérialisation. Après désérialisation, nous ouvrons à nouveau le fichier, restaurant l'opération d'origine.
Si vous devez sérialiser des objets complexes contenant des types de ressources, vous pouvez personnaliser le comportement de sérialisation et de désérialisation des objets en implémentant les méthodes magiques __Sleep et __wakeup . Cela vous permet d'ignorer le type de ressource pendant la sérialisation ou de le remplacer par d'autres formats sérialisables, puis de le restaurer au type de ressource d'origine pendant la désérialisation.
Exemple de code:
class FileHandler
{
private $file;
public function __construct($filePath)
{
$this->file = fopen($filePath, 'r');
}
// Méthode de sérialisation personnalisée
public function __sleep()
{
// Sérialiser les chemins de fichier uniquement，Ne pas déposer des ressources
return ['filePath'];
}
// Méthode de désérialisation personnalisée
public function __wakeup()
{
// Rouvrir le fichier lors de la désérialisation
$this->file = fopen($this->filePath, 'r');
}
}
// Créer un objet et le sérialiser
$fileHandler = new FileHandler('/path/to/file.txt');
$serializedFileHandler = serialize($fileHandler);
// Désérialiser et restaurer les poignées de fichiers
$unserializedFileHandler = unserialize($serializedFileHandler);
Dans cet exemple, nous évitons la sérialisation directe des poignées de fichiers dans la méthode __Sleep et conservons uniquement le chemin du fichier. Dans la méthode __wakeup , nous rouvrons le fichier et restaurons la poignée du fichier.
Dans certains cas, les types de ressources (tels que les poignées de fichiers) peuvent représenter les URL distantes. Au lieu de sérialiser la ressource entière, vous pouvez choisir de stocker et de sérialiser ces URL en tant que chaînes.
Par exemple, supposons que vous ayez une poignée de fichier pointant vers un fichier distant, que vous pouvez remplacer par l'URL correspondant et recueillit le fichier distant lorsqu'il est désérialisé.
Exemple de code:
$fileUrl = 'http://gitbox.net/path/to/file.txt'; // utiliser URL Au lieu de la poignée du fichier
// Sérialiser les fichiers URL
$serializedFileUrl = serialize(['fileUrl' => $fileUrl]);
// 反Sérialiser les fichiers URL
$unserializedFileUrl = unserialize($serializedFileUrl);
// Quand la désérialisation，Tu peux URL Obtenir des fichiers ou effectuer d'autres opérations
echo "The file URL is: " . $unserializedFileUrl['fileUrl'];
Ici, nous stockons la chaîne URL du fichier dans les données sérialisées et restaurons cette URL lorsqu'il est désérialisé. Cela évite les problèmes causés par la sérialisation des poignées de fichiers, tout en étant en mesure de stocker et de transférer les informations nécessaires.
Lorsque vous utilisez la fonction de sérialisation de PHP, vous devez être très prudent lors de la gestion des types de ressources (tels que des poignées de fichiers). Le sérialisation directement des types de ressources peut conduire à un comportement imprévisible pendant la désérialisation et même aux erreurs. La meilleure pratique consiste à éviter la sérialisation des types de ressources ou à les traiter grâce à des méthodes de sérialisation et de désérialisation personnalisées. Grâce à ces méthodes, vous pouvez vous assurer que les ressources système sont correctement traitées et restaurées pendant le processus de sérialisation et de désérialisation.
