Une plongée approfondie dans la sérialisation et la désérialisation en PHP

Cet article vous donnera une analyse approfondie de la sérialisation et de la désérialisation en PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

[Apprentissage recommandé : "Tutoriel vidéo PHP"]

Sérialisation

Format de sérialisation

En PHP, la sérialisation est utilisée pour stocker ou transférer des valeurs PHP sans perdre leur type et leur structure.

Le prototype de la fonction de sérialisation est le suivant :

string serialize ( mixed $value )

Regardez d'abord l'exemple suivant :

class CC {
	public $data;
	private $pass;

	public function __construct($data, $pass)
	{
		$this->data = $data;
		$this->pass = $pass;
	}
}
$number = 34;
$str = 'uusama';
$bool = true;
$null = NULL;
$arr = array('a' => 1, 'b' => 2);
$cc = new CC('uu', true);

var_dump(serialize($number));
var_dump(serialize($str));
var_dump(serialize($bool));
var_dump(serialize($null));
var_dump(serialize($arr));
var_dump(serialize($cc));

Le résultat de sortie est :

string(5) "i:34;"
string(13) "s:6:"uusama";"
string(4) "b:1;"
string(2) "N;"
string(30) "a:2:{s:1:"a";i:1;s:1:"b";i:2;}"
string(52) "O:2:"CC":2:{s:4:"data";s:2:"uu";s:8:" CC pass";b:1;}"

Donc la sérialisation pour différents types obtiennent Le format de chaîne est :

• String : s:size:value;
• Integer : i:value;
• Boolean : b :value;(Enregistrer 1 ou 0)
• Null : N;
• Array : a:size:{key definition;value definition;(répété par élément)}
• Object : O:strlen(nom de l'objet):nom de l'objet:taille de l'objet:{s:strlen(nom de la propriété):nom de la propriété:définition de la propriété;(répété par propriété)}

Objet sérialisé

Dans l'exemple ci-dessus, nous pouvons voir que lors de la sérialisation d'un objet, seules les valeurs d'attribut seront enregistrées.

• Les constantes de l'objet seront-elles enregistrées ?
• S'il s'agit d'un héritage, les variables de la classe parent seront-elles enregistrées ?

class CB {
	public $CB_data = 'cb';
}

class CC extends CB{
	const SECOND = 60;

	public $data;
	private $pass;

	public function __construct($data, $pass)
	{
		$this->data = $data;
		$this->pass = $pass;
	}

	public function setPass($pass)
	{
		$this->pass = $pass;
	}
}
$cc = new CC('uu', true);

var_dump(serialize($cc));

Le résultat de sortie est :

string(75) "O:2:"CC":3:{s:4:"data";s:2:"uu";s:8:" CC pass";b:1;s:7:"CB_data";s:2:"cb";}"

Évidemment, lors de la sérialisation de l'objet, elle ne sera pas enregistrée. La valeur de la constante. Les variables de la classe parent seront conservées.

Personnalisation de la sérialisation d'objet

Lors de la sérialisation d'un objet, nous n'avons pas besoin de sauvegarder certains attributs sensibles dans l'objet. Comment devons-nous gérer cela ?

Lorsque la fonction serialize() est appelée pour sérialiser un objet, la fonction vérifie s'il existe une méthode magique __sleep() dans la classe. Si elle est présente, cette méthode sera appelée en premier, puis l'opération de sérialisation sera effectuée. Vous pouvez personnaliser le comportement de la sérialisation en surchargeant cette méthode. Le prototype de cette méthode est le suivant :

public array __sleep ( void )

• Cette méthode renvoie un tableau contenant les noms de toutes les variables de l'objet qui doivent être sérialisées
• Cette méthode ne renvoie rien, alors NULL est sérialisé et génère une E_NOTICE erreur de niveau
• __sleep() ne peut pas renvoyer le nom d'un membre privé de la classe parent. Cela générera une erreur de niveau E_NOTICE. Pour le moment, il ne peut être remplacé que par l'interface Serializable.
• Couramment utilisé pour le nettoyage lors de la sauvegarde d'objets volumineux afin d'éviter de sauvegarder trop de données redondantes

Regardez l'exemple suivant :

class User{
	const SITE = 'uusama';

	public $username;
	public $nickname;
	private $password;

	public function __construct($username, $nickname, $password)
	{
		$this->username = $username;
		$this->nickname = $nickname;
		$this->password = $password;
	}

	// 重载序列化调用的方法
	public function __sleep()
	{
		// 返回需要序列化的变量名，过滤掉password变量
		return array('username', 'nickname');
	}
}
$user = new User('uusama', 'uu', '123456');
var_dump(serialize($user));

Le résultat renvoyé est le suivant, évidemment La valeur du champ mot de passe est ignorée lors de la sérialisation.

string(67) "O:4:"User":2:{s:8:"username";s:6:"uusama";s:8:"nickname";s:2:"uu";}"

Stockage d'objets sérialisés

Grâce à l'introduction ci-dessus, nous pouvons sérialiser un objet ou des données copiés dans une chaîne de séquence, et le collègue qui enregistre la valeur enregistre également son structure.

Nous pouvons enregistrer la valeur sérialisée dans un fichier ou un cache. Il n'est pas recommandé de le stocker dans la base de données en raison du problème de lisibilité, et il n'est pas facile à migrer et à maintenir, et il n'est pas facile à interroger.

$user = new User('uusama', 'uu', '123456');
$ser = serialize($user);
// 保存在本地
file_put_contents('user.ser', $ser);

Désérialisation

Méthode d'utilisation

Grâce à l'explication ci-dessus, nous pouvons sérialiser des objets en chaînes et les enregistrer, donc comment restaurer ces chaînes sérialisées à leur état d'origine ? PHP fournit une fonction de désérialisation :

mixed unserialize ( string $str )

unserialize()La fonction de désérialisation est utilisée pour reconvertir une seule variable sérialisée en une valeur PHP.

• Si la chaîne transmise ne peut pas être désérialisée, FALSE est renvoyé et un E_NOTICE
• est renvoyé, qui peut être integer``float, string, array ou object
• Si la variable en cours de désérialisation est un objet, après avoir reconstruit avec succès l'objet, PHP tentera automatiquement d'appeler la fonction membre __wakeup() (si elle existe)

Regardez à l'exemple suivant :

class User{
	const SITE = 'uusama';

	public $username;
	public $nickname;
	private $password;
	private $order;

	public function __construct($username, $nickname, $password)
	{
		$this->username = $username;
		$this->nickname = $nickname;
		$this->password = $password;
	}

	// 定义反序列化后调用的方法
	public function __wakeup()
	{
		$this->password = $this->username;
	}
}
$user_ser = 'O:4:"User":2:{s:8:"username";s:6:"uusama";s:8:"nickname";s:2:"uu";}';
var_dump(unserialize($user_ser));

Le résultat de sortie est :

object(User)#1 (4) {
  ["username"]=>
  string(6) "uusama"
  ["nickname"]=>
  string(2) "uu"
  ["password":"User":private]=>
  string(6) "uusama"
  ["order":"User":private]=>
  NULL
}

Les conclusions suivantes peuvent être tirées :

• __wakeup() La fonction est exécutée après l'objet est construit, donc la valeur de $this->username n'est pas vide
• Lors de la désérialisation, il essaiera de faire correspondre la valeur de la variable et de la copier dans l'objet sérialisé

Gestion des classes non définies

Dans l'exemple ci-dessus, nous avons défini la classe unserialize() à l'avance avant d'appeler la fonction de désérialisation User Si nous Que se passe-t-il s'il n'y a pas de définition ?

$user_ser = 'O:4:"User":2:{s:8:"username";s:6:"uusama";s:8:"nickname";s:2:"uu";}';
var_dump(unserialize($user_ser));

Dans cet exemple, nous n'avons défini aucune User classe. La désérialisation s'est exécutée normalement et aucune erreur n'a été signalée. Le résultat est le suivant :

object(__PHP_Incomplete_Class)#1 (3) {
  ["__PHP_Incomplete_Class_Name"]=>
  string(4) "User"
  ["username"]=>
  string(6) "uusama"
  ["nickname"]=>
  string(2) "uu"
}

Notez que par rapport au. précédemment défini UserLe résultat de la classe, l'objet obtenu par désérialisation est ici __PHP_Incomplete_Class, et le nom de la classe non définie est spécifié.

如果这个时候我们去使用这个反序列化后的不明对象，则会抛出E_NOTICE。这么看着不能用也不是办法，那么如何处理呢？有两种方案。

• 定义__autoload()等函数，指定发现未定义类时加载类的定义文件
• 可通过 php.ini、ini_set() 或 .htaccess 定义unserialize_callback_func。每次实例化一个未定义类时它都会被调用

以上两种方案的实现如下：

// unserialize_callback_func 从 PHP 4.2.0 起可用
ini_set('unserialize_callback_func', 'mycallback'); // 设置您的回调函数
function mycallback($classname) 
{
   // 只需包含含有类定义的文件
   // $classname 指出需要的是哪一个类
}


// 建议使用下面的函数，代替__autoload()
spl_autoload_register(function ($class_name) {
	// 动态加载未定义类的定义文件
    require_once $class_name . '.php';
});

PHP预定义序列化接口Serializable

还记得上面在将序列化过程中遇到的：无法在__sleep()方法中返回父类对象的问题吗，方法就是实现序列化接口Serializable。

该接口的原型如下：

Serializable {
	abstract public string serialize ( void )
	abstract public mixed unserialize ( string $serialized )
}

需要注意的是，如果定义的类实现了Serializable接口，那么序列化和反序列化的时候，PHP就不会再去调用__sleep()方法和__wakeup()方法。

class CB implements Serializable{
	public $CB_data = '';
	private $CB_password = 'ttt';

	public function setCBPassword($password)
	{
		$this->CB_password = $password;
	}

	public function serialize()
	{
		echo __METHOD__ . "\n";
		return serialize($this->CB_password);
	}

	public function unserialize($serialized)
	{
		echo __METHOD__ . "\n";
	}
}

class CC extends CB {
	const SECOND = 60;

	public $data;
	private $pass;

	public function __construct($data, $pass)
	{
		$this->data = $data;
		$this->pass = $pass;
	}

	public function __sleep()
	{
		// 输出调用了该方法名
		echo __METHOD__ . "\n";
	}

	public function __wakeup()
	{
		// 输出调用了该方法名
		echo __METHOD__ . "\n";
	}
}
$cc = new CC('uu', true);
$ser = serialize($cc);
var_dump($ser);
$un_cc = unserialize($ser);
var_dump($un_cc);

运行结果为：

CB::serialize
string(24) "C:2:"CC":10:{s:3:"ttt";}"
CB::unserialize
object(CC)#2 (4) {
  ["data"]=>
  NULL
  ["pass":"CC":private]=>
  NULL
  ["CB_data"]=>
  string(0) ""
  ["CB_password":"CB":private]=>
  string(3) "ttt"
}

可以完全定义serialize()方法，该方法返回的值就是序列化后大括号内的值，只要保证自定义序列化和反序列化的规则一致即可。

题外话

在PHP应用中，序列化和反序列化一般用做缓存，比如session缓存，cookie等。

序列化和反序列化在PHP中用得不算多，在Java语言中用得比较多。其实你有没有发现，这种把一个对象或者数组的变量转化成字符串的方式，json也可以做到。

使用json来实现对象和字符串之间的转换，在PHP中显得更加直观和轻便。而且经过测试，使用json_encode()比serialize()方法更加快速，大概快2~3倍。

在我看来，序列化和反序列化是一种传输抽象数据的思想。通过定义序列化和反序列化的规则，我们可以实现将PHP中的对象序列化成字节流，然后传输给别的语言或者系统使用，这在远程调用里面非常的方便。

更多编程相关知识，请访问：编程视频！！

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!