源码浏览剖析-PHP-laravel
如何浏览源码？浏览源码有什么用？
这个问题对于工作两年左右的程序来说就会开始去接触并且会无意关注和去理解；大都数的认为源码的浏览是为了更好的去应答面试找更高薪的工作；其实除了这样的成果以外还有的就是，能够更好地了解框架及程序的设计原理和设计思路，设计模式等；对于开发来说还能够通过对源码的浏览从中汲取良好的代码编写布局进步本人代码品质，以及对bug的问题剖析和修复能力以及性能扩大的能力等等。
因而就开始尝试对源码的浏览。
01. 遇到的问题；懵，一脸懵；
在对源码的浏览中，老手在没有把握技巧的时候往往是很懵，又很晕感觉绕来绕去（叮当猫都晕了）
老手个别看源码的形式是这样的；如下为一段代码【ioc注册与解析并通过app加载启动利用db获取数据的简化过程】
<code class="php"><?php
class Config
{
public function get($key)
{
return "获取配置信息 ".$key;
}
}
class Db
{
protected $app
function __construct(App $app)
{
$this->app = $app;
}
public function connection()
{
$this->configuration()
}
public function configuration()
{
$connections = $this->app->make("config").get("database.connections")
// ...
}
public function select()
{
$this->connection()
return "查问数据";
}
}
class Ioc
{
protected $bindings = [];
public function make($key)
{
return $this->bindings[$key];
}
public function bind($key, $object)
{
$this->bindings[$key] = $object;
}
}
class App extends Ioc
{
public function __construct()
{
$this->registerCoreIocBinding();
}
public function run()
{
// ..跳过对Controller/闭包的解析过程
$db = $this->make(db).select();
}
protected function registerCoreIocBinding()
{
foreach ([
"config" => Config::class,
"db" => Db::class,
] as $key => $value) {
$this->bind($key, $value);
}
}
}
// 调用
$app = new App();
$app->run()
?>
下面的代码中定义一个ioc的对象提供对容器注册与解析的外围办法，框架中的app或application继承ioc对象，并会对框架中的外围容器对象进行注册（利用bind办法）；
在示例代码中提供了两个容器别离是Config与Db两个对象；在Db中初始化的时候要求传递app，并在connection中获取配置信息时需通过app解析Config对象从中获取到相干的配置信息；
如上的代码相对来说较为简单，并没有特地简单的设计；咱们通过下面的代码来理解一下大家平时如何浏览源码的；
———————————–光彩的分割线—————————————-
很多同志对源码剖析的时候本人不晓得要剖析一些什么，而后就从最开始的index.php中的办法一个个点点点点，点到最初发现绕圈子而后，而后就…从开始到放弃（我说的不是你，如果你也是在评论去给个666）
比方下面的代码中；习惯性的同志就会开始从new App()开始，对new App() -> app.__construct() -> app.registerCoreIocBinding -> ioc.bind() 整个链路的办法全副点击一次再说；
实现之后就开始第二个办法$app->run()，而后又开始对其链接的每个办法都点击一次;从$app->run() 到 app.make()唉这个时候发现又到本人的make办法外面了（这里就会存在小纳闷），当这里走完了好不容易理解了就进入到Db.select()中，持续点击Db.select()->Db.connection()->Db.configuration()->app.make()好家伙而后又回去了…
02. 技巧总结
对于源码的浏览，是有技巧的，技巧次要是；
- 先确定指标
- 源码摸索考究适量而止，切记不可死磕往死里点
- 肯定要看办法名，肯定要看正文；
- 不明来历看继承，看初始化、看非凡办法及相干特色
- 巧用程序提供的打印函数
- 记录过程，及调度链
- 临时跳过不会的，不晓得的，或者尝试猜想
其中是1,2,3点是十分重要基本上对于很多相干的语言的第一浏览都是能够使用到的，一样实用，特地不能运行代码的时候十分有帮忙；
其中4和5须要对程序有肯定的理解才行，当你对一个语言理解如何运行及根本的机制也能够尝试去浏览
细节拆分具体思路
- 先确定指标
这是十分要害要害要害！！！的第一个点，因为很多同志，晓得我要去看源码一通点击下又回归原点，最初本人被本人转晕了；
其关键问题是不分明本人到底是想看那个性能实现过程没有什么指标，因而对于指标的清晰是十分重要的事件；
- 源码摸索考究适量而止，切记不可死磕往死里点
这一步，次要是针对摸索的过程设计，第一次看的同时往往是看到一个办法就点一个办法，而后发现还有办法再点一个办法，就这样始终点击上来；
也忘了本人是谁，是在哪里，为什么我要看源码？（是的话评论扣个666）
对于源码浏览肯定要留神适量而止，源码的浏览须要基于第一个点为主线；主线中往往会随带较多的分支，而分支多了就会蛊惑大家，这里倡议对于每个办法最多点击三级，在第一次对办法剖析的时候；
三级次要是指比方A办法，在A办法中含有（B,C,D)等办法；对于A办法的查阅视为1级，第二级则是对B,C,D的点击浏览，第三级就是对B,C,D办法外部调用的办法去查看；
当大略理解了A办法中B,C,D办法的状况再根据其源码浏览带来的信息去分辨主线，这样就防止死磕往死里点；避免出现爱的魔力转圈圈
- 肯定要看办法名，肯定要看正文；
对于这一条，大部分同志对于开源程序，很少去关注（我已经也是）；
首先咱们须要了解；一个办法的封装（且不谈办法外面是何种牛马蛇神）那么是具备其要害性质的性能及作用的;
而优良的开源程序的程序往往会把办法的性能及相干的阐明以正文和办法名的形式传播给了阅读者；
当然，也不排除有英语不是很会的也问题不大，翻译安顿
联合第二步，当咱们点击了一个办法之后能够先看看办法的正文，并对办法名翻译理解它干了什么；有一些办法咱们理论只须要看办法名就即可，再实再不了解的时候才进一步点击往下看，往下看的时候也需次要适量而止；
- 不明来历看继承，看初始化、看非凡办法及相干特色
在源码中妨碍咱们对于程序了解的就是这些非凡存在；
在办法中不乏还有变量调用有如全局/部分属性，留神也蕴含办法；最麻烦的问题次要是那些“来历不明的办法和属性”
比方在PHP框架中存在facade非凡设定，然而在facade的对象中的确办法空洞无物，那办法从哪来？？？
这就须要看语言的一些初始化，继承，以及非凡办法及相干特色了；在facade中办法次要是通过__call()相干的魔术办法实现，在不同语言的实现形式不一样因而须要时刻警觉非凡存在去查找不明来历的源头
- 巧用程序提供的打印函数
这是我认为对程序代码调试比拟好的技巧；在程序源码浏览中，在第四点提到会存在不明来历的属性和办法；
那么咱们能够借助打印办法能够尝试确定对应属性的起源或者其不明办法的作用是什么；
能够把相干调用的变量利用打印函数打印参数信息以此来察看和探索属性背地的源头，但这个也要分语言不是特地万能；
然而有一点是很有用的，就是咱们能够利用打印理解程序的执行和参数的变动过程
比方：
<code class="php">function A($a){
var_dump($a); // 解决前
// 对a解决
var_dump($a); // 解决后
}
- 记录过程，及调度链
这一点次要是不便本人回顾；
在开源程序及开源框架中整体的调度链个别都很简单，因而对于每个办法的作用和调度过程，倡议能够绘制流程图以及相干的阐明这样就能够不便日后回顾而舒适
对于第6点往往应该是配合一个整体的调度流程，本文例子….这个作者很懒，懒得画了；
- 临时跳过不会的，不晓得的 或者尝试猜想
在浏览源码的时候常常会遇到不会的状况，以及看不懂不是特地能了解为什么是这样或者是做什么的；
这个时候我的倡议是如果你通过后面6个步骤还是不了解，就间接跳过；
程序的学习并不是肯定要把某个点了解好了才往后学习，在咱们理论学习中可能临时不会然而之后就会了；“用着，用着，用着就会了”
另外也能够在看的时候尝试依据办法名或可能看到理解的相干信息作为线索猜想其作用
03. 实际使用
- 实际对象：laravel5.7.*版本
- 浏览原理：申请到控制器执行
好开始~~~
03.01 入口
对于PHP来说框架的入口文件根本都是从public/index.php开始
<code class="php"><?php
define('LARAVEL_START', microtime(true));
require __DIR__.'/../vendor/autoload.php';
// 初始化框架利用对象application
$app = require_once __DIR__.'/../bootstrap/app.php';
// 获取对http申请解决的外围实例
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
// 执行申请解决
$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);
// 响应输入
$response->send();
// 程序完结，并完结相干中间件
$kernel->terminate($request, $response);
?>
在一开始咱们能够通过对public/index.php的浏览能够理解到整个框架程序的流程及过程；
- 初始化框架利用对象application
- 获取对http申请解决的外围实例
- 执行申请解决
- 响应输入
- 程序完结，并完结相干中间件
接下来咱们进入bootstrap/app.php中理解application初始化的过程
03.02 application利用初始化
<code class="php"><?php
// 初始化application
$app = new Illuminate\Foundation\Application(
$_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
);
// 绑定http/debug/console外围处理器
$app->singleton(
Illuminate\Contracts\Http\Kernel::class,
App\Http\Kernel::class
);
$app->singleton(
Illuminate\Contracts\Console\Kernel::class,
App\Console\Kernel::class
);
$app->singleton(
Illuminate\Contracts\Debug\ExceptionHandler::class,
App\Exceptions\Handler::class
);
// 返回
return $app;
?>
这里咱们的指标是为了理解Application在初始化的过程，因而咱们就须要点击看Application的结构过程；
浏览思路剖析：针对下面的代码，基于咱们的指标能够必定的是Application对象的构造函数是咱们须要看的理解的
而后续中调用Application中的singleton置信第一次看的不是很了解，基于7点的准则咱们能够先跳过以Application的初始化过程为主
好进入Application办法
blog\vendor\laravel\framework\src\Illuminate\Foundation\Application.php
<code class="php"><?php
class Application
{
// ..
public function __construct($basePath = null)
{
if ($basePath) {
$this->setBasePath($basePath);
}
$this->registerBaseBindings();
$this->registerBaseServiceProviders();
$this->registerCoreContainerAliases();
}
// ...
}
?>
看到办法的时候依据准则“3. 肯定要看办法名，肯定要看正文；6. 记录过程，及调度链”
而后一下子不就明了吗”是不是”, 你：“对对对”
<code class="php"><?php
// Create a new Illuminate application instance.
// 创立一个新的照明应用程序实例。
public function __construct($basePath = null)
{
// 判断是否有设置利用门路
if ($basePath) {
// 设置利用门路
$this->setBasePath($basePath);
}
// 注册利用绑定
$this->registerBaseBindings();
// 注册利用服务提供者
$this->registerBaseServiceProviders();
// 注册外围容器别名
$this->registerCoreContainerAliases();
}
?>
再后续会间接在代码上使用3,6点；作者他不想每次都引到，心领神会就好
好接下来咱们基于“2. 源码摸索考究适量而止，切记不可死磕往死里点”再进一步理解每个办法的大略作用
先看setBasePath
<code class="php"><?php
public function setBasePath($basePath)
{
// 解决门路不为空
$this->basePath = rtrim($basePath, '\/');
// 绑定门路到容器里
$this->bindPathsInContainer();
return $this;
}
// 绑定容器中的所有应用程序的门路
protected function bindPathsInContainer()
{
$this->instance('path', $this->path());
$this->instance('path.base', $this->basePath());
$this->instance('path.lang', $this->langPath());
//..
}
?>
对于setBasePath浏览咱们在整体的思路上就能够理解到是对利用的外围门路去进行设置,依据2准则适量而止因而咱们进行对bindPathsInContainer函数的浏览
再看registerBaseBindings
<code class="php"><?php
// 注册根本绑定到容器中
protected function registerBaseBindings()
{
static::setInstance($this);
$this->instance('app', $this);
$this->instance(Container::class, $this);
$this->instance(PackageManifest::class, new PackageManifest(
new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
));
}
?>
到此咱们发现instance是一个较为外围的存在，基本上哪儿都有它的身影，那咱们须要对它剖析嘛？？？？？
须要，然而不当初；因为咱们目前的关键在于理解Application初始化过程;
依据7能够大略猜想它的作用是为了注册实例，也就是注册对象；再联合办法名即可了解，该办法就是把外围实例application注册到容器中；
<code class="php">$this->instance(PackageManifest::class, new PackageManifest(
new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
));
这一段干了啥？？？？你晓得嘛？？你：“什么鬼怎么扯我了，我就是看文章的怎么晓得”;
“我当然晓得你不晓得”不晓得咋办，当然是跳过呀。。。依据7的准则
持续看registerBaseServiceProviders
<code class="php"><?php
// 注册所有根底服务提供商
protected function registerBaseServiceProviders()
{
$this->register(new \Illuminate\Events\EventServiceProvider($this));
$this->register(new \Illuminate\Log\LogServiceProvider($this));
$this->register(new \Illuminate\Routing\RoutingServiceProvider($this));
}
?>
进入到这个办法依据意思“注册所有根底服务提供商”，看了这个办法依据event 翻译 事件,log,routing依据这三个关键词的信息提供，这不就晓得这个办法干了啥嘛；
就是注册框架事件、框架日志、框架路由的服务提供者嘛；而后就OK了须要看register嘛，这是之后的事件和目前的主题关系不是很大；
最初看registerCoreContainerAliases
<code class="php"><?php
public function registerCoreContainerAliases()
{
foreach ([
'app' => [self::class, \Illuminate\Contracts\Container\Container::class,
// ... 万能的三点
\Illuminate\Contracts\View\Factory::class],
] as $key => $aliases) {
foreach ($aliases as $alias) {
$this->alias($key, $alias);
}
}
}
?>
这一看不就晓得，以后这个办法就是吧外围容器注册到容器中嘛，其中就蕴含view/url/db/redis。。。
而后application初始化ok了
application初识总结
总结工夫到了，依据刚刚的过程基于6点准则，做好总结
总结：在application初始化中会先设置整个利用的系统目录地址，在设置实现之后而后就会去注册并绑定外围利用Application到容器中，还注册event/log/routing等服务提供者，最初实现外围容器的注册
03.04 回到index.php看http-kernel
理解到了Application之后咱们再看看http的过程
<code class="php">$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);
$response->send();
$kernel->terminate($request, $response);
有同志可能就说这$kernel是那个对象？？？？这个时候咱们要用准则5打印
<code class="php">$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
var_dump($kernel);
$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);
看下这不就晓得是那个对象了嘛；
调用的就是App/Http/Kernel.php
<code class="php">use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
// ..
}
然而发现它并没有Kernel办法，依据准则4而后发现这最终办法是在Illuminate\Foundation\Http\Kernel中
可能你要跟我讲Illuminate\Foundation\Http\Kernel“这在哪??”
既然你披肝沥胆的提问了那我就大发慈悲的通知你，当你的编辑器不太能间接点击查阅办法的时候，能够看vendor/composer/autoload_classmap.php它会通知你答案
进入Foundation/Http/Kernel.php中
blog\vendor\laravel\framework\src\Illuminate\Foundation\Http\Kernel.php
而后查找kernel办法
<code class="php">// 解决传入的http申请
public function handle($request)
{
try {
$request->enableHttpMethodParameterOverride();
$response = $this->sendRequestThroughRouter($request);
} catch (Exception $e) {
// 可能是解决xxx谬误
} catch (Throwable $e) {
// 可能是解决xxx谬误
}
// 申请事件
$this->app['events']->dispatch(
new Events\RequestHandled($request, $response)
);
return $response;
}
依据办法的整体构造咱们根本能够推断外围解决申请的办法肯定在enableHttpMethodParameterOverride或sendRequestThroughRouter中
因为就这里失常，其余都是处理错误，因而基于准则2别离查看一下这两个办法，后果enableHttpMethodParameterOverride可能查不到…
没方法只能翻译办法名”http办法参数笼罩”，依据这个意思很显然是解决request申请对象的，那和申请解决就没关系；那假相只有一个
就决定是你了sendRequestThroughRouter
<code class="php">protected function sendRequestThroughRouter($request)
{
// 这个不必去看了，晓得是设置request绑定到容器里
$this->app->instance('request', $request);
// facade 明确实例，不理解就跳过
Facade::clearResolvedInstance('request');
$this->bootstrap();
return (new Pipeline($this->app))
->send($request)
->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
->then($this->dispatchToRouter());
}
接下来看bootstrap
最初咱们就只剩下上面两个了，先看bootstrap();
<code class="php">protected $bootstrappers = [
\Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
\Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
\Illuminate\Foundation\Bootstrap\HandleExceptions::class,
\Illuminate\Foundation\Bootstrap\RegisterFacades::class,
\Illuminate\Foundation\Bootstrap\RegisterProviders::class,
\Illuminate\Foundation\Bootstrap\BootProviders::class,
];
public function bootstrap()
{
if (! $this->app->hasBeenBootstrapped()) {
$this->app->bootstrapWith($this->bootstrappers());
}
}
protected function bootstrappers()
{
return $this->bootstrappers;
}
这里为了缩小篇幅间接安顿相干的调度放到一起，依据“bootstrap”翻译是“驱动/启动”再联合bootstrappers属性中的关键词能够揣测是；对框架中的系统配置，错误处理，facade，服务提供者等去进行加载启动；
通过$this->app->bootstrapWith($this->bootstrappers())实现；
等等..$this->app??哪来的？是谁？；依据4准则发现是构造函数传递的
<code class="php">public function __construct(Application $app, Router $router)
{
$this->app = $app;
}
这个时候你有一个抉择能够再看看$this->app->bootstrapWith或者跳过，这里咱们抉择看
<code class="php">public function bootstrapWith(array $bootstrappers)
{
$this->hasBeenBootstrapped = true;
foreach ($bootstrappers as $bootstrapper) {
$this['events']->dispatch('bootstrapping: '.$bootstrapper, [$this]);
$this->make($bootstrapper)->bootstrap($this);
$this['events']->dispatch('bootstrapped: '.$bootstrapper, [$this]);
}
}
好能够发现，前后都是进行event，唯有中间件的$this->make($bootstrapper)->bootstrap($this)
才是真的再搞闲事，这里你就能够联合在’http::kernel::bootstrap’传入的参数再进一步的去查看；然而呢能够适可而止，因为够了；再看就偏题了
回到sendRequestThroughRouter中
<code class="php">return (new Pipeline($this->app))
->send($request)
->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
->then($this->dispatchToRouter());
目前持续剖析，这里会较为难的剖析；因为看起来有些简单；个别闭包办法看谁？？
看外部外部传递的调度办法,因而筛选就只剩$this->app->shouldSkipMiddleware()和$this->dispatchToRouter()
shouldSkipMiddleware属于Application，是利用层面咱们能够先不看，先看dispatchToRouter；因为它是Kernel中的办法，而kernel的次要性能是解决申请因而要看他，是他，是他，就是他；
咱们看dispatchToRouter
<code class="php">// 线路调度程序回调
protected function dispatchToRouter()
{
return function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};
}
好依据咱们的教训看的是不是就是$this->router->dispatch($request)
仔细的发现$this->router在初始化的时候传递了就是Illuminate\Routing\Router对象；
对router施展咱们的准则技巧
上面我会省略之前的技巧使用阐明；因为最终要的还是本人学会，因而前面我就提出要害的办法本人尝试依据我说过的技巧准则去实际吧；实际上我是懒得写了，太多了太累了，唉又不能给个赞
先看如何查找路由
blog\vendor\laravel\framework\src\Illuminate\Routing\Router.php
<code class="php">public function dispatch(Request $request)
{
$this->currentRequest = $request;
return $this->dispatchToRoute($request);
}
public function dispatchToRoute(Request $request)
{
return $this->runRoute($request, $this->findRoute($request));
}
protected function findRoute($request)
{
$this->current = $route = $this->routes->match($request);
$this->container->instance(Route::class, $route);
return $route;
}
protected function runRoute(Request $request, Route $route)
{
$request->setRouteResolver(function () use ($route) {
return $route;
});
$this->events->dispatch(new Events\RouteMatched($route, $request));
return $this->prepareResponse($request,
$this->runRouteWithinStack($route, $request)
);
}
依据整体来看路由的匹配是通过findRoute实现的，runRoute则是运行；而联合对findRoute浏览能够确定的是调用RouteCollection::match进行解析查找的
<code class="php">public function match(Request $request)
{
// 能够试试用打印的办法
$routes = $this->get($request->getMethod());
// 查找到路由，这里是关键性的路由查找办法
$route = $this->matchAgainstRoutes($routes, $request);
if (! is_null($route)) {
return $route->bind($request);
}
$others = $this->checkForAlternateVerbs($request);
if (count($others) > 0) {
return $this->getRouteForMethods($request, $others);
}
throw new NotFoundHttpException;
}
protected function matchAgainstRoutes(array $routes, $request, $includingMethod = true)
{
// 这里看不懂就打印$fallbacks, $routes就行了，用var_dump
[$fallbacks, $routes] = collect($routes)->partition(function ($route) {
return $route->isFallback;
});
// 这里是闭包，遇到闭包间接看外部调用的办法
return $routes->merge($fallbacks)->first(function ($value) use ($request, $includingMethod) {
// $value不晓得就用var_dump打印
return $value->matches($request, $includingMethod);
});
}
通过下面的步骤根本就能够找到，是调用的那个办法最终会在赋值给$route变量并返回
最初看如何查调用
回到blog\vendor\laravel\framework\src\Illuminate\Routing\Router.php中
<code class="php">protected function runRoute(Request $request, Route $route)
{
$request->setRouteResolver(function () use ($route) {
return $route;
});
$this->events->dispatch(new Events\RouteMatched($route, $request));
return $this->prepareResponse($request,
// 一样的准则先看它
$this->runRouteWithinStack($route, $request)
);
}
protected function runRouteWithinStack(Route $route, Request $request)
{
$shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
$this->container->make('middleware.disable') === true;
$middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
return (new Pipeline($this->container))
->send($request)
->through($middleware)
->then(function ($request) use ($route) {
// 一样的准则又是看它
return $this->prepareResponse(
// $route在下面传参了
$request, $route->run()
);
});
}
而后咱们就能够看到调用的中央了Route::run办法
<code class="php">
public function run()
{
$this->container = $this->container ?: new Container;
try {
if ($this->isControllerAction()) {
return $this->runController();
}
return $this->runCallable();
} catch (HttpResponseException $e) {
return $e->getResponse();
}
}
好了到此咱们就看完了
04. 续
心愿本次对源码解读的过程能够帮忙到你
.
转载请注明原文链接：源码阅读分析PHPlaravel
