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

简述

可能大家都知道,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:\apmserv\www\htdocs\test\debug\index.php
22                [line] => 10
23                [function] => three
24                [args] => Array
25                    (
26                    )
27
28            )
29
30        [1] => Array
31            (
32                [file] => D:\apmserv\www\htdocs\test\debug\index.php
33                [line] => 6
34                [function] => two
35                [args] => Array
36                    (
37                    )
38
39            )
40
41        [2] => Array
42            (
43                [file] => D:\apmserv\www\htdocs\test\debug\index.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.phppackage.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.phppackage.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\test\test\index.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\test\test\index.php
25        [line] => 5
26    ) 

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

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

总结

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

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

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

读后感:

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

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

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

3、接下来再去研究一下该函数在 PHP调试及日志系统 中的应用;

时间: 2024-10-18 10:35:58

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

继承,多态,集合,面向对象,XML文件解析,TreeView动态加载综合练习-----&gt;网络电视精灵项目练习、分析

网络电视精灵 项目运行状态如图: 项目完成后的类: 首先,将程序分为二部分进行: 一:TreeView节点内容的设计及编写: 1.1遍写XML文件:管理(FullChannels.xml),A类电视台北京电视台(北京电视台.xml),B类电视台凤凰卫视(凤凰卫视.xml) 1.2创建一个抽象的电视频道父类,ChannelBase,其中有成员:频道名称,频道路径,节目列表(以电视节目类作为类型的集合),解析频道节目单的抽象方法.代码如下: using System; using System.Co

关于apk加壳之动态加载dex文件

由于自己之前做了一个关于手机令牌的APK软件,在实现的过程中尽管使用了native so进行一定的逻辑算法保护,但是在自己逆向破解的过程中发现我的手机令牌关键数据能够“轻易地”暴露出来,所以我就想进一步的对其进行加固.于是,我使用的网上常用的梆梆加固.爱加密和阿里的聚安全应用来对我的apk进行一个加固保护.加固后,出于好奇心,我想对这些加固的原理进行一个了解,便于我自己能够实现这个加固的方法.于是开始了网上关于这方面的学习,我将这些加固的大致原理进行了一个总结,发现它们实现的最主要的方法就是利用

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

利用PHP的debug_backtrace函数,实现PHP文件权限管理.动态加载 简述 可能大家都知道,php中有一个函数叫debug_backtrace,它可以回溯跟踪函数的调用信息,可以说是一个调试利器. 好,来复习一下.view source?01    one();02     03    function one() {04        two();05    }06     07    function two() {08        three();09    }10    

(转)利用PHP的debug_backtrace函数,实现PHP文件权限管理、动态加载 【反射】

原文地址:http://www.cnblogs.com/melonblog/archive/2013/05/09/3062303.html 原文作者:豆浆油条 - melon 本文示例代码测试环境是Windows下的APMServ(PHP5.2.6) 简述 可能大家都知道,php中有一个函数叫debug_backtrace,它可以回溯跟踪函数的调用信息,可以说是一个调试利器. 好,来复习一下. one(); function one() { two(); } function two() { t

Struts2的国际化(二)-利用超链接实现动态加载国际化资源文件

原理:程序是根据Locale来确定国际化资源文件,因此关键之处在于知道 Struts2 框架是如何确定 Local 对象的 ! 由于Struts2 使用 i18n 拦截器处理国际化,并且将其注册在默认的拦截器中,因此,可以通过阅读 I18N 拦截器知道. 具体确定 Locale 对象的过程: > Struts2 使用 i18n 拦截器 处理国际化,并且将其注册在默认的拦截器栈中 > i18n拦截器在执行Action方法前,自动查找请求中一个名为 request_locale 的参数. 如果该参

利用DexClassLoader动态加载dex文件

Java中也有类加载器ClassLoader,其作用是动态装载Class文件,当我们从网络下载Class文件,或者在编译时不参与而在运行时动态调用时就需要用类加载器.由于Android对class文件进行了重新打包和优化,最终APK文件中包含的是dex文件,加载这种文件就需要用到DexClassLoader. DexClassLoader(dexPath, optimizedDirectory, libraryPath, parent) dexPath:目标类所在的APK或者jar包,/.../

两种动态加载JavaScript文件的方法

两种动态加载JavaScript文件的方法 第一种便是利用ajax方式,第二种是,动静创建一个script标签,配置其src属性,经过把script标签拔出到页面head来加载js,感乐趣的网友可以看下 动态加载script到页面大约有俩方法 第一种便是利用ajax方式,把script文件代码从背景加载到前台,而后对加载到的内容经过eval()实施代码.第二种是,动静创建一个script标签,配置其src属性,经过把script标签插入到页面head来加载js,相当于正在head中写了一个<sc

使用jQuery动态加载js脚本文件的方法

动态加载Javascript是一项非常强大且有用的技术.这方面的主题在网上已经讨论了不少,我也经常会在一些个人项目上使用RequireJS和Dojo加载js 它们很强大,但有时候也会得不偿失.如果你使用的是jQuery,它里面有一个内置的方法可以用来加载单个js文件.当你需要延迟加载一些js插件或其它类型的文件时,可以使用这个方法.下面就介绍一下如何使用它! 一.jQuery getScript()方法加载JavaScript jQuery内置了一个方法可以加载单一的js文件:当加载完成后你可以

JavaScript 之 动态加载JS代码或JS文件

2.动态加载JS文件 <script type="text/javascript"> function loadScript(url, callback) { var script = document.createElement("script"); script.type = "text/javascript"; if(typeof(callback) != "undefined"){     if (scri