Analysis of the running process of PHP container Pimple

This article mainly introduces the analysis of the running process of PHP container Pimple, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

Required knowledge points

Closure

Closures and anonymous functions were introduced in PHP5.3.0.

A closure refers to a function that encapsulates the surrounding state when created. Even if the environment in which the closure is located no longer exists, the state encapsulated in the closure still exists.

Theoretically, closures and anonymous functions are different concepts. But PHP treats it as the same concept.
Actually, closures and anonymous functions are objects disguised as functions. They are instances of the Closure class.

Closures, like strings and integers, are first-class value types.

Create closure:

<?php
$closure = function ($name) {
    return &#39;Hello &#39; . $name;
};
echo $closure(&#39;nesfo&#39;);//Hello nesfo
var_dump(method_exists($closure, &#39;__invoke&#39;));//true

The reason why we can call the $closure variable is because the value of this variable is a closure, and the closure object implements__invoke()Magic method. As long as there is () after the variable name, PHP will find and call the __invoke() method.

Usually PHP closures are used as callbacks of functions.

array_map(), preg_replace_callback() methods all use callback functions. This is the best time to use closures!

For example:

<?php
$numbersPlusOne = array_map(function ($number) {
    return $number + 1;
}, [1, 2, 3]);
print_r($numbersPlusOne);

Get the result:

[2, 3, 4]

Before closures appeared, you could only create named functions individually and then reference that function by name. By doing this, the code execution will be slightly slower, and the implementation of the callback will be isolated from the usage scenario.

<?php
function incrementNum ($number) {
    return $number + 1;
}

$numbersPlusOne = array_map(&#39;incrementNum&#39;, [1, 2, 3]);
print_r($numbersPlusOne);

SPL

ArrayAccess

Implementing the ArrayAccess interface allows objects to operate like arrays. The ArrayAccess interface contains four methods that must be implemented:

interface ArrayAccess {
    //检查一个偏移位置是否存在 
    public mixed offsetExists ( mixed $offset  );
    
    //获取一个偏移位置的值 
    public mixed offsetGet( mixed $offset  );
    
    //设置一个偏移位置的值 
    public mixed offsetSet ( mixed $offset  );
    
    //复位一个偏移位置的值 
    public mixed offsetUnset  ( mixed $offset  );
}

SplObjectStorage

The SplObjectStorage class implements a map with objects as keys or a collection of objects (if the object corresponding to the key is ignored data) this data structure. An instance of this class is much like an array, but the objects it stores are all unique. Another feature of this class is that you can directly delete the specified object from it without traversing or searching the entire collection.

::classSyntax

Because ::class represents a string. The advantage of using ::class is that you can directly rename a class in the IDE, and then the IDE will automatically handle the related references.
At the same time, when PHP executes the relevant code, it will not load the relevant class first.

Similarly, automated code inspection inspect can also correctly identify classes.

A brief analysis of Pimple container process

Pimpl is a popular container in the PHP community. There is not a lot of code, see https://github.com/silexphp/P... for details.

Our application can be developed based on Pimple:

namespace EasyWeChat\Foundation;

use Pimple\Container;

class Application extends Container
{
    /**
     * Service Providers.
     *
     * @var array
     */
    protected $providers = [
        ServiceProviders\ServerServiceProvider::class,
        ServiceProviders\UserServiceProvider::class
    ];

    /**
     * Application constructor.
     *
     * @param array $config
     */
    public function __construct($config)
    {
        parent::__construct();

        $this['config'] = function () use ($config) {
            return new Config($config);
        };

        if ($this['config']['debug']) {
            error_reporting(E_ALL);
        }

        $this->registerProviders();
    }

    /**
     * Add a provider.
     *
     * @param string $provider
     *
     * @return Application
     */
    public function addProvider($provider)
    {
        array_push($this->providers, $provider);

        return $this;
    }

    /**
     * Set providers.
     *
     * @param array $providers
     */
    public function setProviders(array $providers)
    {
        $this->providers = [];

        foreach ($providers as $provider) {
            $this->addProvider($provider);
        }
    }

    /**
     * Return all providers.
     *
     * @return array
     */
    public function getProviders()
    {
        return $this->providers;
    }

    /**
     * Magic get access.
     *
     * @param string $id
     *
     * @return mixed
     */
    public function __get($id)
    {
        return $this->offsetGet($id);
    }

    /**
     * Magic set access.
     *
     * @param string $id
     * @param mixed  $value
     */
    public function __set($id, $value)
    {
        $this->offsetSet($id, $value);
    }
}

How to use our application:

$app = new Application([]);
$user = $app->user;

After that we can use the method of the $user object . We found that there is no $this->user attribute, but it can be used directly. Mainly the role of these two methods:

public function offsetSet($id, $value){}
public function offsetGet($id){}

Below we will explain what Pimple does when executing these two lines of code. But before explaining this, let’s look at some core concepts of containers.

Service provider

The service provider is the bridge connecting the container and the specific function implementation class. Service providers need to implement the interface ServiceProviderInterface:

namespace Pimple;

/**
 * Pimple service provider interface.
 *
 * @author  Fabien Potencier
 * @author  Dominik Zogg
 */
interface ServiceProviderInterface
{
    /**
     * Registers services on the given container.
     *
     * This method should only be used to configure services and parameters.
     * It should not get services.
     *
     * @param Container $pimple A container instance
     */
    public function register(Container $pimple);
}

All service providers must implement the interface register method.

There are 2 service providers by default in our application:

protected $providers = [
    ServiceProviders\ServerServiceProvider::class,
    ServiceProviders\UserServiceProvider::class
];

Taking UserServiceProvider as an example, we look at its code implementation:

namespace EasyWeChat\Foundation\ServiceProviders;

use EasyWeChat\User\User;
use Pimple\Container;
use Pimple\ServiceProviderInterface;

/**
 * Class UserServiceProvider.
 */
class UserServiceProvider implements ServiceProviderInterface
{
    /**
     * Registers services on the given container.
     *
     * This method should only be used to configure services and parameters.
     * It should not get services.
     *
     * @param Container $pimple A container instance
     */
    public function register(Container $pimple)
    {
        $pimple['user'] = function ($pimple) {
            return new User($pimple['access_token']);
        };
    }
}

We see that this service provides The user's registration method will add the attribute user to the container, but what is returned is not an object, but a closure. I will explain this later.

Service registration

We use $this->registerProviders(); in the constructor of Application to register all service providers:

private function registerProviders()
{
    foreach ($this->providers as $provider) {
        $this->register(new $provider());
    }
}

Looking carefully, we find that the service provider is instantiated here and the register method of the container Pimple is called:

public function register(ServiceProviderInterface $provider, array $values = array())
{
    $provider->register($this);

    foreach ($values as $key => $value) {
        $this[$key] = $value;
    }

    return $this;
}

And here the register of the service provider is called method, which is what we mentioned in the previous section: the registration method adds attributes user to the container, but it returns not an object, but a closure.

When we add attributes user to the container Pimple, the offsetSet($id, $value) method will be called: values ​​to the attributes of the container Pimple , keys are assigned respectively:

$this->values[$id] = $value;
$this->keys[$id] = true;

Up to this point, we have not instantiated the class EasyWeChat\User\Usr that actually provides actual functions. However, the service provider registration has been completed.

When we run here:

$user = $app->user;

will call offsetGet($id) and instantiate the real class:

$raw = $this->values[$id];
$val = $this->values[$id] = $raw($this);
$this->raw[$id] = $raw;

$this->frozen[$id] = true;

return $val;

$raw obtains the closure:

$pimple['user'] = function ($pimple) {
    return new User($pimple['access_token']);
};

$raw($this) returns the instantiated object User. That is to say, only the actual call will instantiate the specific class. Later we can call methods in the User class through $this['user'] or $this->user.

Of course, there are many features in Pimple that are worthy of our in-depth study, so we won’t explain them too much here.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

How to use wp_head() function in wordpress

Scope, global, static of PHP variables Wait for keywords

The above is the detailed content of Analysis of the running process of PHP container Pimple. For more information, please follow other related articles on the PHP Chinese website!