PHP 파이프라인 플러그인 League\Pipeline 분석에 대해

이 기사에서는 주로 참조 가치가 있는 PHP 파이프라인 플러그인 LeaguePipeline에 대한 분석을 소개합니다. 이제는 필요한 친구들이 참조할 수 있습니다.

Pipeline 디자인 패턴 #🎜🎜 #

수도관이 너무 길어서 한 부분이 부러지면 물이 새고, 복잡한 환경에서 구부러지고 휘어지는 데 도움이 되지 않습니다. 따라서 우리는 수도관을 매우 짧은 파이프로 나눈 다음 파이프의 크기를 최대화하여 다양한 기능을 갖고 현지 조건에 적응하고 다양한 요구 사항을 충족하도록 함께 조립할 것입니다.

이는 복잡하고 긴 프로세스를 작은 프로세스와 작업으로 나누는 파이프라인의 디자인 패턴으로 이어집니다. 최소한으로 정량화된 각 작업을 재사용하여 다양한 작은 작업을 조합하여 복잡하고 다양한 프로세스를 형성할 수 있습니다.

마지막으로 "입력"을 파이프라인에 도입하고 각 작은 작업에 따라 입력을 작동(처리, 필터링)하고 최종적으로 요구 사항을 충족하는 결과를 출력합니다.

오늘은 "Pipeline"을 주로 배울건데, 그런데 PHP 플러그인 league/pipeline을 추천합니다.

league/pipeline。

gulp

第一次知道「pipe」的概念，来自 gulp 的使用。

gulp 是基于 NodeJS 的自动任务运行器，她能自动化地完成Javascript、sass、less 等文件的测试、检查、合并、压缩、格式化、浏览器自动刷新、部署文件生成，并监听文件在改动后重复指定的这些步骤。在实现上，她借鉴了 Unix 操作系统的管道 (pipe) 思想，前一级的输出，直接变成后一级的输入，使得在操作上非常简单。

var gulp = require('gulp');
var less = require('gulp-less');
var minifyCSS = require('gulp-csso');
var concat = require('gulp-concat');
var sourcemaps = require('gulp-sourcemaps');

gulp.task('css', function(){
  return gulp.src('client/templates/*.less')
    .pipe(less())
    .pipe(minifyCSS())
    .pipe(gulp.dest('build/css'))
});

gulp.task('js', function(){
  return gulp.src('client/javascript/*.js')
    .pipe(sourcemaps.init())
    .pipe(concat('app.min.js'))
    .pipe(sourcemaps.write())
    .pipe(gulp.dest('build/js'))
});

gulp.task('default', [ 'html', 'css', 'js' ]);

上面的两个 task 主要是将 less、所有 js 文件进行解析、压缩、输出等流程操作，然后存到对应的文件夹下；每一步操作的输出就是下一步操作的输入，犹如管道的流水一般。

IlluminatePipeline

Laravel 框架中的中间件，就是利用 IlluminatePipeline 来实现的，本来想写写我对 「Laravel 中间件」源码的解读，但发现网上已经有很多帖子都有表述了，所以本文就简单说说如何使用 IlluminatePipeline。

写个 demo

public function demo(Request $request)
{
    $pipe1 = function ($payload, Closure $next) {
        $payload = $payload + 1;
        return $next($payload);
    };

    $pipe2 = function ($payload, Closure $next) {
        $payload = $payload * 3;
        return $next($payload);
    };

    $data = $request->input('data', 0);

    $pipeline = new Pipeline();

    return $pipeline
        ->send($data)
        ->through([$pipe1, $pipe2])
        ->then(function ($data) {
            return $data;
        });
}

对于该源码的分析，可以推荐看这篇文章，分析的挺透彻了：

Laravel Pipeline 组件的实现 https://www.insp.top/article/realization-of-pipeline-component-for-laravel

LeaguePipeline

上面对 gulp 和 IlluminatePipeline 的简单使用，只是告诉我们「Pipeline」应用比较广泛。如果让我们自己也写一个类似的插件出来呢，我想应该也不是很难。

下面我拿 LeaguePipelinegulp

"파이프"라는 개념을 처음 알게 된 것은 gulp를 사용하면서 나왔습니다.

gulp는 NodeJS를 기반으로 하는 자동 작업 실행기입니다. 그녀는 Javascript, sass, less 및 기타 테스트, 검사, 병합, 압축, 서식 지정, 자동 브라우저 새로 고침 등을 자동으로 완료할 수 있습니다. 파일이 생성되고 파일이 변경된 후 지정된 단계가 반복됩니다. 구현 측면에서는 Unix 운영 체제의 파이프 아이디어를 활용하여 이전 레벨의 출력이 바로 다음 레벨의 입력이 되므로 작업이 매우 간단합니다.

composer require league/pipeline

위의 두 작업은 주로 less 및 모든 js 파일을 구문 분석하고 압축하고 출력하는 데 사용됩니다. 그런 다음 작업은 해당 폴더에 저장됩니다. 파이프라인의 물 흐름과 마찬가지로 각 작업의 출력은 다음 작업의 입력이 됩니다.

IlluminatePipeline

Laravel 프레임워크의 미들웨어는 IlluminatePipeline을 사용하여 구현되었습니다. 원래는 "Laravel 미들웨어" 소스 코드 해석에 대해 작성하고 싶었습니다. 하지만 이미 인터넷에 이에 대해 설명하는 게시물이 많이 있다는 것을 알게 되었기 때문에 이번 글에서는 간단히 IlluminatePipeline 사용법에 대해서만 설명하겠습니다.

데모 작성

use League\Pipeline\Pipeline;

// 创建两个闭包函数
$pipe1 = function ($payload) {
    return $payload + 1;
};

$pipe2 = function ($payload) {
    return $payload * 3;
};

$route->map(
    'GET',
    '/demo',
    function (ServerRequestInterface $request, ResponseInterface $response
    ) use ($service, $pipe1, $pipe2) {
        $params = $request->getQueryParams();

        // 正常使用
        $pipeline1 = (new Pipeline)
            ->pipe($pipe1)
            ->pipe($pipe2);

        $callback1 = $pipeline1->process($params['data']);

        $response->getBody()->write("<h1 id="正常使用">正常使用</h1>");
        $response->getBody()->write("<p>结果：$callback1</p>");

        // 使用魔术方法
        $pipeline2 = (new Pipeline())
            ->pipe($pipe1)
            ->pipe($pipe2);

        $callback2 = $pipeline2($params['data']);

        $response->getBody()->write("<h1 id="使用魔术方法">使用魔术方法</h1>");
        $response->getBody()->write("<p>结果：$callback2</p>");

        // 使用 Builder
        $builder = new PipelineBuilder();
        $pipeline3 = $builder
            ->add($pipe1)
            ->add($pipe2)
            ->build();

        $callback3 = $pipeline3($params['data']);

        $response->getBody()->write("<h1 id="使用-Builder">使用 Builder</h1>");
        $response->getBody()->write("<p>结果：$callback3</p>");
        return $response;
    }
);

#🎜 🎜 # 소스 코드 분석을 위해 이 기사를 읽는 것이 좋습니다. 분석은 매우 철저합니다.

Laravel Pipeline 구성 요소 구현 https://www.insp. top/ article/realization-of-pipeline-comComponent-for-laravel

LeaguePipeline

위는 gulp 및 IlluminatePipeline에 대한 것입니다. code> 간단히 사용하면 "파이프라인"이 널리 사용된다는 것을 알 수 있습니다. 비슷한 플러그인을 직접 작성해 달라고 하면 어렵지 않을 것 같아요. <p><img src="/static/imghw/default1.png" data-src="https://img.php.cn//upload/image/615/141/918/1531204142213417.jpg" class="lazy" title="1531204142213417.jpg" alt="PHP 파이프라인 플러그인 League\Pipeline 분석에 대해"> 이제 <code>LeaguePipeline 플러그인의 소스코드를 살펴보며 어떻게 구현되는지 살펴보겠습니다.

간단한 설명

이 패키지는 파이프라인 패턴의 플러그 앤 플레이 구현을 제공합니다. 이는 순차적 프로세스를 캡슐화하는 아키텍처 패턴입니다. , 이를 통해 작업과 파이프라인을 혼합하고 일치시켜 새로운 실행 체인을 생성할 수 있습니다. 파이프라인 패턴은 각 단계가 특정 페이로드/주제에 대해 특정 작업을 수행하고 조작할 수 있는 생산 라인과 종종 비교됩니다. , 페이로드를 장식하거나 교체할 수도 있습니다.

특정 주제에 대한 일련의 작업을 완료하기 위해 한 함수에서 다른 함수로 결과를 전달하는 경우 이를 파이프라인으로 변환하는 것이 좋습니다.

# 🎜🎜#https://pipeline.thephpleague.com/

플러그인 설치

<?php declare(strict_types=1);

namespace League\Pipeline;

interface PipelineInterface extends StageInterface
{
    /**
     * Create a new pipeline with an appended stage.
     *
     * @return static
     */
    public function pipe(callable $operation): PipelineInterface;
}

interface StageInterface
{
    /**
     * Process the payload.
     *
     * @param mixed $payload
     *
     * @return mixed
     */
    public function __invoke($payload);
}

쓰기 데모

<?php class CallableClass 
{
    function __invoke($x) {
        var_dump($x);
    }
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));
?>

#🎜🎜##🎜🎜#실행 결과#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜 🎜##🎜🎜##🎜🎜#소스 코드 해석#🎜🎜##🎜🎜##🎜🎜#전체 플러그인에는 다음 파일만 있습니다: #🎜🎜##🎜🎜##🎜🎜##🎜 🎜## 🎜🎜##🎜🎜#PipelineInterface#🎜🎜##🎜🎜#

int(5)
bool(true)

#🎜🎜#이 인터페이스는 주로 체인 프로그래밍 아이디어를 사용하여 파이프 "파이프"를 지속적으로 추가한 다음 마법의 방법을 추가합니다. 들어오는 매개변수가 작동하도록 하십시오. #🎜🎜##🎜🎜#이 마법 메서드의 기능을 살펴보겠습니다. #🎜🎜#

mixed __invoke ([ $... ] )
当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用。

如：

<?php class CallableClass 
{
    function __invoke($x) {
        var_dump($x);
    }
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));
?>

返回结果：

int(5)
bool(true)

Pipeline

<?php declare(strict_types=1);

namespace League\Pipeline;

class Pipeline implements PipelineInterface
{
    /**
     * @var callable[]
     */
    private $stages = [];

    /**
     * @var ProcessorInterface
     */
    private $processor;

    public function __construct(ProcessorInterface $processor = null, callable ...$stages)
    {
        $this->processor = $processor ?? new FingersCrossedProcessor;
        $this->stages = $stages;
    }

    public function pipe(callable $stage): PipelineInterface
    {
        $pipeline = clone $this;
        $pipeline->stages[] = $stage;

        return $pipeline;
    }

    public function process($payload)
    {
        return $this->processor->process($payload, ...$this->stages);
    }

    public function __invoke($payload)
    {
        return $this->process($payload);
    }
}

其中核心类 Pipeline 的作用主要就是两个：

1. 添加组装各个管道「pipe」；

2. 组装后，引水流动，执行 process($payload)，输出结果。

Processor

接好各种管道后，那就要「引水入渠」了。该插件提供了两个基础执行类，比较简单，直接看代码就能懂。

// 按照 $stages 数组顺利，遍历执行管道方法，再将结果传入下一个管道，让「水」一层层「流动」起来
class FingersCrossedProcessor implements ProcessorInterface
{
    public function process($payload, callable ...$stages)
    {
        foreach ($stages as $stage) {
            $payload = $stage($payload);
        }

        return $payload;
    }
}

// 增加一个额外的「过滤网」，经过每个管道后的结果，都需要 check，一旦满足则终止，直接输出结果。
class InterruptibleProcessor implements ProcessorInterface
{
    /**
     * @var callable
     */
    private $check;

    public function __construct(callable $check)
    {
        $this->check = $check;
    }

    public function process($payload, callable ...$stages)
    {
        $check = $this->check;

        foreach ($stages as $stage) {
            $payload = $stage($payload);

            if (true !== $check($payload)) {
                return $payload;
            }
        }

        return $payload;
    }
}

interface ProcessorInterface
{
    /**
     * Process the payload using multiple stages.
     *
     * @param mixed $payload
     *
     * @return mixed
     */
    public function process($payload, callable ...$stages);
}

我们完全也可以利用该接口，实现我们的方法来组装管道和「过滤网」。

PipelineBuilder

最后提供了一个 Builder，这个也很好理解：

class PipelineBuilder implements PipelineBuilderInterface
{
    /**
     * @var callable[]
     */
    private $stages = [];

    /**
     * @return self
     */
    public function add(callable $stage): PipelineBuilderInterface
    {
        $this->stages[] = $stage;

        return $this;
    }

    public function build(ProcessorInterface $processor = null): PipelineInterface
    {
        return new Pipeline($processor, ...$this->stages);
    }
}

interface PipelineBuilderInterface
{
    /**
     * Add an stage.
     *
     * @return self
     */
    public function add(callable $stage): PipelineBuilderInterface;

    /**
     * Build a new Pipeline object.
     */
    public function build(ProcessorInterface $processor = null): PipelineInterface;
}

总结

无论是对不同技术的横向理解，还是基于 Laravel 或者某些开源插件，我们都能学习到技术之上的通用原理和方法。再将这些原理和方法反作用于我们的实际代码开发中。

最近闲来没事，自己参考 Laravel 去写个简易框架，也将League\Pipeline 引入到框架中使用。

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

关于PHP开发中遇到的一些错误的解决方法

关于利用Vue-laravel前端和后端分离写一个博客的方法

위 내용은 PHP 파이프라인 플러그인 League\Pipeline 분석에 대해의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!