欢迎光临
我们一直在努力

前端JS与后端PHP加密解密

网页端(在没有https情况下)给密码之类的加密传输,虽然多此一举,也好过直接监控软件就能看到信息

PHP端

    /**
     * 前台加密(对应JS解密)
     * @param $data
     * @param $key
     * @param $iv
     * @return string
     */
    function js_encrypt($data,$key,$iv){
        $data = openssl_encrypt($data,"AES-128-CBC",$key,true,$iv);
        return base64_encode($data);
    }



    /**
     * 前台解密(对应JS加密)
     * @param $data
     * @param $key
     * @param $iv
     * @return string
     */
    function js_decrypt($data,$key,$iv){
        $data = openssl_decrypt(base64_decode($data),"AES-128-CBC",$key,true,$iv);
        $data = rtrim($data,"\0");
        return json_decode($data,true);
    }




 

后端使用

$str = "要加密的文本信息,如果是对象,请转换成文本";
$key = "52c7f81cd24c9699";//16位加密key
$iv = "42e07d2f7199c35d";//16位偏移量

//加密成密文
$new_str = js_encrypt($str,$key,$iv);
var_dump($new_str);
//解密成原文
$old_str = js_decrypt($new_str,$key,$iv);
var_dump($old_str);


16位偏移量可以用通过时间戳+随机数转16位小写的md5实现

 

前端

/**
* 接口数据加密函数
* @param str string 需加密的json字符串
* @param key string 加密key(16位)
* @param iv string 加密向量(16位)
* @return string 加密密文字符串
*/
function js_encrypt(str, key, iv) {
//密钥16位
key = CryptoJS.enc.Utf8.parse(key);
//加密向量16位
iv = CryptoJS.enc.Utf8.parse(iv);
let encrypted = CryptoJS.AES.encrypt(str, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});

return encrypted.toString();
}

/**
* 接口数据解密函数
* @param str string 已加密密文
* @param key string 加密key(16位)
* @param iv string 加密向量(16位)
* @returns {*|string} 解密之后的json字符串
*/
function js_decrypt(str, key, iv) {

//密钥16位
key = CryptoJS.enc.Utf8.parse(key);
//加密向量16位
iv = CryptoJS.enc.Utf8.parse(iv);
let decrypted = CryptoJS.AES.decrypt(str, key, {
iv: iv,
padding: CryptoJS.pad.Pkcs7
}).toString(CryptoJS.enc.Utf8);

return decrypted;
}


前端需要引入类库,基于crypto-js(点击下载)

<!--加密解密类-->
<script src="crypto-js/aes.js" type="text/javascript"></script>

前端使用

let str = "要加密的文本信息,如果是对象,请转换成文本";
let key = "52c7f81cd24c9699";//16位加密key
let iv = "42e07d2f7199c35d";//16位偏移量

//加密成密文
let new_str = js_encrypt(str,key,iv);
console.log(new_str);
//解密成原文
let old_str = js_decrypt(new_str,key,iv);
console.log(old_str);

 

PHP 将 mcrypt_encrypt 迁移至 openssl_encrypt 的方法

为什么要提及迁移,比如 A & B 两套系统使用 AES 加密做数据传输,且 A 作为客户端,B 则是第三方的服务,且 A 已经在使用 7.2.0+ 版本,而 B 作为长期运行的服务仍在使用 7.1.0-,那我们能做的就是在 A 上使用 openssl_簇 原样的实现 mcrypt_簇 的加解密功能,以便兼容 B 服务,且 mcrypt_簇 是有一些需要多加注意的地方,否则迁移之路略微坎坷。

mcrypt_簇 虽说被遗弃了,但 文档页 上依然有很多值得注意的文档贡献,有助于我们将 mcrypt_簇 迁移至 openssl_簇,大家应该仔细看一下。

1.If you're writing code to encrypt/encrypt data in 2015, you should use openssl_encrypt() and openssl_decrypt(). The underlying library (libmcrypt) has been abandoned since 2007, and performs far worse than OpenSSL (which leverages AES-NI on modern processors and is cache-timing safe).
2.Also, MCRYPT_RIJNDAEL_256 is not AES-256, it's a different variant of the Rijndael block cipher. If you want AES-256 in mcrypt, you have to use MCRYPT_RIJNDAEL_128 with a 32-byte key. OpenSSL makes it more obvious which mode you are using (i.e. 'aes-128-cbc' vs 'aes-256-ctr').

3.OpenSSL also uses PKCS7 padding with CBC mode rather than mcrypt's NULL byte padding. Thus, mcrypt is more likely to make your code vulnerable to padding oracle attacks than OpenSSL.

1、即刻起,应尽可能的使用 openssl_簇 代替 mcrypt_簇 来实现数据的加密功能。

2、MCRYPT_RIJNDAEL_256 并不是 AES-256,如果想使用 mcrypt_簇 实现 AES-256,则你应该使用 MCRYPT_RIJNDAEL_128 算法 + 32位的 key,openssl_簇 则更为清晰的明确了各种模式。这里我整理了一下对应关系供大家参考:

MCRYPT_RIJNDAEL_128 & CBC + 16位Key = openssl_encrypt(AES-128-CBC, 16位Key) = AES-128
MCRYPT_RIJNDAEL_128 & CBC + 24位Key = openssl_encrypt(AES-192-CBC, 24位Key) = AES-192
MCRYPT_RIJNDAEL_128 & CBC + 32位Key = openssl_encrypt(AES-256-CBC, 32位Key) = AES-256

(注:AES-128, 192 and 256 的加密 key 的长度分别为 16, 24 and 32 位)

openssl_簇 的确更为清晰明了,而且 mcrypt_get_key_size 得到的 key 长度都是 32 位,所以不太靠谱。

iv 到是会根据 cipher 方法变更 16 、24、32,但 openssl_簇的 AES cipher 的 iv 长度适中要求为 16 位。

所以,我们为了最大的适配,即便现在不会再用,也要知道 mcrypt_簇 实现 AES-128/192/256 的标准方式为:

  • cipher 选 MCRYPT_RIJNDAEL_128
  • 根据 cipher 和 mode 获取 iv 长度并生成 iv
  • 根据实际业务来确定 key 长度: AES-128 16位 / AES-192 24位 / AES-256 32位,而不是使用 mcrypt_get_key_size

3、这一点其实蛮重要的,涉及 加密算法数据块 & 填充算法PKCS7 的概念。我在支付宝 alipay SDK 中有看到此算法的实现,虽然 sdk 中仍然使用的 mcrypt_簇,但已结合了 PKCS7 填充算法,为什么要这样做呢?其一是为了安全&兼容,php mcrypt 会使用 null(‘0’) 对数据块进行填充,java/.net 则是使用 PKCS7。其二则是为后期迁移至 openssl_簇 的准备,openssl 的填充模式默认是使用 PKCS7 填充的(当然也可以指定使用 null(‘0’) 填充模式,但极力不推荐的)。

mcrypt_encrypt/mcrypt_decrypt

相关的支持函数

    // 支持的算法 rijndael-128|rijndael-192|rijndael-256(此算法并非AES-256,需使用rijndael-128 + key32byte实现)
mcrypt_list_algorithms()
// 支持的模式 cbc ecb 等
mcrypt_list_modes()
// 算法所对应的 key 长度:AES-128, 192 and 256 的加密 key 的长度分别为 16, 24 and 32 位
mcrypt_get_key_size(string $cipher , string $mode)
// 算法所对应的加密向量 iv 的长度
mcrypt_get_iv_size(string $cipher , string $mode)
// 生成 iv
mcrypt_create_iv(mcrypt_get_iv_size(string $cipher , string $mode))
// 加密算法数据块的大小 主要用于填充算法
mcrypt_get_block_size(string $cipher , string $mode)

 

PKCS7 填充算法的实现

/**
 * 填充算法
 * @param string $source
 * @return string
 */
function addPKCS7Padding($source, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    $source     = trim($source);
    // 获取加密算法数据块大小 用于计算需要填充多少位
    $block_size = mcrypt_get_block_size($cipher, $mode);
    $pad        = $block_size - (strlen($source) % $block_size);
    if ($pad <= $block_size) {
        $char = chr($pad);
        $source .= str_repeat($char, $pad);
    }
    return $source;
}

/**
 * 移去填充算法
 * @param string $source
 * @return string
 */
function stripPKCS7Padding($source)
{
    $source = trim($source);
    $char   = substr($source, -1);
    $num    = ord($char);
    if ($num == 62) {
        return $source;
    }

    $source = substr($source, 0, -$num);
    return $source;
}

 

openssl_encrypt/openssl_decrypt

简单讲解一下日常开发中用到的参数

 

    /**
     * $data 待加密内容
     * $method 加密算法
     * $key 加密key
     * $options 数据块填充模式
     * $iv 加密向量
     **/
openssl_encrypt(string $data, string $method, string $key[, int $options = 0[, string $iv = ""
[, string &$tag = NULL[, string $aad = ""[, int $tag_length = 16 ]]]]]): string

openssl_decrypt(string $data, string $method, string $key[, int $options = 0[, string $iv = ""
[, string $tag = "" [, string $aad = "" ]]]] ) : string

这里需要特别注意的就是 options 选项,很多人 mcrypt_簇 迁移至 openssl_簇 时二者加密结果内容不一致,大都是此处没有搞清楚的原因。options 共 3 个值可选

0 默认值 使用 PKCS7 填充算法,不对加密结果进行 base64encode
1 OPENSSL_RAW_DATA 使用 PKCS7 填充算法,且对加密结果进行 base64encode
2 OPENSSL_ZERO_PADDING 使用 null('0') 进行填充,且对加密结果进行 base64encode

所以要注意填充算法及对结果是否进行了 base64encode 编码。

mcrypt_簇 迁移至 openssl_簇

mcrypt_簇

/**
 * 加密算法
 * @param  string $content    待加密数据
 * @param  string $key    加密key
 * @param  string $iv     加密向量
 * @param  string $cipher 加密算法
 * @param  string $mode   加密模式
 * @return string         加密后的内容且base64encode
 */
function encrypt($content, $key, $iv, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    //AES, 128 模式加密数据 CBC
    $content           = addPKCS7Padding($content);
    $content_encrypted = mcrypt_encrypt($cipher, $key, $content, $mode, $iv);
    return base64_encode($content_encrypted);
}

/**
 * 解密算法
 * @param  [type] $content [description]
 * @param  [type] $key     [description]
 * @param  [type] $iv      [description]
 * @param  [type] $cipher  [description]
 * @param  [type] $mode    [description]
 * @return [type]          [description]
 */
function decrypt($content_encrypted, $key, $iv, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    //AES, 128 模式加密数据 CBC
    $content_encrypted = base64_decode($content_encrypted);
    $content           = mcrypt_decrypt($cipher, $key, $content_encrypted, $mode, $iv);
    $content           = stripPKSC7Padding($content);
    return $content;
}

/**
 * PKCS7填充算法
 * @param string $source
 * @return string
 */
function addPKCS7Padding($source, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    $source = trim($source);
    $block  = mcrypt_get_block_size($cipher, $mode);
    $pad    = $block - (strlen($source) % $block);
    if ($pad <= $block) {
        $char = chr($pad);
        $source .= str_repeat($char, $pad);
    }
    return $source;
}
/**
 * 移去PKCS7填充算法
 * @param string $source
 * @return string
 */
function stripPKSC7Padding($source)
{
    $source = trim($source);
    $char   = substr($source, -1);
    $num    = ord($char);
    if ($num == 62) {
        return $source;
    }

    $source = substr($source, 0, -$num);
    return $source;
}

openssl_簇

转换实例

以 AES-128 为例

// 固定使用此算法 然后通过 key 的长度来决定具体使用的是何种 AES
$cipher = MCRYPT_RIJNDAEL_128;
$mode   = MCRYPT_MODE_CBC;

// openssl_簇 iv 固定为 16 位,mcrypt_簇 MCRYPT_RIJNDAEL_128 是 16位
// 但改为 MCRYPT_RIJNDAEL_192/256 就是 24/32 位了,会不兼容 openssl_簇
// 所以务必注意向量长度统一固定 16 位方便两套算法对齐
// $iv = mcrypt_create_iv(mcrypt_get_iv_size($cipher, $mode), MCRYPT_RAND);

// 根据需要自行定义相应的 key 长度 aes-128=16 aes-192=24 aes-256=32
$key = '0123456789012345';
// 固定为 16 位
$iv  = '0123456789012345';

$content = "hello world";

// mcrypt 加解密
$mcrypt_data = encrypt($content, $key, $iv, $cipher, $mode);
var_dump($mcrypt_data);
$content = decrypt($mcrypt_data, $key, $iv, $cipher, $mode);
var_dump($content);

// mcrypt 时使用了 PKCS7 填充 并对结果 base64encode
// 如果 +PKCS7 +base64encode 则 option = 0
// 如果 +PKCS7 -base64encode 则 option = 1
// 如果 -PKCS7 +base64encode 则 option = 2
$openssl_data = openssl_encrypt($content, "AES-128-CBC", $key, 0, $iv)
var_dump($openssl_data);
$content = openssl_decrypt($openssl_data, "AES-128-CBC", $key, 0, $iv)
var_dump($content);

// 相互转换
$content = openssl_decrypt($mcrypt_data, "AES-128-CBC", $key, 0, $iv)
var_dump($content);
$content = decrypt($openssl_data, $key, $iv, $cipher, $mode);
var_dump($content);

总结

1、PKCS7 填充算法。
2、openssl_encrypt / openssl_decrypt 三种模式所表示的 PKCS7/base64encode。
3、mcrypt_簇 的 cipher/mode 同 openssl_簇 的转换。

<?php
/**
 * MCRYPT_RIJNDAEL_128 & CBC + 16位Key + 16位iv = openssl_encrypt(AES-128-CBC, 16位Key, 16位iv) = AES-128
 * MCRYPT_RIJNDAEL_128 & CBC + 24位Key + 16位iv = openssl_encrypt(AES-192-CBC, 24位Key, 16位iv) = AES-192
 * MCRYPT_RIJNDAEL_128 & CBC + 32位Key + 16位iv = openssl_encrypt(AES-256-CBC, 32位Key, 16位iv) = AES-256
 * ------------------------------------------------------------------------------------------------------
 * openssl_簇 options
 * 0 : 自动对明文进行 pkcs7 padding, 返回的数据经过 base64 编码.
 * 1 : OPENSSL_RAW_DATA, 自动对明文进行 pkcs7 padding, 但返回的结果未经过 base64 编码
 * 2 : OPENSSL_ZERO_PADDING, 自动对明文进行 null('0') 填充, 同 mcrpty 一致,且返回的结果经过 base64 编码, openssl 不推荐 0 填充的方式, 即使选择此项也不会自动进行 padding, 仍需手动 padding
 * --------------------------------------------------------------------------------------------------------
 * mcrypt 默认是用 0 填充,为保持良好的兼容性建议使用 pkcs7 填充数据 openssl 0|1 都使用的 pkcs7
 * pkcs7 填充
 * 加密工具类
 */

// 随机字符串
function get_random_str($length = 16)
{
    $char_set = array_merge(range('a', 'z'), range('A', 'Z'), range('0', '9'));
    shuffle($char_set);
    return implode('', array_slice($char_set, 0, $length));
}

// 固定使用此算法 然后通过 key 的长度来决定具体使用的是何种 AES
$mcrypt_cipher = MCRYPT_RIJNDAEL_128;
$mcrypt_mode   = MCRYPT_MODE_CBC;
// openssl_簇 AES iv 固定为 16 位,mcrypt_簇只有在 MCRYPT_RIJNDAEL_128 为 16 位 需注意保持一致
$iv = mcrypt_create_iv(mcrypt_get_iv_size($mcrypt_cipher, $mcrypt_mode), MCRYPT_RAND);
// aes-128=16 aes-192=24 aes-256=32
$key_size = 16;
$key      = get_random_str($key_size);
// openssl_ AES 向量长度固定 16 位 这里为
$iv = get_random_str(16);

/**
 * 加密算法
 * @param  string $content    待加密数据
 * @param  string $key    加密key
 * @param  string $iv     加密向量
 * @param  string $cipher 加密算法
 * @param  string $mode   加密模式
 * @return string         加密后的内容且base64encode
 */
function encrypt($content, $key, $iv, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    //AES, 128 模式加密数据 CBC
    $content           = addPKCS7Padding($content);
    $content_encrypted = mcrypt_encrypt($cipher, $key, $content, $mode, $iv);
    return base64_encode($content_encrypted);
}

/**
 * 解密算法
 * @param  [type] $content [description]
 * @param  [type] $key     [description]
 * @param  [type] $iv      [description]
 * @param  [type] $cipher  [description]
 * @param  [type] $mode    [description]
 * @return [type]          [description]
 */
function decrypt($content_encrypted, $key, $iv, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    //AES, 128 模式加密数据 CBC
    $content_encrypted = base64_decode($content_encrypted);
    $content           = mcrypt_decrypt($cipher, $key, $content_encrypted, $mode, $iv);
    $content           = stripPKSC7Padding($content);
    return $content;
}

/**
 * PKCS7填充算法
 * @param string $source
 * @return string
 */
function addPKCS7Padding($source, $cipher = MCRYPT_RIJNDAEL_128, $mode = MCRYPT_MODE_CBC)
{
    $source = trim($source);
    $block  = mcrypt_get_block_size($cipher, $mode);
    $pad    = $block - (strlen($source) % $block);
    if ($pad <= $block) {
        $char = chr($pad);
        $source .= str_repeat($char, $pad);
    }
    return $source;
}
/**
 * 移去PKCS7填充算法
 * @param string $source
 * @return string
 */
function stripPKSC7Padding($source)
{
    $source = trim($source);
    $char   = substr($source, -1);
    $num    = ord($char);
    if ($num == 62) {
        return $source;
    }

    $source = substr($source, 0, -$num);
    return $source;
}

$content = "hello world";

var_dump($data = encrypt($content, $key, $iv, $mcrypt_cipher, $mcrypt_mode));
var_dump(decrypt($data, $key, $iv, $mcrypt_cipher, $mcrypt_mode));
var_dump($openssl_data = openssl_encrypt($content, "AES-128-CBC", $key, 0, $iv));
var_dump(openssl_decrypt($openssl_data, "AES-128-CBC", $key, 0, $iv));

// var_dump(openssl_cipher_iv_length('AES-256-CBC'));
// var_dump(mcrypt_get_key_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC));

搞定,收工

 

 

 

 

PHP 7系列版本(7.0、7.1、7.2、7.3、7.4)新特性

PHP很久不用了,很多新特性都搞不清了,稍微整理一下。

  1. 标量参数类型声明[7.0]
  2. 返回值类型声明[7.0]
  3. Nullable类型[7.1]
  4. 属性值类型声明[7.4]
  5. Void 函数[7.1]
  6. 箭头函数[7.4]
  7. 类常量可见性[7.1]
  8. iterable 伪类[7.1]
  9. 新的object类型[7.2]
  10. 允许重写抽象方法[7.2]
  11. 类在实现接口方法时参数类型扩展[7.2]
  12. null合并运算符[7.0]
  13. 空值连写赋值运算符[7.4]
  14. 组合比较符[7.0]
  15. 通过 define() 定义常量数组[7.0]
  16. 支持匿名类[7.0]
  17. Unicode codepoint 转译语法[7.0]
  18. Closure::call()[7.0]
  19. 断言[7.0]
  20. use 分组写法[7.0]
  21. 允许分组命名空间的尾部逗号[7.2]
  22. 生成器可以返回表达式[7.0]
  23. 生成器委托[7.0]
  24. 可以使用 list() 函数来展开实现了 ArrayAccess 接口的对象[7.0]
  25. list()现在支持键名[7.1]
  26. 对称性数组解构[7.1]
  27. 数组的解构支持引用赋值[7.3]
  28. 多异常捕获处理[7.1]
  29. 支持为负的字符串偏移量[7.1]
  30. 通过名称加载扩展 dl()[7.2]
  31. 更灵活的Heredoc 与 Nowdoc 语法[7.3]
  32. Instanceof 运算符支持字面量[7.3]
  33. 允许函数和方法被调用时参数最后的空逗号收尾[7.3]
  34. 多字节字符串的相关函数[7.3]
  35. 数组内展开[7.4]
  36. 数值型字面量分隔符[7.4]
  37. 弱引用[7.4]
  38. __toString() 方法允许抛出异常[7.4]
新特性:
7.0
1、标量参数类型声明
标量类型声明 有两种模式: 强制 (默认) 和 严格模式。
现在可以使用下列类型参数(无论用强制模式还是严格模式):
字符串(string),
整数 (int),
浮点数 (float),
以及布尔值 (bool)。
它们扩充了PHP5中引入的其他类型:类名,接口,数组和 回调类型。
<?php
// Coercive mode
function sumOfInts(int …$ints)
{
    return array_sum($ints);
}
var_dump(sumOfInts(2, ‘3’, 4.1));
2、返回值类型声明
返回类型声明指明了函数返回值的类型。可用的类型与参数声明中可用的类型相同。
<?php
function arraysSum(array …$arrays): array
{
    return array_map(function(array $array): int {
        return array_sum($array);
    }, $arrays);
}
print_r(arraysSum([1,2,3], [4,5,6], [7,8,9]));
3、null合并运算符
如果变量存在且值不为NULL, 它就会返回自身的值,否则返回它的第二个操作数。
<?php
// Fetches the value of $_GET[‘user’] and returns ‘nobody’
// if it does not exist.
$username = $_GET[‘user’] ?? ‘nobody’;
// This is equivalent to:
$username = isset($_GET[‘user’]) ? $_GET[‘user’] : ‘nobody’;
// Coalesces can be chained: this will return the first
// defined value out of $_GET[‘user’], $_POST[‘user’], and
// ‘nobody’.
$username = $_GET[‘user’] ?? $_POST[‘user’] ?? ‘nobody’;
?>
4、太空船操作符(组合比较符)
用于比较两个表达式。当$a小于、等于或大于$b时它分别返回-1、0或1
<?php
// 整数
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// 浮点数
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// 字符串
echo “a” <=> “a”; // 0
echo “a” <=> “b”; // -1
echo “b” <=> “a”; // 1
5、通过 define() 定义常量数组
在 PHP5.6 中仅能通过 const 定义。
<?php
define(‘ANIMALS’, [
    ‘dog’,
    ‘cat’,
    ‘bird’
]);
echo ANIMALS[1]; // 输出 “cat”
6、匿名类
<?php
interface Logger {
    public function log(string $msg);
}
class Application {
    private $logger;
    public function getLogger(): Logger {
         return $this->logger;
    }
    public function setLogger(Logger $logger) {
         $this->logger = $logger;
    }
}
$app = new Application;
$app->setLogger(new class implements Logger {
    public function log(string $msg) {
        echo $msg;
    }
});
var_dump($app->getLogger());
7、Unicode codepoint 转译语法
接受一个以16进制形式的 Unicode codepoint,并打印出一个双引号或heredoc包围的 UTF-8 编码格式的字符串
echo “\u{aa}”;
echo “\u{0000aa}”;
echo “\u{9999}”;
8、Closure::call()
简短干练的暂时绑定一个方法到对象上闭包并调用它。
<?php
class A {private $x = 1;}
// PHP 7 之前版本的代码
$getXCB = function() {return $this->x;};
$getX = $getXCB->bindTo(new A, ‘A’); // 中间层闭包
echo $getX();
// PHP 7+ 及更高版本的代码
$getX = function() {return $this->x;};
echo $getX->call(new A);
9、为unserialize()提供过滤
通过白名单的方式来防止潜在的代码注入。
<?php
// 将所有的对象都转换为 __PHP_Incomplete_Class 对象
$data = unserialize($foo, [“allowed_classes” => false]);
// 将除 MyClass 和 MyClass2 之外的所有对象都转换为 __PHP_Incomplete_Class 对象
$data = unserialize($foo, [“allowed_classes” => [“MyClass”, “MyClass2”]);
// 默认情况下所有的类都是可接受的,等同于省略第二个参数
$data = unserialize($foo, [“allowed_classes” => true]);
10、断言
assert()现在是一个语言结构,它允许第一个参数是一个表达式,而不仅仅是一个待计算的 string或一个待测试的boolean。
<?php
ini_set(‘assert.exception’, 1);
class CustomError extends AssertionError {}
assert(false, new CustomError(‘Some error message’));
11、Group use declarations
从同一 namespace 导入的类、函数和常量现在可以通过单个 use 语句 一次性导入了。
// PHP 7+ 及更高版本的代码
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};
12、生成器可以返回表达式
允许在生成器函数中通过使用 return 语法来返回一个表达式 (但是不允许返回引用值), 可以通过调用 Generator::getReturn() 方法来获取生成器的返回值, 但是这个方法只能在生成器完成产生工作以后调用一次。
<?php
$gen = (function() {
    yield 1;
    yield 2;
    return 3;
})();
foreach ($gen as $val) {
    echo $val, PHP_EOL;
}
echo $gen->getReturn(), PHP_EOL;
13、生成器委托
只需在最外层生成器中使用 yield from, 就可以把一个生成器自动委派给其他的生成器, Traversable 对象或者 array。
<?php
function gen()
{
    yield 1;
    yield 2;
    yield from gen2();
}
function gen2()
{
    yield 3;
    yield 4;
}
foreach (gen() as $val)
{
    echo $val, PHP_EOL;
}
14、整数除法函数 intdiv()
进行 整数的除法运算。
<?php
var_dump(intdiv(10, 3));
15、可以使用 list() 函数来展开实现了 ArrayAccess 接口的对象
7.1
1、Nullable类型
参数以及返回值的类型通过在类型前加上一个问号使之允许为空
<?php
function testReturn(): ?string
{
    return ‘elePHPant’;
}
var_dump(testReturn());
function testReturn(): ?string
{
    return null;
}
var_dump(testReturn());
function test(?string $name)
{
    var_dump($name);
}
test(‘elePHPant’);
test(null);
test();
2、Void 函数
方法要么干脆省去 return 语句,要么使用一个空的 return 语句。
对于 void 函数来说,NULL 不是一个合法的返回值。
<?php
function swap(&$left, &$right) : void
{
    if ($left === $right) {
        return;
    }
    $tmp = $left;
    $left = $right;
    $right = $tmp;
}
$a = 1;
$b = 2;
var_dump(swap($a, $b), $a, $b);
3、对称性数组解构
短数组语法([])现在作为list()语法的一个备选项,可以用于将数组的值赋给一些变量(包括在foreach中)
<?php
$data = [
    [1, ‘Tom’],
    [2, ‘Fred’],
];
// list() style
list($id1, $name1) = $data[0];
// [] style
[$id1, $name1] = $data[0];
// list() style
foreach ($data as list($id, $name)) {
    // logic here with $id and $name
}
// [] style
foreach ($data as [$id, $name]) {
    // logic here with $id and $name
}
4、类常量可见性
<?php
class ConstDemo
{
    const PUBLIC_CONST_A = 1;
    public const PUBLIC_CONST_B = 2;
    protected const PROTECTED_CONST = 3;
    private const PRIVATE_CONST = 4;
}
5、iterable 伪类
<?php
function iterator(iterable $iter)
{
    foreach ($iter as $val) {
        //
    }
}
6、多异常捕获处理
<?php
try {
    // some code
} catch (FirstException | SecondException $e) {
    // handle first and second exceptions
}
7、list()现在支持键名
这意味着它可以将任意类型的数组 都赋值给一些变量
<?php
$data = [
    [“id” => 1, “name” => ‘Tom’],
    [“id” => 2, “name” => ‘Fred’],
];
// list() style
list(“id” => $id1, “name” => $name1) = $data[0];
// [] style
[“id” => $id1, “name” => $name1] = $data[0];
// list() style
foreach ($data as list(“id” => $id, “name” => $name)) {
    // logic here with $id and $name
}
// [] style
foreach ($data as [“id” => $id, “name” => $name]) {
    // logic here with $id and $name
}
8、支持为负的字符串偏移量
一个负数的偏移量会被理解为一个从字符串结尾开始的偏移量。
<?php
var_dump(“abcdef”[-2]);
var_dump(strpos(“aabbcc”, “b”, -3));
7.2
1、新的object类型
这种新的类型 object, 引进了可用于逆变(contravariant)参数输入和协变(covariant)返回任何对象类型。
<?php
function test(object $obj) : object
{
    return new SplQueue();
}
test(new StdClass());
2、通过名称加载扩展
使用 dl() 函数进行启用
3、允许重写抽象方法(Abstract method)
<?php
abstract class A
{
    abstract function test(string $s);
}
abstract class B extends A
{
    // overridden – still maintaining contravariance for parameters and covariance for return
    abstract function test($s) : int;
}
4、扩展了参数类型
重写方法和接口实现的参数类型现在可以省略了。不过这仍然是符合LSP,因为现在这种参数类型是逆变的。
<?php
interface A
{
    public function Test(array $input);
}
class B implements A
{
    public function Test($input){} // type omitted for $input
}
5、允许分组命名空间的尾部逗号
<?php
use Foo\Bar\{
    Foo,
    Bar,
    Baz,
};
6、更灵活的Heredoc 与 Nowdoc 语法
7、数组的解构支持引用赋值
 [&$a, [$b, &$c]] = $d
8、Instanceof 运算符支持字面量
判断结果总是 FALSE
9、允许函数和方法被调用时参数最后的空逗号收尾
10、多字节字符串的相关函数
mb_convert_case():
mb_strtolower())
mb_strtoupper())
<?php
mb_ereg(‘(?<word>\w+)’, ‘国’, $matches);
// => [0 => “国”, 1 => “国”, “word” => “国”];
<?php
mb_ereg_replace(‘\s*(?<word>\w+)\s*’, “_\k<word>_\k’word’_”, ‘ foo ‘);
// => “_foo_foo_”
7.4
1、属性值类型声明
<?php
class User {
    public int $id;
    public string $name;
}
2、箭头函数
<?php
$factor = 10;
$nums = array_map(fn($n) => $n * $factor, [1, 2, 3, 4]);
// $nums = array(10, 20, 30, 40);
3、空值连写赋值运算符
<?php
$array[‘key’] ??= computeDefault();
// is roughly equivalent to
if (!isset($array[‘key’])) {
    $array[‘key’] = computeDefault();
}
4、数组内展开
<?php
$parts = [‘apple’, ‘pear’];
$fruits = [‘banana’, ‘orange’, …$parts, ‘watermelon’];
// [‘banana’, ‘orange’, ‘apple’, ‘pear’, ‘watermelon’];
5、数值型字面量分隔符
<?php
6.674_083e-11; // float
299_792_458;   // decimal
0xCAFE_F00D;   // hexadecimal
0b0101_1111;   // binary
6、弱引用
引用对象使其不被销毁
7、__toString()方法允许跑出异常

支付宝支付-提现到个人支付宝

支持沙盒环境的测试

此项目已开源欢迎Start、PR、发起Issues一起讨论交流共同进步
https://github.com/Javen205/IJPay
http://git.oschina.net/javen205/IJPay

提现到个人支付宝官方的名称是单笔转账到支付宝账户

1、创建应用并获取APPID

如果没有在开发平台创建应用就得创建一个《开放平台应用创建指南》
如果之前有创建过应用那么就可以直接添加功能

添加单笔转账到支付宝账户

如果只是测试不上线可以跳过上面的步骤,直接使用沙盒环境测试

2、配置密钥

可以参考《配置应用环境》

生成RSA密钥

配置密钥

3、下载服务端SDK

下载开放平台服务端SDK

4、使用服务端SDK

4.1 初始化SDK

 

AlipayClient alipayClient = new DefaultAlipayClient(URL, APP_ID, APP_PRIVATE_KEY, FORMAT, CHARSET, ALIPAY_PUBLIC_KEY, SIGN_TYPE);

参数说明可以参考关键参数说明

4.2 接口调用

调用流程

说明:

1、如果商户重复请求转账,支付宝会幂等返回成功结果,商户必须对重复转账的业务做好幂等处理;如果不判断,存在潜在的风险,商户自行承担因此而产生的所有损失。

2、如果调用alipay.fund.trans.toaccount.transfer掉单时,或返回结果code=20000时,或返回结果code=40004,sub_code= SYSTEM_ERROR时,请调用alipay.fund.trans.order.query发起查询,如果未查询到结果,请保持原请求不变再次请求alipay.fund.trans.toaccount.transfer接口。

3、商户处理转账结果时,对于错误码的处理,只能使用sub_code作为后续处理的判断依据,不可使用sub_msg作为后续处理的判断依据。

4.3 SDK的调用

主要涉及到两个接口

4.4 单笔转账到支付宝账户接口alipay.fund.trans.toaccount.transfer 封装

直接调用转账接口如果返回不是Success 就调用转账查询接口

 

/**
     * 单笔转账到支付宝账户
     * https://doc.open.alipay.com/docs/doc.htm?spm=a219a.7629140.0.0.54Ty29&treeId=193&articleId=106236&docType=1
     * @param content
     * @return
     * @throws AlipayApiException
     */
    public static boolean transfer(AlipayFundTransToaccountTransferModel model) throws AlipayApiException{
        AlipayFundTransToaccountTransferResponse response = transferToResponse(model);
        String result = response.getBody();
        log.info("transfer result>"+result);
        System.out.println("transfer result>"+result);
        if (response.isSuccess()) {
            return true;
        } else {
            //调用查询接口查询数据
            JSONObject jsonObject = JSONObject.parseObject(result);
            String out_biz_no = jsonObject.getJSONObject("alipay_fund_trans_toaccount_transfer_response").getString("out_biz_no");
            AlipayFundTransOrderQueryModel queryModel = new AlipayFundTransOrderQueryModel();
            model.setOutBizNo(out_biz_no);
            boolean isSuccess = transferQuery(queryModel);
            if (isSuccess) {
                return true;
            }
        }
        return false;
    }
    
    public static AlipayFundTransToaccountTransferResponse transferToResponse(AlipayFundTransToaccountTransferModel model) throws AlipayApiException{
        AlipayFundTransToaccountTransferRequest request = new AlipayFundTransToaccountTransferRequest();
        request.setBizModel(model);
        return alipayClient.execute(request);
    }
4.5 查询转账订单接口alipay.fund.trans.order.query 封装

 

/**
     * 转账查询接口
     * @param content
     * @return
     * @throws AlipayApiException
     */
    public static boolean transferQuery(AlipayFundTransOrderQueryModel model) throws AlipayApiException{
        AlipayFundTransOrderQueryResponse response = transferQueryToResponse(model);
        log.info("transferQuery result>"+response.getBody());
        System.out.println("transferQuery result>"+response.getBody());
        if(response.isSuccess()){
            return true;
        }
        return false;
    }
    public static AlipayFundTransOrderQueryResponse transferQueryToResponse(AlipayFundTransOrderQueryModel model) throws AlipayApiException{
        AlipayFundTransOrderQueryRequest request = new AlipayFundTransOrderQueryRequest();
        request.setBizModel(model);
        return alipayClient.execute(request);
    }

5、 接口测试

 

/**
     * 单笔转账到支付宝账户
     * https://doc.open.alipay.com/docs/doc.htm?spm=a219a.7629140.0.0.54Ty29&treeId=193&articleId=106236&docType=1
     */
    public void transfer() {
        boolean isSuccess = false;
        String total_amount = "100";
        AlipayFundTransToaccountTransferModel model = new AlipayFundTransToaccountTransferModel();
        model.setOutBizNo(StringUtils.getOutTradeNo());//生成订单号
        model.setPayeeType("ALIPAY_LOGONID");//固定值
        model.setPayeeAccount("abpkvd0206@sandbox.com");//转账收款账户
        model.setAmount(total_amount);
        model.setPayerShowName("测试退款");
        model.setPayerRealName("沙箱环境");//账户真实名称
        model.setRemark("javen测试单笔转账到支付宝");
        
        try {
            isSuccess = AliPayApi.transfer(model);
        } catch (Exception e) {
            e.printStackTrace();
        }
        renderJson(isSuccess);
    }

故意把账户真实名称写错

 

{
  "alipay_fund_trans_toaccount_transfer_response": {
    "code": "40004",
    "msg": "Business Failed",
    "sub_code": "PAYER_USER_INFO_ERROR",
    "sub_msg": "付款用户姓名或其它信息不一致",
    "out_biz_no": "051023044814944"
  },
  "sign": "Zbm9lI9GbTlLbYsPQoJhd5y7+oevOInPFoKlRWp2064VUPZYUGBJRiM/8Ip8Vfz4MDhu+0Uc3gEzvoXk1O6eVj7bAPjGLc5cZI3gQNmbogTxeK/4eGgIjxJBKK46r6rzKgK2/e7YEBmExi6hACbo3inBqX0OnaIxIbedZnYY2qrkNdhIjiD1G/EWJNH846IEwhwLkihV7vVKXhIgfmfKmGu5jE7aNddwxKhAK8fAzTR7JOs8p/ZOcLD9/RHfUP1ro4HoNlUOrFUZfhxRuUEFwLxvcJon0HkcO6dnjNnXQx3jh/Ne3632SpWca1pZczervU3/z9/C0LVflQWna42t9g=="
}

正确返回结果


{
  "alipay_fund_trans_toaccount_transfer_response": {
    "code": "10000",
    "msg": "Success",
    "order_id": "20170510110070001500460000004431",
    "out_biz_no": "051023003214944",
    "pay_date": "2017-05-10 23:00:30"
  },
  "sign": "hedaOEcrS8CwzcLNFAQhLWJnmevaA4a+SsNuzuuyBHABUjJ+ZvagMoS1/eUpRIHfwXVOLxGVjCCtJzi4Irclqu2Roz9aHo8ROkNKFKbw66lcT2dOo9AWCYw8UVhQDUjjSZ/d+lu9nnpHPf3ZPPdFHvziBo6ghZF0DRiIX/9ZVx7uH7grFJb8SRbCbcF5C7eouJU8Aw9sMdu/XjREdlW7pLvjeinzouOLbIpICRP33JtGC/KhgdQltDzlXHtVgi9xWRJVXJVp7+jtDRbRP+V+ImY9NqYKtpfxtTBZZ1bW6nOxJaMV7ePgC/6GpDIyWjg+LdHQ09eeBtTy4XCOxtGe1g=="
}

 

PHP异步执行的几种常用方式

本文为大家讲述了php异步调用方法,分享给大家供大家参考,具体内容如下 客户端与服务器端是通过HTTP协议进行连接通讯,客户端发起请求,服务器端接收到请求后执行处理,并返回处理结果。 有时服务器需要执行很耗时的操作,这个操作的结果并不需要返回给客户端。但因为php是同步执行的,所以客户端需要等待服务处理完才可以进行下一步。 因此对于耗时的操作适合异步执行,服务器接收到请求后,处理完客户端需要的数据就返回,再异步在服务器执行耗时的操作。 1.使用Ajax 与 img 标记 原理,服务器返回的html中插入Ajax 代码或 img 标记,img的src为需要执行的程序。 优点:实现简单,服务端无需执行任何调用 缺点:在执行期间,浏览器会一直处于loading状态,因此这种方法并不算真正的异步调用。
$.get("doRequest.php", { name: "fdipzone"} );<img src="doRequest.php?name=fdipzone">
2.使用popen 使用popen执行命令,语法:
// popen — 打开进程文件指针  resource popen ( string $command , string $mode )pclose(popen('php /home/fdipzone/doRequest.php &', 'r'));
优点:执行速度快 缺点:
  • 1).只能在本机执行
  • 2).不能传递大量参数
  • 3).访问量高时会创建很多进程
3.使用curl 设置curl的超时时间 CURLOPT_TIMEOUT 为1 (最小为1),因此客户端需要等待1秒
<?php 
  $ch = curl_init(); 
  $curl_opt = array( CURLOPT_URL,'http://www.example.com/doRequest.php'CURLOPT_RETURNTRANSFER,1, CURLOPT_TIMEOUT,1 ); 
  curl_setopt_array($ch, $curl_opt); 
  curl_exec($ch); curl_close($ch); 
?>
4.使用fsockopen fsockopen是最好的,缺点是需要自己拼接header部分。
<?php  
$url = 'http://www.example.com/doRequest.php'; 
$param = array( 'name'=>'fdipzone', 'gender'=>'male', 'age'=>30 );  doRequest($url, $param);  
function doRequest($url, $param=array()){  
  $urlinfo = parse_url($url);  
  $host = $urlinfo['host']; 
  $path = $urlinfo['path']; 
  $query = isset($param)? http_build_query($param) : '';  
  $port = 80; 
  $errno = 0; 
  $errstr = ''; 
  $timeout = 10;  
  $fp = fsockopen($host, $port, $errno, $errstr, $timeout);  
  $out = "POST ".$path." HTTP/1.1\r\n"; $out .= "host:".$host."\r\n"; 
  $out .= "content-length:".strlen($query)."\r\n"; 
  $out .= "content-type:application/x-www-form-urlencoded\r\n"; 
  $out .= "connection:close\r\n\r\n"; 
  $out .= $query;  
  fputs($fp, $out); 
  fclose($fp); 
}  
?>
注意:当执行过程中,客户端连接断开或连接超时,都会有可能造成执行不完整,因此需要加上
ignore_user_abort(true); // 忽略客户端断开 set_time_limit(0);    // 设置执行不超时

PHP5.5新增的利器:生成器

如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生。但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,也可以是生成器作用不是很明显。但是,生成器功能的确非常有用。

优点

直接讲概念估计你听完还是一头雾水,所以我们先来说说优点,也许能勾起你的兴趣。那么生成器有哪些优点,如下:

  • 生成器会对PHP应用的性能有非常大的影响
  • PHP代码运行时节省大量的内存
  • 比较适合计算大量的数据

那么,这些神奇的功能究竟是如何做到的?我们先来举个例子。

概念引入

首先,放下生成器概念的包袱,来看一个简单的PHP函数:

function createRange($number){
    $data = [];
    for($i=0;$i<$number;$i++){
        $data[] = time();
    }
    return $data;
}

这是一个非常常见的PHP函数,我们在处理一些数组的时候经常会使用。这里的代码也非常简单:

  1. 我们创建一个函数。
  2. 函数内包含一个for循环,我们循环的把当前时间放到$data里面
  3. for循环执行完毕,把$data返回出去。

下面没完,我们继续。我们再写一个函数,把这个函数的返回值循环打印出来:

$result = createRange(10); // 这里调用上面我们创建的函数
foreach($result as $value){
    sleep(1);//这里停顿1秒,我们后续有用
    echo $value.'<br />';
}

我们在浏览器里面看一下运行结果:

图片描述

这里非常完美,没有任何问题。(当然sleep(1)效果你们看不出来)

思考一个问题

我们注意到,在调用函数createRange的时候给$number的传值是10,一个很小的数字。假设,现在传递一个值10000000(1000万)。

那么,在函数createRange里面,for循环就需要执行1000万次。且有1000万个值被放到$data里面,而$data数组在是被放在内存内。所以,在调用函数时候会占用大量内存。

这里,生成器就可以大显身手了。

创建生成器

我们直接修改代码,你们注意观察:

function createRange($number){
    for($i=0;$i<$number;$i++){
        yield time();
    }
}

看下这段和刚刚很像的代码,我们删除了数组$data,而且也没有返回任何内容,而是在time()之前使用了一个关键字yield

使用生成器

我们再运行一下第二段代码:

$result = createRange(10); // 这里调用上面我们创建的函数
foreach($result as $value){
    sleep(1);
    echo $value.'<br />';
}
图片描述

我们奇迹般的发现了,输出的值和第一次没有使用生成器的不一样。这里的值(时间戳)中间间隔了1秒。

这里的间隔一秒其实就是sleep(1)造成的后果。但是为什么第一次没有间隔?那是因为:

  • 未使用生成器时:createRange函数内的for循环结果被很快放到$data中,并且立即返回。所以,foreach循环的是一个固定的数组。
  • 使用生成器时:createRange的值不是一次性快速生成,而是依赖于foreach循环。foreach循环一次,for执行一次。

到这里,你应该对生成器有点儿头绪。

深入理解生成器

代码剖析

下面我们来对于刚刚的代码进行剖析。

function createRange($number){
    for($i=0;$i<$number;$i++){
        yield time();
    }
}

$result = createRange(10); // 这里调用上面我们创建的函数
foreach($result as $value){
    sleep(1);
    echo $value.'<br />';
}

我们来还原一下代码执行过程。

  1. 首先调用createRange函数,传入参数10,但是for值执行了一次然后停止了,并且告诉foreach第一次循环可以用的值。
  2. foreach开始对$result循环,进来首先sleep(1),然后开始使用for给的一个值执行输出。
  3. foreach准备第二次循环,开始第二次循环之前,它向for循环又请求了一次。
  4. for循环于是又执行了一次,将生成的时间戳告诉foreach.
  5. foreach拿到第二个值,并且输出。由于foreachsleep(1),所以,for循环延迟了1秒生成当前时间

所以,整个代码执行中,始终只有一个记录值参与循环,内存中也只有一条信息。

无论开始传入的$number有多大,由于并不会立即生成所有结果集,所以内存始终是一条循环的值。

概念理解

到这里,你应该已经大概理解什么是生成器了。下面我们来说下生成器原理。

首先明确一个概念:生成器yield关键字不是返回值,他的专业术语叫产出值,只是生成一个值

那么代码中foreach循环的是什么?其实是PHP在使用生成器的时候,会返回一个Generator类的对象。foreach可以对该对象进行迭代,每一次迭代,PHP会通过Generator实例计算出下一次需要迭代的值。这样foreach就知道下一次需要迭代的值了。

而且,在运行中for循环执行后,会立即停止。等待foreach下次循环时候再次和for索要下次的值的时候,for循环才会再执行一次,然后立即再次停止。直到不满足条件不执行结束。

实际开发应用

很多PHP开发者不了解生成器,其实主要是不了解应用领域。那么,生成器在实际开发中有哪些应用?

读取超大文件

PHP开发很多时候都要读取大文件,比如csv文件、text文件,或者一些日志文件。这些文件如果很大,比如5个G。这时,直接一次性把所有的内容读取到内存中计算不太现实。

这里生成器就可以派上用场啦。简单看个例子:读取text文件

图片描述

我们创建一个text文本文档,并在其中输入几行文字,示范读取。

<?php
header("content-type:text/html;charset=utf-8");
function readTxt()
{
    # code...
    $handle = fopen("./test.txt", 'rb');

    while (feof($handle)===false) {
        # code...
        yield fgets($handle);
    }

    fclose($handle);
}

foreach (readTxt() as $key => $value) {
    # code...
    echo $value.'<br />';
}
图片描述

通过上图的输出结果我们可以看出代码完全正常。

但是,背后的代码执行规则却一点儿也不一样。使用生成器读取文件,第一次读取了第一行,第二次读取了第二行,以此类推,每次被加载到内存中的文字只有一行,大大的减小了内存的使用。

这样,即使读取上G的文本也不用担心,完全可以像读取很小文件一样编写代码。

PHP 程序员进阶学习书籍参考指南

 

今天给PHP程序员们推荐几本PHP进阶好书,PHP程序员们不要以为自己现在已经工作就放弃了一个上进的心,现在互联网发展这么快,小心长江后浪推前浪,前浪死在沙滩上哦。。。

 

【初阶】(基础知识及入门)

01. 《PHP 与 MySQL 程序设计(第 4 版)》

http://item.jd.com/10701892.html

02. 《深入浅出 MySQL 数据库开发 优化与管理维护 第 2 版》

http://item.jd.com/11381295.html

03. 《实战 Nginx:取代 Apache 的高性能 Web 服务器》

http://dwz.cn/2K1ryn

04. 《Redis 实战》

http://item.jd.com/11791607.html

05. 《MongoDB 权威指南 第 2 版》

http://item.jd.com/11384782.html

06. 《Linux 系统命令及 Shell 脚本实践指南》

http://item.jd.com/11354663.html

【中阶】(基本系统知识相关,可阅读类似书籍)

01. 《图解 HTTP》

http://item.jd.com/11449491.html

02. 《图解 TCP/IP 第 5 版》

http://item.jd.com/11253710.html

03. 《大话设计模式》

http://item.jd.com/10079261.html

04. 《大话数据结构》

http://item.jd.com/10663703.html

05. 《编译原理(第 2 版)》

http://item.jd.com/10058776.html

06. 《Linux C 编程一站式学习》

http://dwz.cn/2K1C3n

07. 《PHP 应用程序安全编程》

http://dwz.cn/2K317p

08. 《高性能 PHP 应用开发》

http://dwz.cn/2K1kcy

09. 《PHP 核心技术与最佳实践》

http://item.jd.com/11123177.html

10. 《高性能 MySQL(第 3 版)》

http://item.jd.com/11220393.html

11. 《深入理解 MariaDB 与 MySQL》

http://item.jd.com/11835700.html

12. 《构建高可用 Linux 服务器(第 3 版)》

http://item.jd.com/11557939.html

【中高阶】(深入理解系统)

01.《深入理解计算机系统(原书第 2 版)》

http://item.jd.com/10360906.html

02.《现代操作系统(原书第 3 版)》

http://item.jd.com/10058893.html

03.《数据库系统概念(原书第 6 版)》

http://item.jd.com/10954261.html

04.《数据库系统实现(第 2 版)》

http://item.jd.com/10060181.html

05.《UNIX 环境高级编程(第 3 版)》

http://item.jd.com/11469694.html

06.《UNIX 网络编程 卷 1 套接字联网 API(第 3 版)》

http://item.jd.com/11728741.html

07. 《Linux 高性能服务器编程》

http://item.jd.com/11252777.html

【高阶】(深入理解服务原理)

01. 《深入理解 PHP 内核》

http://www.php-internals.com/book/

02. 《深入理解 MySQL》

http://item.jd.com/10063042.html

03. 《MySQL 技术内幕:InnoDB 存储引擎(第 2 版)》

http://item.jd.com/11252326.html

04. 《深入剖析 Nginx》

http://item.jd.com/11226514.html

05. 《深入理解 Nginx:模块开发与架构解析》

http://item.jd.com/11217076.html

06. 《Redis 设计与实现》

http://item.jd.com/11486101.html

【架构及升级】(Web 架构、分布式、云计算、机器学习等方向)

01. 《大规模 Web 服务开发技术》

http://dwz.cn/2K2o1d

02. 《大型分布式网站架构设计与实践》

http://item.jd.com/11529266.html

03. 《大型网站技术架构 核心原理与案例分析》

http://item.jd.com/11322972.html

04. 《大规模分布式系统架构与设计实战》

http://item.jd.com/11417660.html

05. 《大规模分布式存储系统:原理解析与架构实战》

http://item.jd.com/11310547.html

06. 《分布式系统:概念与设计(原书第 5 版)》

http://item.jd.com/11194499.html

07. 《Hadoop 权威指南(第 3 版 修订版)》

http://item.jd.com/11566298.html

08. 《Cassandra 权威指南》

http://item.jd.com/10794341.html

09. 《云计算架构技术与实践》

http://item.jd.com/11537731.html

10. 《OpenStack 开源云王者归来》

http://item.jd.com/11521443.html

11. 《数据挖掘 概念与技术(原书第 3 版)》

http://item.jd.com/11056660.html

12. 《机器学习》

http://item.jd.com/10131321.html

13. 《图解机器学习》

http://item.jd.com/11676112.html

14. 《机器学习实战》

http://item.jd.com/11242112.html

【番外篇】(可以参考延展学习)

01. 《深入 PHP:面向对象、模式与实践(第 3 版)》

http://item.jd.com/10794350.html

02. 《Linux 网络编程(第 2 版)》

http://item.jd.com/11397772.html

03. 《Linux 多线程服务端编程 使用 muduo C++ 网络库》

http://item.jd.com/11163782.html

04. 《Linux 运维之道》

http://item.jd.com/11375254.html

05. 《Linux 性能优化大师》

http://item.jd.com/11734651.html

06. 《PostgreSQL 修炼之道:从小工到专家》

http://item.jd.com/11684063.html

07. 《图解网络硬件》

http://item.jd.com/11506709.html

08. 《网络安全基础:网络攻防、协议与安全》

http://item.jd.com/10550797.html

09. 《密码学原理与实践(第 3 版)》

http://item.jd.com/10067358.html

10. 《黑客大曝光:网络安全机密与解决方案(第 7 版)》

http://item.jd.com/11307435.html

11. 《黑客攻防技术宝典 Web 实战篇 第 2 版》

http://item.jd.com/11020022.html

12. 《精通正则表达式(第 3 版)》

http://item.jd.com/11070361.html

13. 《Go 语言编程》

http://item.jd.com/11067810.html

14. 《Python 基础教程(第 2 版 修订版)》

http://item.jd.com/11461683.html

15. 《快学 Scala》

http://item.jd.com/11113845.html

16. 《Erlang/OTP 并发编程实战》

http://item.jd.com/11037265.html

17. 《函数式编程思维》

http://item.jd.com/11763847.html

18. 《Android 从入门到精通》

http://item.jd.com/11078112.html

19. 《iOS 开发指南》

http://item.jd.com/11681585.html

20. 《搜索引擎:信息检索实践》

http://item.jd.com/10059723.html

21. 《统计自然语言处理(第 2 版)》

http://item.jd.com/11314362.html

22. 《这就是搜索引擎:核心技术详解》

http://item.jd.com/10893803.html

23. 《Elasticsearch 服务器开发(第 2 版)》

http://item.jd.com/11615450.html

24. 《实战 Elasticsearch、Logstash、Kibana》

http://item.jd.com/11706768.html

25. 《推荐系统实践》

http://item.jd.com/11007625.html

26. 《机器学习实践指南:案例应用解析》

http://item.jd.com/11447036.html

27. 《Hadoop 实战(第 2 版)》

http://item.jd.com/11116710.html

28. 《Hadoop 大数据分析与挖掘实战》

http://item.jd.com/11837003.html

29. 《Spark 大数据处理:技术、应用与性能优化》

http://item.jd.com/11577088.html

30. 《Spark 机器学习》

http://item.jd.com/11763016.html

laravel服务容器—–深入理解控制反转(IoC)和依赖注入(DI)

容器,字面上理解就是装东西的东西。常见的变量、对象属性等都可以算是容器。一个容器能够装什么,全部取决于你对该容器的定义。当然,有这样一种容器,它存放的不是文本、数值,而是对象、对象的描述(类、接口)或者是提供对象的回调,通过这种容器,我们得以实现许多高级的功能,其中最常提到的,就是 “解耦” 、“依赖注入(DI)”。本文就从这里开始。

IoC 容器, laravel 的核心

Laravel 的核心就是一个 IoC 容器,根据文档,称其为“服务容器”,顾名思义,该容器提供了整个框架中需要的一系列服务。作为初学者,很多人会在这一个概念上犯难,因此,我打算从一些基础的内容开始讲解,通过理解面向对象开发中依赖的产生和解决方法,来逐渐揭开“依赖注入”的面纱,逐渐理解这一神奇的设计理念。

本文一大半内容都是通过举例来让读者去理解什么是 IoC(控制反转) 和 DI(依赖注入),通过理解这些概念,来更加深入。更多关于 laravel 服务容器的用法建议阅读文档即可。

IoC 容器诞生的故事

讲解 IoC 容器有很多的文章,我之前也写过。但现在我打算利用当下的灵感重新来过,那么开始吧。

超人和超能力,依赖的产生!

面向对象编程,有以下几样东西无时不刻的接触:接口还有对象。这其中,接口是类的原型,一个类必须要遵守其实现的接口;对象则是一个类实例化后的产物,我们称其为一个实例。当然这样说肯定不利于理解,我们就实际的写点中看不中用的代码辅助学习。

怪物横行的世界,总归需要点超级人物来摆平。

我们把一个“超人”作为一个类,

class Superman {}

我们可以想象,一个超人诞生的时候肯定拥有至少一个超能力,这个超能力也可以抽象为一个对象,为这个对象定义一个描述他的类吧。一个超能力肯定有多种属性、(操作)方法,这个尽情的想象,但是目前我们先大致定义一个只有属性的“超能力”,至于能干啥,我们以后再丰富:

class Power {
    /**
     * 能力值
     */
    protected $ability;

    /**
     * 能力范围或距离
     */
    protected $range;

    public function __construct($ability, $range)
    {
        $this->ability = $ability;
        $this->range = $range;
    }
}

这时候我们回过头,修改一下之前的“超人”类,让一个“超人”创建的时候被赋予一个超能力:

class Superman
{
    protected $power;

    public function __construct()
    {
        $this->power = new Power(999, 100);
    }
}

这样的话,当我们创建一个“超人”实例的时候,同时也创建了一个“超能力”的实例,但是,我们看到了一点,“超人”和“超能力”之间不可避免的产生了一个依赖。

所谓“依赖”,就是 “我若依赖你,我就不能离开你”。

在一个贯彻面向对象编程的项目中,这样的依赖随处可见。少量的依赖并不会有太过直观的影响,我们随着这个例子逐渐铺开,让大家慢慢意识到,当依赖达到一个量级时,是怎样一番噩梦般的体验。当然,我也会自然而然的讲述如何解决问题。

一堆乱麻 —— 可怕的依赖

之前的例子中,超能力类实例化后是一个具体的超能力,但是我们知道,超人的超能力是多元化的,每种超能力的方法、属性都有不小的差异,没法通过一种类描述完全。我们现在进行修改,我们假设超人可以有以下多种超能力:

  • 飞行,属性有:飞行速度、持续飞行时间
  • 蛮力,属性有:力量值
  • 能量弹,属性有:伤害值、射击距离、同时射击个数

我们创建了如下类:

class Flight
{
    protected $speed;
    protected $holdtime;
    public function __construct($speed, $holdtime) {}
}

class Force
{
    protected $force;
    public function __construct($force) {}
}

class Shot
{
    protected $atk;
    protected $range;
    protected $limit;
    public function __construct($atk, $range, $limit) {}
}

*为了省事儿我没有详细写出 __construct() 这个构造函数的全部,只写了需要传递的参数。

好了,这下我们的超人有点“忙”了。在超人初始化的时候,我们会根据需要来实例化其拥有的超能力吗,大致如下:

class Superman
{
    protected $power;

    public function __construct()
    {
        $this->power = new Fight(9, 100);
        // $this->power = new Force(45);
        // $this->power = new Shot(99, 50, 2);
        /*
        $this->power = array(
            new Force(45),
            new Shot(99, 50, 2)
        );
        */
    }
}

我们需要自己手动的在构造函数内(或者其他方法里)实例化一系列需要的类,这样并不好。可以想象,假如需求变更(不同的怪物横行地球),需要更多的有针对性的 新的 超能力,或者需要 变更 超能力的方法,我们必须 重新改造 超人。换句话说就是,改变超能力的同时,我还得重新制造个超人。效率太低了!新超人还没创造完成世界早已被毁灭。

这时,灵机一动的人想到:为什么不可以这样呢?超人的能力可以被随时更换,只需要添加或者更新一个芯片或者其他装置啥的(想到钢铁侠没)。这样的话就不要整个重新来过了。

对,就是这样的。

我们不应该手动在 “超人” 类中固化了他的 “超能力” 初始化的行为,而转由外部负责,由外部创造超能力模组、装置或者芯片等(我们后面统一称为 “模组”),植入超人体内的某一个接口,这个接口是一个既定的,只要这个 “模组” 满足这个接口的装置都可以被超人所利用,可以提升、增加超人的某一种能力。这种由外部负责其依赖需求的行为,我们可以称其为 “控制反转(IoC)”。

工厂模式,依赖转移!

当然,实现控制反转的方法有几种。在这之前,不如我们先了解一些好玩的东西。

我们可以想到,组件、工具(或者超人的模组),是一种可被生产的玩意儿,生产的地方当然是 “工厂(Factory)”,于是有人就提出了这样一种模式: 工厂模式

工厂模式,顾名思义,就是一个类所依赖的外部事物的实例,都可以被一个或多个 “工厂” 创建的这样一种开发模式,就是 “工厂模式”。

我们为了给超人制造超能力模组,我们创建了一个工厂,它可以制造各种各样的模组,且仅需要通过一个方法:

class SuperModuleFactory
{
    public function makeModule($moduleName, $options)
    {
        switch ($moduleName) {
            case 'Fight':   return new Fight($options[0], $options[1]);
            case 'Force':   return new Force($options[0]);
            case 'Shot':    return new Shot($options[0], $options[1], $options[2]);
        }
    }
}

这时候,超人 创建之初就可以使用这个工厂!

class Superman
{
    protected $power;

    public function __construct()
    {
        // 初始化工厂
        $factory = new SuperModuleFactory;

        // 通过工厂提供的方法制造需要的模块
        $this->power = $factory->makeModule('Fight', [9, 100]);
        // $this->power = $factory->makeModule('Force', [45]);
        // $this->power = $factory->makeModule('Shot', [99, 50, 2]);
        /*
        $this->power = array(
            $factory->makeModule('Force', [45]),
            $factory->makeModule('Shot', [99, 50, 2])
        );
        */
    }
}

可以看得出,我们不再需要在超人初始化之初,去初始化许多第三方类,只需初始化一个工厂类,即可满足需求。但这样似乎和以前区别不大,只是没有那么多 new 关键字。其实我们稍微改造一下这个类,你就明白,工厂类的真正意义和价值了。

class Superman
{
    protected $power;

    public function __construct(array $modules)
    {
        // 初始化工厂
        $factory = new SuperModuleFactory;

        // 通过工厂提供的方法制造需要的模块
        foreach ($modules as $moduleName => $moduleOptions) {
            $this->power[] = $factory->makeModule($moduleName, $moduleOptions);
        }
    }
}

// 创建超人
$superman = new Superman([
    'Fight' => [9, 100], 
    'Shot' => [99, 50, 2]
    ]);

现在修改的结果令人满意。现在,“超人” 的创建不再依赖任何一个 “超能力” 的类,我们如若修改了或者增加了新的超能力,只需要针对修改 SuperModuleFactory 即可。扩充超能力的同时不再需要重新编辑超人的类文件,使得我们变得很轻松。但是,这才刚刚开始。

再进一步!IoC 容器的重要组成 —— 依赖注入!

由 “超人” 对 “超能力” 的依赖变成 “超人” 对 “超能力模组工厂” 的依赖后,对付小怪兽们变得更加得心应手。但这也正如你所看到的,依赖并未解除,只是由原来对多个外部的依赖变成了对一个 “工厂” 的依赖。假如工厂出了点麻烦,问题变得就很棘手。

其实大多数情况下,工厂模式已经足够了。工厂模式的缺点就是:接口未知(即没有一个很好的契约模型,关于这个我马上会有解释)、产生对象类型单一。总之就是,还是不够灵活。虽然如此,工厂模式依旧十分优秀,并且适用于绝大多数情况。不过我们为了讲解后面的 依赖注入 ,这里就先夸大一下工厂模式的缺陷咯。

我们知道,超人依赖的模组,我们要求有统一的接口,这样才能和超人身上的注入接口对接,最终起到提升超能力的效果。

事实上,我之前说谎了,不仅仅只有一堆小怪兽,还有更多的大怪兽。嘿嘿。额,这时候似乎工厂的生产能力显得有些不足 —— 由于工厂模式下,所有的模组都已经在工厂类中安排好了,如果有新的、高级的模组加入,我们必须修改工厂类(好比增加新的生产线):

class SuperModuleFactory
{
    public function makeModule($moduleName, $options)
    {
        switch ($moduleName) {
            case 'Fight':   return new Fight($options[0], $options[1]);
            case 'Force':   return new Force($options[0]);
            case 'Shot':    return new Shot($options[0], $options[1], $options[2]);
            // case 'more': .......
            // case 'and more': .......
            // case 'and more': .......
            // case 'oh no! its too many!': .......
        }
    }
}

看到没。。。噩梦般的感受!

其实灵感就差一步!你可能会想到更为灵活的办法!对,下一步就是我们今天的主要配角 —— DI (依赖注入)

由于对超能力模组的需求不断增大,我们需要集合整个世界的高智商人才,一起解决问题,不应该仅仅只有几个工厂垄断负责。不过高智商人才们都非常自负,认为自己的想法是对的,创造出的超能力模组没有统一的接口,自然而然无法被正常使用。这时我们需要提出一种契约,这样无论是谁创造出的模组,都符合这样的接口,自然就可被正常使用。

interface SuperModuleInterface
{
    /**
     * 超能力激活方法
     *
     * 任何一个超能力都得有该方法,并拥有一个参数
     *@param array $target 针对目标,可以是一个或多个,自己或他人
     */
    public function activate(array $target);
}

上文中,我们定下了一个接口 (超能力模组的规范、契约),所有被创造的模组必须遵守该规范,才能被生产。

其实,这就是 php 中 接口( interface ) 的用处和意义!很多人觉得,为什么 php 需要接口这种东西?难道不是 java 、 C# 之类的语言才有的吗?这么说,只要是一个正常的面向对象编程语言(虽然 php 可以面向过程),都应该具备这一特性。因为一个 对象(object) 本身是由他的模板或者原型 —— 类 (class) ,经过实例化后产生的一个具体事物,而有时候,实现统一种方法且不同功能(或特性)的时候,会存在很多的类(class),这时候就需要有一个契约,让大家编写出可以被随时替换却不会产生影响的接口。这种由编程语言本身提出的硬性规范,会增加更多优秀的特性。

虽然有些绕,但通过我们接下来的实例,大家会慢慢领会接口带来的好处。

这时候,那些提出更好的超能力模组的高智商人才,遵循这个接口,创建了下述(模组)类:

/**
 * X-超能量
 */
class XPower implements SuperModuleInterface
{
    public function activate(array $target)
    {
        // 这只是个例子。。具体自行脑补
    }
}

/**
 * 终极炸弹 (就这么俗)
 */
class UltraBomb implements SuperModuleInterface
{
    public function activate(array $target)
    {
        // 这只是个例子。。具体自行脑补
    }
}

同时,为了防止有些 “砖家” 自作聪明,或者一些叛徒恶意捣蛋,不遵守契约胡乱制造模组,影响超人,我们对超人初始化的方法进行改造:

class Superman
{
    protected $module;

    public function __construct(SuperModuleInterface $module)
    {
        $this->module = $module
    }
}

改造完毕!现在,当我们初始化 “超人” 类的时候,提供的模组实例必须是一个 SuperModuleInterface 接口的实现。否则就会提示错误。

正是由于超人的创造变得容易,一个超人也就不需要太多的超能力,我们可以创造多个超人,并分别注入需要的超能力模组即可。这样的话,虽然一个超人只有一个超能力,但超人更容易变多,我们也不怕怪兽啦!

现在有人疑惑了,你要讲的 依赖注入 呢?

其实,上面讲的内容,正是依赖注入。

什么叫做 依赖注入

本文从开头到现在提到的一系列依赖,只要不是由内部生产(比如初始化、构造函数 __construct 中通过工厂方法、自行手动 new 的),而是由外部以参数或其他形式注入的,都属于 依赖注入(DI) 。是不是豁然开朗?事实上,就是这么简单。下面就是一个典型的依赖注入:

// 超能力模组
$superModule = new XPower;

// 初始化一个超人,并注入一个超能力模组依赖
$superMan = new Superman($superModule);

关于依赖注入这个本文的主要配角,也就这么多需要讲的。理解了依赖注入,我们就可以继续深入问题。慢慢走近今天的主角……

更为先进的工厂 —— IoC 容器!

刚刚列了一段代码:

$superModule = new XPower;

$superMan = new Superman($superModule);

读者应该看出来了,手动的创建了一个超能力模组、手动的创建超人并注入了刚刚创建超能力模组。呵呵,手动。

现代社会,应该是高效率的生产,干净的车间,完美的自动化装配。

一群怪兽来了,如此低效率产出超人是不现实,我们需要自动化 —— 最多一条指令,千军万马来相见。我们需要一种高级的生产车间,我们只需要向生产车间提交一个脚本,工厂便能够通过指令自动化生产。这种更为高级的工厂,就是工厂模式的升华 —— IoC 容器

class Container
{
    protected $binds;

    protected $instances;

    public function bind($abstract, $concrete)
    {
        if ($concrete instanceof Closure) {
            $this->binds[$abstract] = $concrete;
        } else {
            $this->instances[$abstract] = $concrete;
        }
    }

    public function make($abstract, $parameters = [])
    {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }

        array_unshift($parameters, $this);

        return call_user_func_array($this->binds[$abstract], $parameters);
    }
}

这时候,一个十分粗糙的容器就诞生了。现在的确很简陋,但不妨碍我们进一步提升他。先着眼现在,看看这个容器如何使用吧!

// 创建一个容器(后面称作超级工厂)
$container = new Container;

// 向该 超级工厂 添加 超人 的生产脚本
$container->bind('superman', function($container, $moduleName) {
    return new Superman($container->make($moduleName));
});

// 向该 超级工厂 添加 超能力模组 的生产脚本
$container->bind('xpower', function($container) {
    return new XPower;
});

// 同上
$container->bind('ultrabomb', function($container) {
    return new UltraBomb;
});

// ******************  华丽丽的分割线  **********************
// 开始启动生产
$superman_1 = $container->make('superman', ['xpower']);
$superman_2 = $container->make('superman', ['ultrabomb']);
$superman_3 = $container->make('superman', ['xpower']);
// ...随意添加

看到没?通过最初的 绑定(bind) 操作,我们向 超级工厂 注册了一些生产脚本,这些生产脚本在生产指令下达之时便会执行。发现没有?我们彻底的解除了 超人 与 超能力模组 的依赖关系,更重要的是,容器类也丝毫没有和他们产生任何依赖!我们通过注册、绑定的方式向容器中添加一段可以被执行的回调(可以是匿名函数、非匿名函数、类的方法)作为生产一个类的实例的 脚本 ,只有在真正的 生产(make) 操作被调用执行时,才会触发。

这样一种方式,使得我们更容易在创建一个实例的同时解决其依赖关系,并且更加灵活。当有新的需求,只需另外绑定一个“生产脚本”即可。

实际上,真正的 IoC 容器更为高级。我们现在的例子中,还是需要手动提供超人所需要的模组参数,但真正的 IoC 容器会根据类的依赖需求,自动在注册、绑定的一堆实例中搜寻符合的依赖需求,并自动注入到构造函数参数中去。Laravel 框架的服务容器正是这么做的。实现这种功能其实理论上并不麻烦,但我并不会在本文中写出,因为……我懒得写。

不过我告诉大家,这种自动搜寻依赖需求的功能,是通过 反射(Reflection) 实现的,恰好的,php 完美的支持反射机制!关于反射,php 官方文档有详细的资料,并且中文翻译基本覆盖,足够学习和研究!

http://php.net/manual/zh/book.reflection.php

现在,到目前为止,我们已经不再惧怕怪兽们了。高智商人才集思广益,井井有条,根据接口契约创造规范的超能力模组。超人开始批量产出。最终,人人都是超人,你也可以是哦 stuck_out_tongue_closed_eyes

回归正常世界。我们开始重新审视 laravel 的核心。

现在,我们开始慢慢解读 laravel 的核心。其实,laravel 的核心就是一个 IoC 容器,也恰好是我之前所说的高级的 IoC 容器。

可以说,laravel 的核心本身十分轻量,并没有什么很神奇很实质性的应用功能。很多人用到的各种功能模块比如 Route(路由)Eloquent ORM(数据库 ORM 组件)Request and Response(请求和响应)等等等等,实际上都是与核心无关的类模块提供的,这些类从注册到实例化,最终被你所使用,其实都是 laravel 的服务容器负责的。

我们以大家最常见的 Route 类作为例子。大家可能经常见到路由定义是这样的:

Route::get('/', function() {
    // bla bla bla...
});

实际上, Route 类被定义在这个命名空间:Illuminate\Routing\Router,文件 vendor/laravel/framework/src/Illuminate/Routing/Router.php

我们通过打开发现,这个类的这一系列方法,如 getpostany 等都不是静态(static)方法,这是怎么一回事儿?不要急,我们继续。

服务提供者

我们在前文介绍 IoC 容器的部分中,提到了,一个类需要绑定、注册至容器中,才能被“制造”。

对,一个类要被容器所能够提取,必须要先注册至这个容器。既然 laravel 称这个容器叫做服务容器,那么我们需要某个服务,就得先注册、绑定这个服务到容器,那么提供服务并绑定服务至容器的东西,就是 服务提供者(ServiceProvider)

虽然,绑定一个类到容器不一定非要通过 服务提供者(ServiceProvider) 。

但是,我们知道,有时候我们的类、模块会有需要其他类和组件的情况,为了保证初始化阶段不会出现所需要的模块和组件没有注册的情况,laravel 将注册和初始化行为进行拆分,注册的时候就只能注册,初始化的时候就是初始化。拆分后的产物就是现在的 服务提供者

服务提供者主要分为两个部分,register(注册) 和 boot(引导、初始化),具体参考文档。register 负责进行向容器注册“脚本”,但要注意注册部分不要有对未知事物的依赖,如果有,就要移步至 boot 部分。

Facade

我们现在解答之前关于 Route 的方法为何能以静态方法访问的问题。实际上这个问题文档上有写,简单说来就是模拟一个类,提供一个静态魔术方法__callStatic,并将该静态方法映射到真正的方法上。

我们使用的 Route 类实际上是 Illuminate\Support\Facades\Route 通过 class_alias() 函数创造的 别名 而已,这个类被定义在文件 vendor/laravel/framework/src/Illuminate/Support/Facades/Route.php 。

我们打开文件一看……诶?怎么只有这么简单的一段代码呢?

<?php namespace Illuminate\Support\Facades;

/**
 * @see \Illuminate\Routing\Router
 */
class Route extends Facade {

    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'router';
    }

}

其实仔细看,会发现这个类继承了一个叫做 Facade 的类,到这里谜底差不多要解开了。

上述简单的定义中,我们看到了 getFacadeAccessor 方法返回了一个 route,这是什么意思呢?事实上,这个值被一个 ServiceProvider 注册过,大家应该知道注册了个什么,当然是那个真正的路由类!

有人会问,Facade 是怎么实现的。我并不想说得太细,一个是我懒,另一个原因就是,自己发现一些东西更容易理解,并不容易忘记。很多细节我已经说了,建议大家自行去研究。

至此,我们已经讲的差不多了。

和平!我们该总结总结了!

无论如何,世界和平了。

这里要总结的内容就是,其实很多事情并不复杂,怕的是复杂的理论内容。我觉得很多东西一旦想通也就那么回事儿。很多人觉得 laravel 这不好那不好、这里难哪里难,我只能说,laravel 的确不是一流和优秀的框架,说 laravel 是一流、优秀的框架的人,不是 laravel 的粉丝那么就是跟风炒作。Laravel 最大的特点和优秀之处就是使用了很多 php 比较新(实际上并不新)的概念和技术(也就一堆语法糖)而已。因此 laravel 的确符合一个适宜学习的框架。Laravel 的构思的确和其他框架有很大不同,这也要求学习他的人必须熟练 php,并 基础扎实!如果你觉得学 laravel 框架十分困难,那么原因只有一个:你 php 基础不好。

另外,善于利用命名空间和面向对象的诸多特性,去追寻一些东西,你会发现,原来这一切这么容易。

php中实现将姓名拆分为姓氏和名字

之前有分享了用javascript在客户端进行姓名拆分的方法,后应项目需要,又用PHP实现了,贴出来 跟大家分享交流:

<?php

/**
 * 拆分姓名(姓氏和名字)
 * @param string $fullname 全名(如:百里屠苏)
 * @return array 一维数组[0=>'姓氏',1=>'名称']
 * @author: 爱是西瓜<blog.mbku.net>
 * @return array
 */
function splitName($fullname){
    $hyphenated = array(
        '百里','北堂','北野','北宫','辟闾',
        '淳于','成公','陈生','褚师','城池',
        '端木','东方','东郭','东野','东门','第五','大狐','段干','段阳','第二','东宫',
        '公孙','公冶','公羊','公良','公西','公孟','公伯','公析','公肩','公坚','公乘','公皙','公户','公广','公仪','公祖','公玉','公仲','公上','公门','公山','高堂','高阳','郭公','谷梁','毌将','毌丘','单于','叱干','叱利','车非',
        '独孤','大野','独吉','达奚','东里',
        '哥舒','贯丘',
        '皇甫','黄龙','胡母','何阳','赫连','呼延','贺兰','贺若','黑齿','斛律','斛粟',
        '夹谷','九方','即墨','吉胡',
        '可频',
        '梁丘','闾丘','洛阳','陵尹','冷富','龙丘','令狐',
        '慕容','万俟','抹捻',
        '纳兰','南荣',
        '南宫','南郭','女娲','南伯','南容','南门','南野',
        '欧阳','欧侯',
        '濮阳','普周','仆固','仆散','蒲察',
        '青阳','漆雕','亓官','渠丘','屈突','屈卢','钳耳',
        '壤驷','汝嫣',
        '上官','少室','少叔','司徒','司马','司空','司寇','士孙','申屠','申徒','申鲜','申叔','夙沙','叔先','叔仲','叔孙','侍其','是云','索卢','厍狄',
        '澹台','太史','太叔','太公','屠岸','唐古','拓跋','同蹄','秃发',
        '闻人','巫马','微生','王孙','无庸','完颜',
        '夏侯','西门','信平','鲜于','轩辕','相里','新垣','徐离姓',
        '羊舌','羊角','延陵','於陵','伊祁','吾丘','乐正','宇文','尉迟','耶律',
        '诸葛','颛孙','仲孙','仲长','钟离','宗政','主父','中叔','左人','左丘','宰父','长儿','仉督','长孙','子车','子书','子桑'
    );
    $vLength = mb_strlen($fullname, 'utf-8');
    $lastname = '';
    $firstname = '';//前为姓,后为名
    if($vLength > 2){
        $preTwoWords = mb_substr($fullname, 0, 2, 'utf-8');//取命名的前两个字,看是否在复姓库中
        if(in_array($preTwoWords, $hyphenated)){
            $lastname = $preTwoWords;
            $firstname = mb_substr($fullname, 2, 10, 'utf-8');
        }else{
            $lastname = mb_substr($fullname, 0, 1, 'utf-8');
            $firstname = mb_substr($fullname, 1, 10, 'utf-8');
        }
    }else if($vLength == 2){//全名只有两个字时,以前一个为姓,后一下为名
        $lastname = mb_substr($fullname ,0, 1, 'utf-8');
        $firstname = mb_substr($fullname, 1, 10, 'utf-8');
    }else{
        $lastname = $fullname;
    }
    return array($lastname, $firstname);
}

//输出调试
var_dump(splitName('李强'));
var_dump(splitName('百里屠苏'));
var_dump(splitName('完颜洪烈'));

注:字典数组数据来源于百度百科,只收录了有“根源”的复姓,少数名族英译的没有收录,双姓(父亲与母亲的姓组合新的姓)没有收录,来源不明确的姓也没收录。

拆分原理懂PHP应该都能理解,如果遇到了特殊的姓要处理加入字典即可。

 

PHP设计模式-链式操作

在传统的代码中,许多情况下要调用一个类中的很多方法使用。比如Db类

传统方法

$db->name('user');
$db->where('where');
$db->limit('1,10');
$db->order('id desc');
$db->find('1');

链式方法

$db->name('user')->where('where')->limit('1,10')->order('id desc')->find('1');

链式操作的核心原理就是需要链的方法return $this;只要把对象返回回去自然可以调用其他方法了,如此循环下去

public function name($name){
    var_dump($name);
    return $this;
}

public function where($where){

    var_dump($where);
    return $this;
}

public function order($order){
    var_dump($order);
    return $this;
}

public function limit($limit){
    var_dump($limit);
    return $this;
}