zoukankan      html  css  js  c++  java

  • 利用PHP的debug_backtrace函数，实现PHP文件权限管理、动态加载

    利用PHP的debug_backtrace函数，实现PHP文件权限管理、动态加载    

    作者：SNSGOU 发布于：2014-02-13 09:42:53  分类：PHP   标签: PHP调试 debug_backtrace  评论(0)  浏览(545) 

    简述

    可能大家都知道，php中有一个函数叫debug_backtrace，它可以回溯跟踪函数的调用信息，可以说是一个调试利器。

    好，来复习一下。

    01 one();
    02  
    03 function one() {
    04     two();
    05 }
    06  
    07 function two() {
    08     three();
    09 }
    10  
    11 function three() {
    12     print_r( debug_backtrace() );
    13 }
    14  
    15 /*
    16 输出：
    17 Array
    18 (
    19     [0] => Array
    20         (
    21             [file] => D:apmservwwwhtdocs estdebugindex.php
    22             [line] => 10
    23             [function] => three
    24             [args] => Array
    25                 (
    26                 )
    27  
    28         )
    29  
    30     [1] => Array
    31         (
    32             [file] => D:apmservwwwhtdocs estdebugindex.php
    33             [line] => 6
    34             [function] => two
    35             [args] => Array
    36                 (
    37                 )
    38  
    39         )
    40  
    41     [2] => Array
    42         (
    43             [file] => D:apmservwwwhtdocs estdebugindex.php
    44             [line] => 3
    45             [function] => one
    46             [args] => Array
    47                 (
    48                 )
    49  
    50         )
    51  
    52 )
    53 */

    顺便提一下类似的函数：debug_print_backtrace，与之不同的是它会直接打印回溯信息。

    回来看debug_backtrace，从名字来看用途很明确，是让开发者用来调试的。直到有一天我注意到它返回的file参数，file表示函数或者方法的调用脚本来源（在哪个脚本文件使用的）。忽然我想到，如果当前脚本知道调用来源，那是否可以根据这个来源的不同，来实现一些有趣的功能，比如文件权限管理、动态加载等。

    实战

    实现魔术函数 

    获取当前函数或方法的名称 

    尽管PHP中已经有了__FUNCTION__和__METHOD__魔术常量，但我还是想介绍一下用debug_backtrace获取当前函数或者方法名称的方法。

    代码如下：

    01 //函数外部输出getFuncName的值
    02 echo getFuncName();
    03  
    04 printFuncName();
    05  
    06 Object::printMethodName();
    07  
    08 //调用了上面两个函数后，再次在外部输出getFuncName，看看是否有‘缓存’之类的问题
    09 echo getFuncName();
    10  
    11  
    12  
    13 function printFuncName() {
    14     echo getFuncName();
    15 }
    16  
    17 class Object {
    18     static function printMethodName() {
    19         echo getFuncName();
    20     }
    21 }
    22  
    23 /**
    24  * 获取当前函数或者方法的名称
    25  * 函数名叫getFuncName，好吧，其实method也可以当做function，实在想不出好名字
    26  *
    27  * @return string name
    28  */
    29 function getFuncName() {
    30     $debug_backtrace = debug_backtrace();
    31     //如果函数名是以下几个，表示载入了脚本，并在函数外部调用了getFuncName
    32     //这种情况应该返回空
    33     $ignore = array(
    34         'include',
    35         'include_once',
    36         'require',
    37         'require_once'
    38     );
    39     //第一个backtrace就是当前函数getFuncName，再上一个（第二个）backtrace就是调用getFuncName的函数了
    40     $handle_func = $debug_backtrace[1];
    41     if( isset( $handle_func['function'] ) && !in_array( $handle_func['function'], $ignore ) ) {
    42         return $handle_func['function'];
    43     }
    44     return null;
    45 }
    46  
    47  
    48 //输出：
    49 //null
    50 //printFuncName
    51 //printMethodName
    52 //null

    看上去没有问题，很好。

    加载相对路径文件

    如果在项目中要加载相对路径的文件，必需使用include或者require之类的原生方法，但现在有了debug_backtrace，我可以使用自定义函数去加载相对路径文件。

    新建一个项目，目录结构如下：

    我想在index.php中调用自定义函数，并使用相对路径去载入package/package.php，并且在package.php中使用同样的方法载入_inc_func.php 

    三个文件的代码如下（留意index.php和package.php调用import函数的代码）：

    index.php：

    01 <?php
    02  
    03 import( './package/package.php' );
    04  
    05 /**
    06  * 加载当前项目下的文件
    07  *
    08  * @param string $path 相对文件路径
    09  */
    10 function import( $path ) {
    11     //获得backstrace列表
    12     $debug_backtrace = debug_backtrace();
    13     //第一个backstrace就是调用import的来源脚本
    14     $source = $debug_backtrace[0];
    15  
    16     //得到调用源的目录路径，和文件路径结合，就可以算出完整路径
    17     $source_dir = dirname( $source['file'] );
    18     require realpath( $source_dir . '/' . $path );
    19 }
    20  
    21 ?>

    package.php：

    1 <?php
    2  
    3 echo 'package';
    4  
    5 import( './_inc_func.php' );
    6  
    7 ?>

    _inc_func.php：

    1 <?php
    2  
    3 echo '_inc_func';
    4  
    5 ?>

    运行index.php：

    1 //输出：
    2 //package
    3 //_inc_func

    可以看到，我成功了。

    思考：这个方法我觉得非常强大，除了相对路径之外，可以根据这个思路引伸出相对包、相对模块之类的抽象特性，对于一些项目来说可以增强模块化的作用。

    管理文件调用权限

    我约定一个规范：文件名前带下划线的只能被当前目录的文件调用，也就是说这种文件属于当前目录‘私有’，其它目录的文件不允许载入它们。

    这样做的目的很明确：为了降低代码耦合性。在项目中，很多时候一些文件只被用在特定的脚本中。但是经常发生的事情是：一些程序员发现这些脚本有自己 需要用到的函数或者类，因此直接载入它来达到自己的目的。这样的做法很不好，原本这些脚本编写的目的仅仅为了辅助某些接口实现，它们并没有考虑到其它通用 性。万一接口内部需要重构，同样需要改动这些特定的脚本文件，但是改动后一些看似与这个接口无关脚本却突然无法运行了。一经检查，却发现文件的引用错综复 杂。

    规范只是监督作用，不排除有人为了一己私欲而违反这个规范，或者无意中违反了。最好的方法是落实到代码中，让程序自动去检测这种情况。

    新建一个项目，目录结构如下。

    那么对于这个项目来说，_inc_func.php属于package目录的私有文件，只有package.php可以载入它，而index.php则没有这个权限。

    package目录是一个包，package.php下提供了这个包的接口，同时_inc_func.php有package.php需要用到的一些函数。index.php将会使用这个包的接口文件，也就是package.php

    它们的代码如下

    index.php：

    01 <?php
    02  
    03 header("Content-type: text/html; charset=utf-8");
    04  
    05 //定义项目根目录
    06 define( 'APP_PATH', dirname( __FILE__ ) );
    07  
    08 import( APP_PATH . '/package/package.php' );
    09 //输出包的信息
    10 Package_printInfo();
    11  
    12 /**
    13  * 加载当前项目下的文件
    14  *
    15  * @param string $path 文件路径
    16  */
    17 function import( $path ) {
    18      
    19     //应该检查路径的合法性
    20     $real_path = realpath( $path );
    21     $in_app = ( stripos( $real_path, APP_PATH ) === 0 );
    22     if( empty( $real_path ) || !$in_app ) {
    23         throw new Exception( '文件路径不存在或不被允许' );
    24     }
    25      
    26     include $real_path;
    27 }
    28  
    29 ?>

    _inc_func.php：

    1 <?php
    2  
    3 function _Package_PrintStr( $string ) {
    4     echo $string;
    5 }
    6  
    7 ?>

    package.php：

    01 <?php
    02  
    03 define( 'PACKAGE_PATH', dirname( __FILE__ ) );
    04  
    05 //引入私有文件
    06 import( PACKAGE_PATH . '/_inc_func.php' );
    07  
    08 function Package_printInfo() {
    09     _Package_PrintStr( '我是一个包。' );
    10 }
    11  
    12 ?>

    运行index.php：

    1 //输出：
    2 //我是一个包。

    整个项目使用了import函数载入文件，并且代码看起来是正常的。但是我可以在index.php中载入package/_inc_func.php文件，并调用它的方法。

    index.php中更改import( APP_PATH . '/package/package.php' );处的代码，并运行：

    1 import( APP_PATH . '/package/_inc_func.php' );
    2  
    3 _Package_PrintStr( '我载入了/package/_inc_func.php脚本' );
    4  
    5 //输出：
    6 //我载入了/package/_inc_func.php脚本

    那么，这时可以使用debug_backtrace检查载入_inc_func.php文件的路径来自哪里，我改动了index.php中的import函数，完整代码如下：

    01 /**
    02  * 加载当前项目下的文件
    03  *
    04  * @param string $path 文件路径
    05  */
    06 function import( $path ) {
    07      
    08     //首先应该检查路径的合法性
    09     $real_path = realpath( $path );
    10     $in_app = ( stripos( $real_path, APP_PATH ) === 0 );
    11     if( empty( $real_path ) || !$in_app ) {
    12         throw new Exception( '文件路径不存在或不被允许' );
    13     }
    14      
    15     $path_info = pathinfo( $real_path );
    16     //判断文件是否属于私有
    17     $is_private = ( substr( $path_info['basename'], 0, 1 ) === '_' );
    18     if( $is_private ) {
    19         //获得backstrace列表
    20         $debug_backtrace = debug_backtrace();
    21         //第一个backstrace就是调用import的来源脚本
    22         $source = $debug_backtrace[0];
    23          
    24         //得到调用源路径，用它来和目标路径进行比较
    25         $source_dir = dirname( $source['file'] );
    26         $target_dir = $path_info['dirname'];
    27         //不在同一目录下时抛出异常
    28         if( $source_dir !== $target_dir ) {
    29             $relative_source_file = str_replace( APP_PATH, '', $source['file'] );
    30             $relative_target_file = str_replace( APP_PATH, '', $real_path );
    31             $error = $relative_target_file . '文件属于私有文件,' . $relative_source_file . '不能载入它。';
    32             throw new Exception( $error );
    33         }
    34     }
    35      
    36     include $real_path;
    37 }

    这时再运行index.php，将产生一个致命错误：

    1 //输出：
    2 //致命错误：/package/_inc_func.php文件属于私有文件,/index.php不能载入它。

    而载入package.php则没有问题，这里不进行演示。

    可以看到，我当初的想法成功了。尽管这样，在载入package.php后，其实在index.php中仍然还可以调用_inc_func.php的函数（package.php载入了它）。因为除了匿名函数，其它函数是全局可见的，包括类。不过这样或多或少可以让程序员警觉起来。关键还是看程序员本身，再好的规范和约束也抵挡不住烂程序员，他们总是会比你‘聪明’。

    debug_backtrace的'BUG'

    如果使用call_user_func或者call_user_func_array调用其它函数，它们调用的函数里面使用debug_backtrace，将获取不到路径的信息。

    例：

    01 call_user_func('import');
    02  
    03 function import() {
    04     print_r( debug_backtrace() );
    05 }
    06  
    07  
    08 /*
    09 输出：
    10 Array
    11 (
    12     [0] => Array
    13         (
    14             [function] => import
    15             [args] => Array
    16                 (
    17                 )
    18  
    19         )
    20  
    21     [1] => Array
    22         (
    23             [file] => F:www est estindex.php
    24             [line] => 3
    25             [function] => call_user_func
    26             [args] => Array
    27                 (
    28                     [0] => import
    29                 )
    30  
    31         )
    32  
    33 )
    34 */

    注意输出的第一个backtrace，它的调用源路径file没有了，这样一来我之前的几个例子将会产生问题。当然可能你注意到第二个backtrace，如果第一个没有就往回找。但经过实践是不可行的，之前我就碰到这种情况，同样会有问题，但是现在无法找回那时的代码了，如果你发现，请将问题告诉我。就目前来说，最好不要使用这种方法，我有一个更好的解决办法，就是使用PHP的反射API。

    使用反射

    使用反射API可以知道函数很详细的信息，当然包括它声明的文件和所处行数

    01 call_user_func('import');
    02  
    03 function import() {
    04     $debug_backtrace = debug_backtrace();
    05     $backtrace = $debug_backtrace[0];
    06     if( !isset( $backtrace['file'] ) ) {
    07         //使用反射API获取函数声明的文件和行数
    08         $reflection_function = new ReflectionFunction( $backtrace['function'] );
    09         $backtrace['file'] = $reflection_function->getFileName();
    10         $backtrace['line'] = $reflection_function->getStartLine();
    11     }
    12     print_r($backtrace);
    13 }
    14  
    15 /*
    16 输出：
    17 Array
    18 (
    19     [function] => import
    20     [args] => Array
    21         (
    22         )
    23  
    24     [file] => F:www est estindex.php
    25     [line] => 5
    26 )
    27 */

    可以看到通过使用反射接口ReflectionMethod的方法，file又回来了。

    类方法的反射接口是ReflectionMethod，获取声明方法同样是getFileName。

    总结

    在一个项目中，我通常不会直接使用include或者require载入脚本。我喜欢把它们封装到一个函数里，需要载入脚本的时候调用这个函数。这样可以在函数里做一些判断，比如说是否引入过这个文件，或者增加一些调用规则等，维护起来比较方便。

    幸好有了这样的习惯，所以我可以马上把debug_backtrace的一些想法应用到整个项目中。

    总体来说debug_backtrace有很好的灵活性，只要稍加利用，可以实现一些有趣的功能。但同时我发现它并不是很好控制，因为每次调用任何一个方法或函数，都有可能改变它的值。如果要使用它来做一些逻辑处理（比如说我本文提到的一些想法），需要一个拥有良好规范准则的系统，至少在加载文件方面吧。

    摘自：http://www.cnblogs.com/melonblog/archive/2013/05/09/3062303.html

    读后感：

    这篇文章是转自一位网友的，它让我对PHP的debug_backtrace()函数有了更深的理解，不过，我还是不太赞成作者对该函数的如此应用：

    1、多次调用debug_backtrace()，会出现性能问题，耗内存；

    2、debug_backtrace()函数在日志调试跟踪的时候比较有用、好用；

    3、接下来再去研究一下该函数在 PHP调试及日志系统 中的应用；
  • 相关阅读:
    RabbitMQ-RPC版主机管理程序
    FTP
    主机管理程序
    高级FTP
    选课系统
    电子银行购物商城
    计算器
    员工信息查询系统
    工资管理系统
    三级菜单
  • 原文地址：https://www.cnblogs.com/shsgl/p/3991026.html
Copyright © 2011-2022 走看看