PHP Cron

Laravel-CacheHelper

根据提供的搜索结果,我可以总结以下关于 Laravel 缓存类 CacheHelper 的最详细知识点:

CacheHelper 类的详细介绍

CacheHelper 是一个抽象类,提供了三个主要方法:
- getKey(): 获取缓存的键
- value(): 从缓存中获取值,如果缓存中不存在则调用 generate() 方法生成并存入缓存
- forget(): 从缓存中删除指定键的值
CacheHelper 类中有两个属性:
- $key: 缓存的键
- $ttl: 缓存的有效时间,单位为秒
value() 方法使用了 Laravel 的 Cache facade 的 remember() 方法来实现从缓存获取值的功能。如果缓存中不存在对应的键,则会调用匿名函数 generate() 来生成值并存入缓存。
forget() 方法使用了 Laravel 的 Cache facade 的 forget() 方法来从缓存中删除指定键的值。
CacheHelper 类是一个抽象类,需要被继承并实现 generate() 方法。开发者可以继承该类并实现自己的缓存逻辑。
作者还提供了一个 CacheIdentifier trait,可以用于为缓存键添加标识符,如用户 ID 等。

使用示例

作者提供了一个 UserExpensiveComputationCache 类作为 CacheHelper 的具体实现示例:

该类继承了 CacheHelper 并使用了 CacheIdentifier trait。
在构造函数中,将用户对象传入,并将用户 ID 作为缓存键的标识符。
generate() 方法中,调用了用户对象的 expensiveComputation() 方法来生成缓存值。
使用时,可以通过 UserExpensiveComputationCache::make($user) 来获取缓存值。

总的来说,CacheHelper 类提供了一个抽象的缓存操作基类,开发者可以继承该类并实现自己的缓存逻辑。该文章详细介绍了 CacheHelper 类的实现原理和使用方法,为开发者提供了一个很好的参考。[1]

Citations: [1] https://buff.ly/3ILNBvj [2] https://blog.csdn.net/libankling2008/article/details/117586654 [3] https://interviewguide.cn/notes/01-guide/web-guide-reading.html [4] https://jb51.net/article/139530.htm [5] https://juejin.cn/post/7269995206806716457

Laravel Queue System

two methods to config the cronJob using laravel:

schedule ->run ,启动schedule

crontab

queue::work is the default queue running on the background

job::dispatch->({jobname})

for the job,we have to create the specific job configuration if we using supervisor

Using a job is a static method call behaviour, its just PHP the same way that you use static method calls with your models, they are actually not facades.

Laravel Distributed Lock

Here is the summary of the detailed knowledge points about distributed locks, translated into English:

Background and Needs of Distributed Locks

In distributed systems, concurrent access to shared resources by multiple nodes may lead to data inconsistency or resource contention issues. Distributed locks are designed to solve these problems.

The main purposes of distributed locks are:

Ensure Mutual Exclusion: In a distributed environment, ensure that only one node can access the critical section resource at a time.
Prevent Cache Penetration: When the cache expires, multiple nodes may simultaneously access the database, putting pressure on the database. Distributed locks can ensure that only one node queries the database and updates the cache.
Control Concurrent Access: In high-concurrency scenarios, distributed locks can limit concurrent access to shared resources, preventing resource contention.

Implementation Methods of Distributed Locks

There are three main ways to implement distributed locks:

1. Implement Distributed Locks Based on Databases

The core idea is to create a table in the database, which includes method name and other fields, and create a unique index on the method name field. To execute a method, you can lock using this index field.

Advantages:

Simple implementation, easy to understand
High reliability, the database system can guarantee data consistency

Disadvantages:

Poor performance, frequent database access can become a bottleneck
Single point of failure risk, database downtime will cause all businesses to be unavailable

2. Implement Distributed Locks Based on Caches (Redis)

As a high-performance in-memory database, Redis is very suitable for implementing distributed locks. The common approach is to use the SETNX command to lock, and the DEL command to release the lock.

Advantages:

High performance, Redis's single-threaded model can provide high concurrency support
High reliability, Redis clusters can provide high availability
Simple implementation, Redis provides ready-made commands to support

Disadvantages:

Need to ensure the high availability of Redis, otherwise it will become a single point of failure
Need to properly handle the security and liveness issues of locks, such as deadlocks, mistaken lock deletions, etc.

3. Implement Distributed Locks Based on Zookeeper

Zookeeper provides a symmetric distributed coordination service, which can be used to implement distributed locks. The common approach is to create ephemeral sequential nodes on Zookeeper, and monitor the status of the previous node to implement distributed locks.

Advantages:

High reliability, Zookeeper clusters can provide high availability
Support multiple language clients, easy to integrate
Support timeout mechanism, can automatically release locks

Disadvantages:

Relatively complex implementation, need to understand the working principle of Zookeeper
Slightly lower performance than Redis, as it requires frequent access to Zookeeper

Correct Implementation of Redis Distributed Locks

When using Redis to implement distributed locks, the following points need to be noted:

Check if there is an existing lock when locking. If there is no lock, use the SETNX command to lock and set an expiration time. If the locking fails, it means that another process already holds the lock.
Set a reasonable expiration time. The expiration time should be based on business requirements, usually set to 2-10 seconds. If the business execution time exceeds this time, you need to continuously extend the expiration time of the lock during the execution process.
Check if the lock belongs to yourself when unlocking. When unlocking, first use the GET command to get the lock value, and check if it is your own lock identifier. If so, use the DEL command to delete the lock. This can avoid mistakenly deleting other processes' locks.

Here is an example implementation of Redis distributed locks:

public function lock($lockKey, $requestId, $expireTime)
{
    $redis = Redis::connection();
    $result = $redis->setnx($lockKey, $requestId);
    if ($result) {
        $redis->expire($lockKey, $expireTime);
        return true;
    }
    return false;
}

public function releaseLock($lockKey, $requestId)
{
    $redis = Redis::connection();
    $result = $redis->get($lockKey);
    if ($result == $requestId) {
        $redis->del($lockKey);
        return true;
    }
    return false;
}

Considerations for Redis Distributed Locks

Locking and setting the expiration time are not atomic operations, which may lead to deadlocks. You need to use the SET command's NX and PX parameters to achieve atomic operations.
When unlocking, you need to check if the lock belongs to yourself, otherwise you may mistakenly delete other processes' locks.
If the business execution time exceeds the lock expiration time, you need to continuously extend the expiration time of the lock during the execution process.
The client identifier (requestId) needs to be globally unique, which can be generated using md5(uniqid(env('APP_NAME'), true)) . rand(10000, 99999).

Other Implementation Methods of Distributed Locks

In addition to the above three main implementation methods, there are some other implementation methods:

File Lock-based

Create a file in a distributed file system (such as NFS), and implement distributed locks by locking the file. This method is simple and easy to understand, but has the risk of single point of failure and poor performance.

Memcached-based

As a high-performance distributed cache system, Memcached can also be used to implement distributed locks. The implementation method is similar to Redis, using the add command to lock and the delete command to unlock.

Etcd-based

Etcd is a highly available distributed key-value storage system, which can also be used to implement distributed locks. Etcd provides distributed coordination services similar to Zookeeper, and can implement distributed locks by creating ephemeral sequential nodes.

Application Scenarios of Distributed Locks

Distributed locks are widely used in the following scenarios:

Distributed Task Scheduling: Multiple nodes execute the same scheduled task simultaneously, and need to use distributed locks to ensure mutual exclusion of the task.
Distributed Rate Limiting: Multiple nodes simultaneously access the same resource, and need to use distributed locks to control concurrent access.
Distributed Cache Update: Multiple nodes simultaneously update the same cache, and need to use distributed locks to ensure cache consistency.
Distributed Session Management: Multiple nodes share the same session, and need to use distributed locks to ensure session uniqueness.
Distributed Payment: Multiple nodes simultaneously deduct the same account balance, and need to use distributed locks to ensure the correctness of the account balance.

Performance Optimization of Distributed Locks

To improve the performance of distributed locks, the following optimization measures can be taken:

Use Redis Cluster or Sentinel to improve the availability of Redis, to avoid single point of failure.
Adopt an asynchronous approach to extend the lock expiration time, to reduce the risk of business execution time exceeding the lock expiration time.
Use the Redis EVAL command to implement atomic locking and expiration time setting, to avoid deadlock issues.
Adopt a segmented locking approach, dividing a large critical section into multiple smaller critical sections to improve concurrency.
Use the Redis WATCH command to implement optimistic locking, to reduce the number of lock retries.
Adopt mature distributed lock implementation libraries like Redisson, which encapsulate the complex implementation details of distributed locks.

Other Considerations for Distributed Locks

Lock Granularity: Too fine-grained locks will increase system complexity, while too coarse-grained locks will reduce concurrency. The lock granularity needs to be balanced based on the business scenario.
Lock Timeout: Too short timeout may cause business execution to be interrupted, while too long timeout may reduce system responsiveness.
Lock Retry Mechanism: The retry strategy when locking fails, such as exponential backoff, random delay, etc., needs to be designed based on the business scenario.
Lock Fault Tolerance: When the dependent services like Redis or Zookeeper are unavailable, there should be corresponding fault tolerance measures, such as degradation or backup plans.
Lock Monitoring and Alerting: It is necessary to monitor and alert the usage of distributed locks, to timely detect and solve problems.

In summary, distributed locks are an important technical point in distributed systems. You need to choose the appropriate implementation method based on the specific business scenario, and pay attention to various details to design a reliable and efficient distributed lock solution.

分布式锁的背景和需求

在分布式系统中,多个节点同时访问共享资源可能会导致数据不一致或资源争用的问题。分布式锁就是为了解决这个问题而产生的。

分布式锁的主要作用有:

保证互斥访问:在分布式环境下,保证同一时间只有一个节点可以访问临界区资源。[1][2][3]
防止缓存击穿:当缓存失效时,多个节点同时访问数据库,会对数据库造成压力。分布式锁可以保证只有一个节点去查询数据库并更新缓存。[2]
控制并发访问:在高并发场景下,分布式锁可以限制对共享资源的并发访问,避免资源争用。[3]

分布式锁的实现方式

实现分布式锁的主要方式有三种:

1. 基于数据库实现分布式锁

核心思想是在数据库中创建一个表,表中包含方法名等字段,并在方法名字段上创建唯一索引。想要执行某个方法,就使用这个索引字段加锁。[4]

优点:

实现简单,容易理解
可靠性高,数据库系统能够保证数据的一致性

缺点:

性能较差,频繁的数据库访问会成为瓶颈
存在单点故障风险,数据库挂掉会导致所有业务不可用

2. 基于缓存(Redis)实现分布式锁

Redis作为一个高性能的内存数据库,非常适合用来实现分布式锁。常见的实现方式是使用Redis的SETNX命令加锁,DEL命令释放锁。[1][2][3]

优点:

性能好,Redis的单线程模型能够提供高并发支持
可靠性高,Redis集群可以提供高可用性
实现简单,Redis提供了现成的命令支持

缺点:

需要保证Redis的高可用性,否则会成为单点故障
需要处理好锁的安全性和活性问题,如死锁、误删锁等

3. 基于Zookeeper实现分布式锁

Zookeeper提供了对称的分布式协调服务,可以用来实现分布式锁。常见的方式是在Zookeeper上创建临时有序节点,通过监听前一个节点的状态来实现分布式锁。[4]

优点:

可靠性高,Zookeeper集群能够提供高可用性
支持多种语言客户端,集成方便
支持超时机制,能够自动释放锁

缺点:

实现相对复杂,需要理解Zookeeper的工作原理
性能略差于Redis,因为需要频繁访问Zookeeper

Redis分布式锁的正确实现

使用Redis实现分布式锁需要注意以下几点:

加锁时要检查是否已经有锁存在。如果没有锁,则使用SETNX命令加锁,并设置过期时间。如果加锁失败,则说明已经有其他进程持有该锁。[1]
设置合理的过期时间。过期时间应该根据业务需求而定,通常设置为2-10秒。如果业务执行时间超过该时间,则需要在执行过程中不断延长锁的过期时间。[1]
解锁时要判断是否为自己的锁。解锁时先使用GET命令获取锁的值,判断是否为自己的锁标识,如果是则使用DEL命令删除该锁。这样可以避免误删其他进程的锁。[1]

下面是一个Redis分布式锁的实现示例:

public function lock($lockKey, $requestId, $expireTime)
{
    $redis = Redis::connection();
    $result = $redis->setnx($lockKey, $requestId);
    if ($result) {
        $redis->expire($lockKey, $expireTime);
        return true;
    }
    return false;
}

public function releaseLock($lockKey, $requestId)
{
    $redis = Redis::connection();
    $result = $redis->get($lockKey);
    if ($result == $requestId) {
        $redis->del($lockKey);
        return true;
    }
    return false;
}

Redis分布式锁的注意事项

加锁和设置过期时间不是原子操作,可能会导致死锁。需要使用SET命令的NX和PX参数来实现原子操作。[1]
解锁时需要判断锁是否属于自己,否则可能会误删其他进程的锁。[1]
如果业务执行时间超过锁的过期时间,需要在执行过程中不断延长锁的过期时间。[1]
客户端标识(requestId)需要确保全局唯一,可以使用md5(uniqid(env('APP_NAME'), true)) . rand(10000, 99999)生成。[1]

分布式锁的其他实现方式

除了上述三种主要的实现方式,还有一些其他的实现方式:

基于文件锁

在分布式文件系统(如NFS)上创建文件,通过对文件加锁来实现分布式锁。这种方式简单易懂,但是存在单点故障风险,性能也较差。[4]

基于Memcached

Memcached作为一个高性能的分布式缓存系统,也可以用来实现分布式锁。实现方式与Redis类似,使用add命令加锁,delete命令释放锁。[4]

基于Etcd

Etcd是一个高可用的分布式键值存储系统,也可以用来实现分布式锁。Etcd提供了类似Zookeeper的分布式协调服务,可以通过创建临时有序节点来实现分布式锁。[4]

分布式锁的应用场景

分布式锁广泛应用于以下场景:

分布式任务调度:多个节点同时执行同一个定时任务,需要使用分布式锁来保证任务的互斥执行。[2][3]
分布式限流:多个节点同时访问同一个资源,需要使用分布式锁来控制并发访问。[2][3]
分布式缓存更新:多个节点同时更新同一个缓存,需要使用分布式锁来保证缓存的一致性。[1][2]
分布式会话管理:多个节点共享同一个会话,需要使用分布式锁来保证会话的唯一性。[3]
分布式支付:多个节点同时扣减同一个账户余额,需要使用分布式锁来保证账户余额的正确性。[3]

分布式锁的性能优化

为了提高分布式锁的性能,可以采取以下优化措施:

使用Redis Cluster或Sentinel提高Redis的可用性,避免单点故障。[1]
采用异步延长锁过期时间的方式,减少业务执行时间超过锁过期时间的风险。[1]
使用Redis的EVAL命令实现加锁和设置过期时间的原子操作,避免死锁问题。[1]
采用分段加锁的方式,将一个大的临界区拆分成多个小的临界区,提高并发度。[3]
使用Redis的WATCH命令实现乐观锁,减少锁重试的次数。[2]
采用Redisson等成熟的分布式锁实现库,封装了分布式锁的复杂实现细节。[2][3]

分布式锁的其他注意事项

锁的粒度:锁的粒度过细会增加系统复杂度,过粗会降低并发度,需要根据业务场景进行权衡。
锁的超时时间:超时时间过短会导致业务执行被中断,过长会降低系统的响应性。
锁的重试机制:加锁失败时的重试策略,如指数退避、随机延迟等,需要根据业务场景进行设计。
锁的容错性:当Redis或Zookeeper等依赖服务不可用时,需要有相应的容错措施,如降级或备用方案。
锁的监控和报警:需要对分布式锁的使用情况进行监控和报警,及时发现和解决问题。

总之,分布式锁是分布式系统中一个重要的技术点,需要结合具体的业务场景,选择合适的实现方式,并注意各种细节问题,才能设计出一个可靠、高效的分布式锁方案。

Citations: [1] https://learnku.com/articles/57086 [2] https://www.cnblogs.com/jackson0714/p/redis.html [3] https://www.cnblogs.com/crazymakercircle/p/14731826.html [4] https://blog.csdn.net/xlgen157387/article/details/79036337 [5] https://blog.csdn.net/wohu1104/article/details/123989134

Laravel-MiddleWare

Introduction to Middleware

Middleware are classes that sit between the web server and your application, allowing you to inspect and filter incoming HTTP requests before they are handled by your application. This provides a convenient way to perform tasks such as authentication, logging, CSRF protection, and more.

Middleware is a very powerful and flexible feature that can help you manage the flow of HTTP requests and responses in your application. By defining and registering middleware, you can easily add various functionalities to your application, thereby improving its security and maintainability.

Defining Middleware

In Laravel, middleware are typically defined in the app/Http/Middleware directory. A basic middleware class looks like this:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class EnsureTokenIsValid
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        if (! $request->hasValidToken()) {
            return redirect('login');
        }

        return $next($request);
    }
}

The handle method is called when the middleware is executed, and it receives the incoming $request and a $next closure that represents the next middleware in the stack.

Registering Middleware

Middleware are registered in the app/Http/Kernel.php file, which contains two main properties:

$middleware: This is the global list of middleware that should be applied to every incoming request.
$routeMiddleware: This is a list of middleware that can be dynamically assigned to routes or groups of routes.

To register a middleware, you can add it to the appropriate list:

protected $middleware = [
    // Global middleware
    \App\Http\Middleware\EnsureTokenIsValid::class,
];

protected $routeMiddleware = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'subscribed' => \App\Http\Middleware\EnsureUserIsSubscribed::class,
];

Middleware Parameters

Middleware can also accept parameters, which can be used to customize their behavior. These parameters are passed to the handle method of the middleware:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class EnsureUserHasRole
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @param  string  $role
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next, string $role)
    {
        if (! $request->user()->hasRole($role)) {
            return redirect('home');
        }

        return $next($request);
    }
}

You can then assign this middleware to a route and pass the required parameter:

Route::get('/admin', function () {
    // ...
})->middleware('role:admin');

Middleware Groups

Laravel also supports the concept of middleware groups, which allow you to group multiple middleware together and apply them to a route or group of routes. This can help you organize your middleware and make it easier to apply a common set of middleware to multiple routes.

// In app/Http/Kernel.php
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        // ...
    ],

    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

You can then apply these middleware groups to your routes:

Route::middleware('web')->group(function () {
    Route::get('/', function () {
        // ...
    });
});

Terminable Middleware

Sometimes, you may need to perform some tasks after the HTTP response has been sent to the client. For this, Laravel provides "terminable" middleware, which allows you to define logic that should be executed after the response has been sent.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class LogRequestInfo
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        $response = $next($request);

        // Log request information
        $this->logRequestInfo($request, $response);

        return $response;
    }

    /**
     * Terminate the middleware and log the request information.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Http\Response  $response
     * @return void
     */
    public function terminate($request, $response)
    {
        // Log request information
    }
}

In this example, the terminate method is called after the response has been sent to the client, allowing you to perform additional logging or cleanup tasks.

Middleware Execution Order

When a request enters your application, middleware are executed in the order they are registered in the $middleware and $routeMiddleware properties. This means that the order of middleware execution is very important, as later middleware may depend on the results of earlier middleware.

For example, if you have an authentication middleware and a CSRF protection middleware, the authentication middleware should be executed before the CSRF protection middleware. This way, the CSRF protection middleware can ensure that only authenticated users can access the protected routes.

You can control the order of middleware execution by adjusting their order in the $middleware and $routeMiddleware properties.

Middleware Inheritance

Sometimes, you may need to share some common functionality between multiple middleware. For this, you can create a base middleware class and have other middleware inherit from it.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

abstract class BaseMiddleware
{
    /**
     * Execute some common middleware logic.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        // Execute some common logic
        $this->doSomething($request);

        return $next($request);
    }

    /**
     * Execute some common operations.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     */
    protected function doSomething(Request $request)
    {
        // Execute some common operations
    }
}

Now, you can have other middleware inherit from the BaseMiddleware class and override the doSomething method to add middleware-specific logic:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class LogRequestInfo extends BaseMiddleware
{
    /**
     * Execute some LogRequestInfo middleware-specific operations.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     */
    protected function doSomething(Request $request)
    {
        // Log request information
        $this->logRequestInfo($request);
    }
}

This inheritance approach can help you better organize and manage your middleware code, and ensure that common functionality is shared across multiple middleware.

Testing Middleware

Middleware are an important part of your application, so it's crucial to test them. Laravel provides some useful tools and methods to help you test your middleware.

You can use the withoutMiddleware method in your tests to disable middleware, so that you can better isolate the behavior of the middleware:

public function testSomeEndpoint()
{
    $this->withoutMiddleware(EnsureTokenIsValid::class)
         ->get('/some-endpoint')
         ->assertStatus(200);
}

You can also use the getMiddleware method to get the list of middleware registered in your application, and ensure that your middleware are working as expected:

public function testMiddlewareIsRegistered()
{
    $kernel = $this->app->make(Kernel::class);
    $middlewareClasses = array_merge(
        $kernel->getMiddleware(),
        $kernel->getRouteMiddleware()
    );

    $this->assertContains(EnsureTokenIsValid::class, $middlewareClasses);
}

By writing unit tests and integration tests for your middleware, you can ensure that your middleware are working as expected and won't break other parts of your application.

Best Practices for Middleware

Here are some best practices for using middleware:

Keep middleware simple and focused: Each middleware should only perform a specific task. If a middleware becomes too complex, consider splitting it into multiple smaller, more focused middleware.
Pay attention to middleware execution order: Ensure that the order of middleware execution aligns with your application's requirements. Place middleware that depend on the results of previous middleware later in the stack.
Use middleware groups: Grouping related middleware can help you better organize and manage your middleware. It also makes it easier to apply a common set of middleware to multiple routes.
Write testable middleware: Ensure that your middleware are testable, so that you can verify they are working as expected and won't break other parts of your application.
Document the purpose of middleware: Write clear documentation for each middleware, explaining its purpose and expected behavior. This can help other developers better understand and use your middleware.
Consider the performance impact of middleware: Middleware add overhead to request processing, so make sure your middleware don't have a significant impact on your application's performance. If necessary, consider using caching or other optimization techniques to improve performance.

Overall, Laravel's middleware system provides a powerful and flexible way to manage the flow of HTTP requests and responses in your application. By defining and registering middleware, you can easily add various functionalities to your application, such as authentication, logging, and CSRF protection. By following best practices, you can ensure that your middleware code is high-quality, testable, and maintainable.

中间件概述

中间件是位于web服务器和应用程序之间的一层,它允许您检查和过滤进入应用程序的HTTP请求。中间件提供了一种方便的方式来执行诸如身份验证、日志记录、CSRF保护等任务。

中间件是一个非常强大和灵活的功能,它可以帮助您管理应用程序的HTTP请求和响应流。通过定义和注册中间件,您可以轻松地为应用程序添加各种功能,从而提高应用程序的安全性和可维护性。

中间件的定义

在Laravel中,中间件通常定义在app/Http/Middleware目录下。一个基本的中间件类看起来像这样:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class EnsureTokenIsValid
{
    /**
     * 处理传入的请求。
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        if (! $request->hasValidToken()) {
            return redirect('login');
        }

        return $next($request);
    }
}

handle方法在中间件执行时被调用,它接收传入的$request和表示下一个中间件的$next闭包。

中间件的注册

中间件在app/Http/Kernel.php文件中注册,该文件包含两个主要属性:

$middleware: 这是应用于每个传入请求的全局中间件列表。
$routeMiddleware: 这是一个可以动态分配给路由或路由组的中间件列表。

要注册一个中间件,您可以将其添加到适当的列表中:

protected $middleware = [
    // 全局中间件
    \App\Http\Middleware\EnsureTokenIsValid::class,
];

protected $routeMiddleware = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'subscribed' => \App\Http\Middleware\EnsureUserIsSubscribed::class,
];

中间件参数

中间件还可以接受参数,这些参数可用于自定义中间件的行为。这些参数会传递给中间件的handle方法:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class EnsureUserHasRole
{
    /**
     * 处理传入的请求。
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @param  string  $role
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next, string $role)
    {
        if (! $request->user()->hasRole($role)) {
            return redirect('home');
        }

        return $next($request);
    }
}

您可以将此中间件分配给一条路由,并传递所需的参数:

Route::get('/admin', function () {
    // ...
})->middleware('role:admin');

中间件组

Laravel还支持中间件组的概念,允许您将多个中间件分组在一起,并将它们应用于路由或路由组。这可以帮助您组织中间件,并更轻松地将一组常用的中间件应用于多个路由。

// 在app/Http/Kernel.php中
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        // ...
    ],

    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

您可以将这些中间件组应用于路由:

Route::middleware('web')->group(function () {
    Route::get('/', function () {
        // ...
    });
});

可终止的中间件

有时,您可能需要在HTTP响应发送给客户端后执行一些任务。为此,Laravel提供了"可终止"的中间件,允许您定义在响应发送后应该执行的逻辑。

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class LogRequestInfo
{
    /**
     * 处理传入的请求。
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        $response = $next($request);

        // 记录请求信息
        $this->logRequestInfo($request, $response);

        return $response;
    }

    /**
     * 终止中间件并记录请求信息。
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Http\Response  $response
     * @return void
     */
    public function terminate($request, $response)
    {
        // 记录请求信息
    }
}

在这个例子中,terminate方法在响应发送给客户端后被调用,允许您执行额外的日志记录或清理任务。

中间件的执行顺序

当一个请求进入您的应用程序时,中间件会按照它们在$middleware和$routeMiddleware属性中的注册顺序依次执行。这意味着中间件的执行顺序非常重要,因为后面的中间件可能依赖于前面中间件的结果。

例如,如果您有一个身份验证中间件和一个CSRF保护中间件,身份验证中间件应该先于CSRF保护中间件执行。这样,CSRF保护中间件就可以确保只有经过身份验证的用户才能访问受保护的路由。

您可以通过调整中间件在$middleware和$routeMiddleware属性中的顺序来控制中间件的执行顺序。

中间件的继承

有时,您可能需要在多个中间件之间共享一些通用的功能。为此,您可以创建一个基础中间件类,并让其他中间件继承自该类。

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

abstract class BaseMiddleware
{
    /**
     * 执行一些通用的中间件逻辑。
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        // 执行一些通用的逻辑
        $this->doSomething($request);

        return $next($request);
    }

    /**
     * 执行一些通用的操作。
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     */
    protected function doSomething(Request $request)
    {
        // 执行一些通用的操作
    }
}

现在,您可以让其他中间件继承自BaseMiddleware类,并重写doSomething方法来添加特定于该中间件的逻辑:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class LogRequestInfo extends BaseMiddleware
{
    /**
     * 执行一些特定于LogRequestInfo中间件的操作。
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     */
    protected function doSomething(Request $request)
    {
        // 记录请求信息
        $this->logRequestInfo($request);
    }
}

这种继承方式可以帮助您更好地组织和管理中间件代码,并确保在多个中间件之间共享通用的功能。

中间件的测试

中间件是应用程序的一个重要组成部分,因此对它们进行测试非常重要。Laravel提供了一些有用的工具和方法来帮助您测试中间件。

您可以使用withoutMiddleware方法在测试中禁用中间件,以便更好地隔离中间件的行为:

public function testSomeEndpoint()
{
    $this->withoutMiddleware(EnsureTokenIsValid::class)
         ->get('/some-endpoint')
         ->assertStatus(200);
}

您还可以使用getMiddleware方法获取应用程序中注册的中间件列表,并确保您的中间件按预期工作:

public function testMiddlewareIsRegistered()
{
    $kernel = $this->app->make(Kernel::class);
    $middlewareClasses = array_merge(
        $kernel->getMiddleware(),
        $kernel->getRouteMiddleware()
    );

    $this->assertContains(EnsureTokenIsValid::class, $middlewareClasses);
}

通过编写针对中间件的单元测试和集成测试,您可以确保您的中间件按预期工作,并且不会破坏应用程序的其他部分。

中间件的最佳实践

以下是一些使用中间件的最佳实践:

保持中间件简单和专注: 每个中间件应该只执行一个特定的任务。如果一个中间件变得太复杂,考虑将其拆分为多个更小、更专注的中间件。
注意中间件的执行顺序: 确保中间件的执行顺序符合您的应用程序需求。将依赖于前一个中间件结果的中间件放在后面执行。
使用中间件组: 将相关的中间件分组可以帮助您更好地组织和管理中间件。这也可以使您更轻松地将一组常用的中间件应用于多个路由。
编写可测试的中间件: 确保您的中间件是可测试的,这样可以帮助您确保它们按预期工作,并且不会破坏应用程序的其他部分。
记录中间件的用途: 为每个中间件编写清晰的文档,解释它的目的和预期行为。这可以帮助其他开发人员更好地理解和使用您的中间件。
考虑中间件的性能影响: 中间件会增加请求处理的开销,因此请确保您的中间件不会对应用程序的性能产生重大影响。如果需要,可以考虑使用缓存或其他优化技术来提高性能。

总之,Laravel的中间件系统提供了一种强大而灵活的方式来管理HTTP请求和响应的流程。通过定义和注册中间件,您可以轻松地为应用程序添加各种功能,如身份验证、日志记录和CSRF保护。通过遵循最佳实践,您可以确保您的中间件代码是高质量的、可测试的和可维护的。

Command Palette

PHP Cron

Laravel-CacheHelper

CacheHelper 类的详细介绍

使用示例

Laravel Queue System

Laravel Distributed Lock

Background and Needs of Distributed Locks

Implementation Methods of Distributed Locks

1. Implement Distributed Locks Based on Databases

2. Implement Distributed Locks Based on Caches (Redis)

3. Implement Distributed Locks Based on Zookeeper

Correct Implementation of Redis Distributed Locks

Considerations for Redis Distributed Locks

Other Implementation Methods of Distributed Locks

File Lock-based

Memcached-based

Etcd-based

Application Scenarios of Distributed Locks

Performance Optimization of Distributed Locks

Other Considerations for Distributed Locks

分布式锁的背景和需求

分布式锁的实现方式

1. 基于数据库实现分布式锁

2. 基于缓存(Redis)实现分布式锁

3. 基于Zookeeper实现分布式锁

Redis分布式锁的正确实现

Redis分布式锁的注意事项

分布式锁的其他实现方式

基于文件锁

基于Memcached

基于Etcd

分布式锁的应用场景

分布式锁的性能优化

分布式锁的其他注意事项

Laravel-MiddleWare

Introduction to Middleware

Defining Middleware

Registering Middleware

Middleware Parameters

Middleware Groups

Terminable Middleware

Middleware Execution Order

Middleware Inheritance

Testing Middleware

Best Practices for Middleware

中间件概述

中间件的定义

中间件的注册

中间件参数

中间件组

可终止的中间件

中间件的执行顺序

中间件的继承

中间件的测试

中间件的最佳实践

Comments

PHP

More from this blog