PHP序列化与反序列化学习

时间：2020-05-15 18:04:27 收藏：0 阅读：60

<h6>序列化与反序列化学习</h6>
把对象转换为字节序列的过程称为对象的序列化；把字节序列恢复为对象的过程称为对象的反序列化。
<pre><code><?php

class UserInfo {

 public $name = "admin";

 public $age = 1;

 public $blog = "file:///var/www/html/flag.php";

}

$data = new UserInfo();

echo serialize($data);

?>
</code></pre>

页面显示： 
<code>O:8:"UserInfo":3:{s:4:"name";s:5:"admin";s:3:"age";i:1;s:4:"blog";s:29:"file:///var/www/html/flag.php";}</code> 
此处调用到了serialize函数，对数据进行了序列化并返回了一组字符串。

<pre><code><?php
$sites = array(‘t1‘, ‘tt2‘, ‘ttt3‘);
$serialized_data = serialize($sites);
echo $serialized_data;
?>
</code></pre>

输出：<code>a:3:{i:0;s:2:"t1";i:1;s:3:"tt2";i:2;s:4:"ttt3";}</code>
对这个序列化的输出进行分析：

<pre><code>a:3表示数组里面有三个分类。
i:0：表示第一个数组。
s:2：表示有两个字符
"t1":表示内容为‘t1‘。

i:1：表示第二个数组。
s:3:"tt2"：标识有三个字符，内容为‘tt2‘
</code></pre>

反序列化：
 <?php
 $sites = array(‘t1‘, ‘tt2‘, ‘ttt3‘);
 $serializeddata = serialize($sites);
 #echo $serializeddata;
 $unserializeddata = unserialize($serializeddata);
 printr($unserializeddata);
 ?>
此时又生成回：<code>Array ( [0] => t1 [1] => tt2 [2] => ttt3 )</code>

其中：o表示对象,a表示数组,s表示字符,i表示数字
<h4>类</h4>
在php中，一个类可以包含有属于自己的常量，变量（属性）以及函数（方法） 
一段反序列化，序列化代码：（来自https://www.jianshu.com/p/8f498198fc3d）
<pre><code><?php
class Test
{
 public $handle1;
 private $handle2;
 protected $handle3;

 public function __construct($handle1,$handle2,$handle3)
 {
 $this->handle1 = $handle1;
 $this->handle2 = $handle2;
 $this->handle3 = $handle3;
 echo ‘__construct ‘;
 }
 public function __destruct()
 {
 echo $this->handle2.‘ ‘;
 echo ‘__destruct ‘;
 }
 public function __wakeup()
 {
 echo ‘__wakeup ‘;
 }
}

$obj = new Test("111","222","333");
$see = serialize($obj);
print ‘Serialized: ‘ . $see . ‘ ‘;
# %00Test%00v2 表示 private %00*%00v3 表示protected
$ss = ‘O:4:"Test":3:{s:7:"handle1";s:3:"777";s:17:"%00Test%00handle2";s:3:"888";S:14:"%00*%00handle3";s:3:"999";}‘;
$obj2 = unserialize($ss);
var_dump($obj2);

?>
</code></pre>

在这段php代码中： 
<code>$obj = new Test("111","222","333");</code>创建了类的实例，所以使用到了new的关键字。
在类中对于静态方法和静态属性的引用：

<pre><code>class Test{
public static $test = 1;
public static function test(){
}
}
</code></pre>

此时我们不用实例化对象，直接使用Test::$test就能获取$test属性的值，Test::test()这样可以直接调用静态方法test。

范围解析操作符：可以用于访问静态成员，类常量，还可以用于覆盖类中的属性和方法，即<code>：：</code>
<pre><code><?php
class MyClass {
 const CONST_VALUE = ‘A constant value‘;
}

$classname = ‘MyClass‘;
echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起
echo ‘ ‘;
echo MyClass::CONST_VALUE;
?>
</code></pre>

此时我们就使用了变量静态地调用了类MyClass当中的常量，注意自 PHP 5.3.0 起，可以通过变量来引用类，但该变量的值不能是关键字。 
结果：

<pre><code>A constant value
A constant value
</code></pre>

使用子类覆盖父类：
<pre><code><?php
class OtherClass extends MyClass
{
 public static $my_static = ‘static var‘;

 public static function doubleColon() {
 echo parent::CONST_VALUE . "\n";
 echo self::$my_static . "\n";
 }
}

$classname = ‘OtherClass‘;
echo $classname::doubleColon(); // 自 PHP 5.3.0 起

OtherClass::doubleColon();
?>
</code></pre>

此时PHP不会调用父类中已被覆盖的方法，是否调用父类的方法取决于子类。
调用父类方法：
<pre><code><?php
class MyClass
{
 protected function myFunc() {
 echo "MyClass::myFunc()\n";
 }
}

class OtherClass extends MyClass
{
 // 覆盖了父类的定义
 public function myFunc()
 {
 // 但还是可以调用父类中被覆盖的方法
 parent::myFunc();
 echo "OtherClass::myFunc()\n";
 }
}

$class = new OtherClass();
$class->myFunc();
?>
</code></pre>

输出： 
<code>MyClass::myFunc() OtherClass::myFunc()</code> 
其中-> 是对象成员访问符号。 
例如：<code>$this->name = $value</code> 
其中：$this是特定变量，它代表了他的类，通过->我们可以访问其类的成员，所以这段代码的意思就是：将当前类的name变量的值设置为 $value. 
继承：类可以在声明中用 extends 关键字继承另一个类的方法和属性。PHP不支持多重继承，一个类只能继承一个基类。

<pre><code>class Father
{
 public $aar;

 public function bar ()
 {
 return ‘father‘;
 }

 final public function testFinal ()
 {
 return ‘father‘;
 }

}
class Son extends father
{
 public function bar ()
 {
 return ‘son‘;
 }

 public function callFatherBar ()
 {
 return parent::bar();
 }
 //Cannot override final method Father::testFinal()
 // public function testFinal()
 // {

 // }
 //如果父类定义是设置了final 则父类方法均不能覆盖 final class Father
 //属性无final的概念
}
echo (new Son())->bar();//son
echo (new Son())->callFatherBar();//father
</code></pre>

前面写类方法获取属性我们使用的是<code>::</code>这是在静态环境中，对于非静态的，我们使用$this->property即可。 
属性的声明由关键词：public，protected或者private开头，后面加上变量。 
即：

<pre><code>public $handle1;
private $handle2;
protected $handle3;
</code></pre>

我们声明了三个不同属性的变量：
三个关键字控制 public 公有；protected 受保护；private 私有的
<pre><code>public：可以在任何地方被访问

protected：可以被自身或其子类和父类访问，表示方式是在变量名前加上%00类名%00

private：只能被其定义所在的类访问，表示方式是在变量名前加个%00*%00
</code></pre>

还有关于常量的定义： 
<code>const constant = ‘constant value‘;</code>
<h6>构造函数</h6>
在PHP5中，可以在一个类中定义一个构造函数，具有构造函数的类，当每次创建新的对象的时候会先调用这个方法，以方便我们在使用对象前做一些初始化工作。

<pre><code>class Father
{
 function __construct ()//不可为private
 {
 echo ‘Father‘;
 }
}

class Child extends Father
{ //当Child无构造函数时，自动调用父类的 Father
 function __construct ()
 {
 echo ‘Child‘;
 }

 function callFatherConstruct ()
 {
 parent::__construct();
 }
}

$obj = new Child;//Child

$obj->callFatherConstruct();//Father
</code></pre>

子类中定义了构造函数，不会隐式的调用父类的构造函数，需要用parent::__construct()调用，如果子类没有构造函数，父类的构造函数将和普通函数一样被子类继承。
参考链接：<a href="https://www.cnblogs.com/ValleyUp/p/11181141.html">https://www.cnblogs.com/ValleyUp/p/11181141.html</a>
<h6>magic函数</h6>
php类包含magic函数的特殊函数，magic函数命名是以符号 __ 开头的，例如 __ sleep, __ wakeup,__ construct, __ destruct等。 
这些函数经常会被自动调用，construct当一个对象创建时被调用，destruct当一个对象销毁时被调用。 
常用的魔术方法有：

<pre><code>serialize()：检查类中是否存在一个魔术方法 __sleep()，优先调用此方法，然后执行序列化操作。
unserialize()：检查是否存在一个 __wakeup() 方法，优先调用此方法
__construct()：当一个对象创建时被调用
__destruct()：当一个对象销毁时被调用
__call()：当调用一个未定义(包括没有权限访问)的方法是调用此方法
__callStatic()：处理静态方法调用
__get()：当调用一个未定义的属性时访问此方法
__set()：给一个未定义的属性赋值时调用
__isset()：当在一个未定义的属性上调用isset()函数时调用此方法
__unset()：当在一个未定义的属性上调用unset()函数时调用此方法
__sleep()：常用于提交未提交的数据，或类似的清理操作，在对象被序列化之前运行
__wakeup()：用于预先准备对象需要的资源，在对象被反序列化之后被调用
__toString()：用于一个类被当成字符串时应怎样回应。例如 echo $obj; 应该显示些什么。此方法必须返回一个字符串
__invoke()：当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用。
__set_state()，：当调用var_export()时，这个静态方法会被调用（自PHP 5.1.0起有效）。本方法的唯一参数是一个数组，其中包含按array(’property’ => value, …)格式排列的类属性。
__clone() ：对象赋值时使用的引用赋值，使用clone方法复制一个对象时，对象会自动调用__clone魔术方法
</code></pre>

当序列化字符串中，表示对象属性个数的值大于实际属性个数时，那么就会跳过wakeup方法的执行。 
拿php一个代码为例，综合上面学习的进行理解：
<pre><code><?php
class Connection //定义一个类，类名为Connection
{
 protected $link; //定义一个变量属性，可以被自身或其子类和父类访问
 private $server, $username, $password, $db; //定义了四个变量属性，只能被其定义所在的类访问。

 public function __construct($server, $username, $password, $db) //定义一个方法，可以在任何地方被访问
 {
 $this->server = $server; //$this是特定变量，它代表了他的类connection，通过->我们可以访问其类的成员如server等，将当前类的server变量的值设置为 $server.
 $this->username = $username; //同上，以下皆是。
 $this->password = $password;
 $this->db = $db;
 $this->connect();
 }

 private function connect() //定义一个方法，只能被其定义所在的类访问
 {
 $this->link = mysql_connect($this->server, $this->username, $this->password); //当前的link，用来连接mysql数据库。
 mysql_select_db($this->db, $this->link);
 }

 public function __sleep() //提交数据时，要进行的行为。
 {
 return array(‘server‘, ‘username‘, ‘password‘, ‘db‘); //提交的时候返回
 }

 public function __wakeup() //重新建立数据库连接
 {
 $this->connect();
 }
}
?>
</code></pre>

序列化得到字符串格式：

<pre><code>s:size:value:表示字符。
a:size:{键值；值；元素}，
例如a:3:{i:0;s:2:"t1";i:1;s:3:"tt2";i:2;s:4:"ttt3";}
i:0,表示第一个数组，s:2表示有两个字符，"t1",表示字符为t1。
O：对象长度：对象类名称：成员变量数：{类型：字符个数长度："具体值"；类型：长度："具体值"；.......}
O:4:"Test":3：{s:7:"handle1";s:3:"111";s:13:"Testhandle2";s:3:"222";s:10:"*handle3";s:3:"333";}
O:1:"A":2:{s:6:" A var";i:1139586461;s:4:"var2";s:1:"b";}
</code></pre>

反序列化能将类的成员变量还原，但是不能将类的方式还原。 
解析顺序： 
<img src="https://image.3001.net/images/20190731/1564545530_5d4111fa958d0.png!small" />
<h6>jsonencode/jsondecode</h6>
<pre><code><?php
$a=array(‘a‘=>‘cuit‘,‘b‘=>‘syclover‘,‘c‘=>‘dog‘);
//序列化数组
$s=json_encode($a);
echo $s;
//反序列化
$o=json_decode($s);
?>
</code></pre>

输出：<code>{"a":"cuit","b":"syclover","c":"dog"}</code>