您的位置：首页 > 编程语言 > PHP开发

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

2014-09-24 16:33 741 查看

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

作者：SNSGOU发布于：2014-02-1309: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:\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
*@returnstringname
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
*@paramstring$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
*@paramstring$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
*@paramstring$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
)
27
*/
可以看到通过使用反射接口ReflectionMethod的方法，file又回来了。

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

总结

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

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

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

摘自：/article/5447926.html

读后感：

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

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

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

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

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航