Implementation code for lazy loading through virtual proxy in php

This thing was learned from Martin's "Enterprise Application Architecture Patterns". It assists the characteristics of PHP dynamic language and can implement lazy loading (LazyLoad) much easier than Java. The basic principle is to use a virtual proxy (Virtual Proxy) as a placeholder. Once a member (method or attribute) of the proxy object is accessed, the loading is triggered.

However, the version I implemented has limitations:

It is only applicable to objects and cannot proxy basic data types such as arrays (it needs to be encapsulated with built-in objects such as ArrayObject)
After being proxied, some interfaces with operator overloading properties The implementation becomes invalid, such as the indexer of ArrayAccess and the iterator of Itreator. If you use this proxy to handle lazy loading of collection types, you need to inherit a subclass for special processing so that external foreach iteration can be used
demo
Copy code Code As follows:
// Test
$v = new VirtualProxy(function(){
echo 'Now, Loading', "n";
$a = new ArrayObject(range(1,100));
$a->abc = 'a';
// In actual use, the findXXX method of DataMapper is called here
// What is returned is a collection of domain objects
return $a;
});
// The proxy object is directly accessed as the original object
/ / At this time, the callback function passed in the constructor is called
// To achieve the delay of loading the object operation
echo $v->abc . $v->offsetGet(50);

Virtual Proxy
Copy code The code is as follows:
/**
* Virtual proxy, the closure function is called to generate the target object only when the member is accessed.
*
* @author tonyseek
*
*/
class VirtualProxy
{
private $holder = null;
private $loader = null;

/**
* Virtual proxy, the closure function is called to generate the target object only when the member is accessed.
*
* @param Closure $loader Generates the closure function of the proxy object
*/
public function __construct(Closure $loader)
{
$this->loader = $loader;
}

/**
* Call of proxy member method
*
* @param string $method
* @param array $arguments
* @throws BadMethodCallException
* @return mixed
*/
public function __call($method, array $arguments = null)
{
$this->check() ;

if (!method_exists($this->holder, $method)) {
throw new BadMethodCallException();
}

return call_user_func_array(
array(&$this->holder, $method),
$arguments);
}

/**
* Reading of proxy member properties
*
* @param string $property
* @throws ErrorException
* @return mixed
*/
public function __get($property)
{
$this->check();

if (!isset($this->holder- >$property)) {
throw new ErrorException();
}

return $this->holder->$property;
}

/**
* Assignment of proxy member properties
*
* @param string $property
* @param mixed $value
*/
public function __set($property , $value)
{
$this->check();

$this->holder->$property = $value;
}

/**
* Check whether the proxy object already exists, and generate it if it does not exist.
*/
private function check( )
{
if (null == $this->holder) {
$loader = $this->loader;
$this->holder = $loader();
}
}
}