The basic working principle of middleware in the pipeline design pattern in the Laravel framework

laravelThe pipeline design pattern in the framework is that the data is transferred to the pipeline to be processed, and then passed to the next step. Next, let’s take a look at the pipeline design in the laravel framework The basic working principle of pattern middleware.

The so-called pipeline (Pipeline) design pattern is to pass data to a task sequence. The pipeline plays the role of an assembly line, where the data is processed and then passed to the next step.

Using pipelines has many benefits, especially when writing complex processing code in a single task. Pipelines provide us with great convenience, and stage tasks can be easily added, removed, or replaced in the pipeline.

LaravelThe Pipeline design pattern is used in many places in the framework, which means that all the places where we need to implement the pipeline design pattern are already part of the underlying application.

We can use Laravel's internal components to build our own functionality on top of the framework. In today’s tutorial we will discuss the pipeline design pattern and how to use Laravel’s internal pipelines.

What is the pipeline design pattern?

Pipeline mode is used to break down complex processes into multiple independent subtasks. Each independent task is reusable, so these tasks can be combined into complex processes.

This mode allows you to break down a huge process into smaller subtasks, which process the data and pass the processed results to the next subtask. Just like an assembly line, it is orderly and complete, from raw material processing to finished products.

Each task in the pipeline will accept and return the same type of data, so subtasks can be added, removed, or replaced in the pipeline without affecting other subtasks.

If you are familiar with Unix systems, you may be familiar with pipes, because we often use pipe commands in shell commands, for example:

cat helloworld.txt | grep "hello world" | rev | > output.txt

In this example, we read file content and query it for the string "hello world", reverse the string and finally add it to the output.txt file.

How to use pipeline mode in Laravel?

Laravel uses the pipeline design pattern in many places in the framework, the most common one being the implementation of middleware.

When the request finally reaches the controller action and is processed, it will first go through a series of middleware. Each intermediary has an independent responsibility, such as setting cookies, determining whether to log in, and preventing CSRF attacks, etc.

The request will be processed at each stage. If the request passes, it will be passed to the next processing. If it fails, the corresponding HTTP response will be returned.

This mechanism makes it easy for us to add processing operations before the request finally reaches the application code. Of course, if this processing operation is not needed, you can also remove it at any time without affecting the life cycle of the request.

Advantages of the pipeline mode

The pipeline mode has many advantages:

First, it breaks down the complex processing flow into independent subtasks, making it easier to Test each subtask;

Secondly, the decomposed subtasks can be reused by different processing processes to avoid code redundancy.

Finally, it is very easy to add, remove and replace subtasks in complex processes without any impact on existing processes.

Disadvantages of the pipeline mode

Of course, the pipeline mode also has disadvantages:

Although each sub-task becomes simpler, when you try again There is a certain degree of complexity when these subtasks are combined into a complete process;

In addition, you also need to ensure that the overall process can work normally after the independent subtask tests pass, which has a certain degree of uncertainty.

Finally, when all you see is a sub-task, it makes it difficult to understand the overall process (the story of the blind man touching the elephant must be familiar to everyone, and this is why).

How to use Laravel's pipeline

Using the pipeline provided by Laravel is very simple. First, you need to create a new Illuminate\Pipeline\Pipeline object and inject it into a certain An instance of Illuminate\Contracts\Container\Container:

$pipeline = app('Illuminate\Pipeline\Pipeline');

Next send the object you want to pass to this pipe:

$pipeline->send($request);

Then pass it to the task array that accepts and processes the request ：

$pipeline->through($middleware);

Finally run the pipeline task and write the callback processing:

$pipeline->then(function ($request) {
    // Do something
});

This is the basic working principle of middleware: receive HTTP requests, let the requests go through the defined routing middleware, and finally reach the destination processed locally.

Conclusion

The pipeline design pattern is very useful. Middleware is just a special example. Laravel makes full use of this design pattern in the underlying framework. Of course, you can also Use the pipeline provided by Laravel in your own project.

The above is the entire content of this article, please pay attention to the laravel tutorial for more!

Recommended related articles:

Laravel environment construction: How to deploy laravel to Alibaba Cloud or Tencent Cloud steps

Related course recommendations:

The latest five Laravel videos in 2017 Tutorial recommendation

The above is the detailed content of The basic working principle of middleware in the pipeline design pattern in the Laravel framework. For more information, please follow other related articles on the PHP Chinese website!