Hallo zusammen, heute werde ich euch die Pipeline des Laravel-Frameworks vorstellen.
Es ist eine sehr einfach zu verwendende Komponente, die die Struktur des Codes sehr klar machen kann. Darauf basierend wird der Middleware-Mechanismus von Laravel implementiert.
Durch Pipeline kann die APO-Programmierung einfach implementiert werden.
Offizielle GIT-Adresse
https://github.com/illuminate/pipeline
Der folgende Code ist eine vereinfachte Version, die ich implementiert habe:
class Pipeline
{
/**
* The method to call on each pipe
* @var string
*/
protected $method = 'handle';
/**
* The object being passed throw the pipeline
* @var mixed
*/
protected $passable;
/**
* The array of class pipes
* @var array
*/
protected $pipes = [];
/**
* Set the object being sent through the pipeline
*
* @param $passable
* @return $this
*/
public function send($passable)
{
$this->passable = $passable;
return $this;
}
/**
* Set the method to call on the pipes
* @param array $pipes
* @return $this
*/
public function through($pipes)
{
$this->pipes = $pipes;
return $this;
}
/**
* @param \Closure $destination
* @return mixed
*/
public function then(\Closure $destination)
{
$pipeline = array_reduce(array_reverse($this->pipes), $this->getSlice(), $destination);
return $pipeline($this->passable);
}
/**
* Get a Closure that represents a slice of the application onion
* @return \Closure
*/
protected function getSlice()
{
return function($stack, $pipe){
return function ($request) use ($stack, $pipe) {
return $pipe::{$this->method}($request, $stack);
};
};
}
}
Die Hauptlogik dieses Typs liegt in den Methoden then und getSlice. Generieren Sie über array_reduce eine anonyme Funktion, die einen Parameter akzeptiert, und führen Sie dann den Aufruf aus.
Einfaches Anwendungsbeispiel
class ALogic
{
public static function handle($data, \Clourse $next)
{
print "开始 A 逻辑";
$ret = $next($data);
print "结束 A 逻辑";
return $ret;
}
}
class BLogic
{
public static function handle($data, \Clourse $next)
{
print "开始 B 逻辑";
$ret = $next($data);
print "结束 B 逻辑";
return $ret;
}
}
class CLogic
{
public static function handle($data, \Clourse $next)
{
print "开始 C 逻辑";
$ret = $next($data);
print "结束 C 逻辑";
return $ret;
}
}
$pipes = [
ALogic::class,
BLogic::class,
CLogic::class
];
$data = "any things";
(new Pipeline())->send($data)->through($pipes)->then(function($data){ print $data;});
Laufendes Ergebnis:
"开始 A 逻辑" "开始 B 逻辑" "开始 C 逻辑" "any things" "结束 C 逻辑" "结束 B 逻辑" "结束 A 逻辑"
AOP-Beispiel
Der Vorteil von AOP besteht darin, dass es Funktionen dynamisch hinzufügen kann, ohne andere Ebenen zu beeinträchtigen, und es sehr praktisch sein kann, Funktionen hinzuzufügen oder zu löschen.
class IpCheck
{
public static function handle($data, \Clourse $next)
{
if ("IP invalid") { // IP 不合法
throw Exception("ip invalid");
}
return $next($data);
}
}
class StatusManage
{
public static function handle($data, \Clourse $next)
{
// exec 可以执行初始化状态的操作
$ret = $next($data)
// exec 可以执行保存状态信息的操作
return $ret;
}
}
$pipes = [
IpCheck::class,
StatusManage::class,
];
(new Pipeline())->send($data)->through($pipes)->then(function($data){ "执行其它逻辑";});