Implementation code for lazy loading through virtual proxy in php_PHP tutorial

This thing was learned from Martin's "Enterprise Application Architecture Patterns". It assists the characteristics of PHP's 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:

is only applicable to objects and cannot proxy basic data types such as arrays (needs to be encapsulated with built-in objects such as ArrayObject)
is proxied After that, some interface implementations with operator overloading properties became invalid, such as the indexer of ArrayAccess and the iterator of Itreator. If you use this proxy to handle delayed loading of collection types, you need to inherit a subclass for special processing so that Externally use foreach to iterate
demo

Copy code The code is 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 the domain object collection
return $a;
});
// The proxy object is directly used as The original object is accessed
// At this time, the callback function passed in by 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();
}
}
}

http://www.bkjia.com/PHPjc/323536.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/323536.htmlTechArticleThis thing was learned from Martin’s "Enterprise Application Architecture Pattern" to assist the characteristics of PHP dynamic language. Lazy Load can be implemented much easier than Java. Basically the original...