Brief analysis of Pimple running process (PHP container)

Required knowledge points

Closure

Closed Packages and anonymous functions were introduced in PHP5.3.0.

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.

In fact, 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 the __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

implements the ArrayAccess interface, which 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

SplObjectStorage class implements a map with objects as keys or A data structure that is a collection of objects (if you ignore the data corresponding to the object as the key). 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/Pimple/blob/master/src/Pimple/Container.php 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 attribute $this->user, 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 between the container and the specific function implementation class. Service providers need to implement the interfaceServiceProviderInterface:

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, let’s 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']);
        };
    }
}

us As you can see, the service provider'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 in Application All service providers are registered:

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 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 the service provider is called here The register method of the user is what we mentioned in the previous section: the registration method adds the attribute user to the container, but it returns not an object, but a closure.

When we add the attribute user to the container Pimple, we will call the offsetSet($id, $value) method: give the attribute values ​​to the container Pimple , keys are assigned values ​​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 gets the closure:

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

$raw($this)返回的是实例化的对象User。也就是说只有实际调用才会去实例化具体的类。后面我们就可以通过$this['user']或者$this->user调用User类里的方法了。

当然，Pimple里还有很多特性值得我们去深入研究，这里不做过多讲解。

更多相关php知识，请访问php教程！

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