Virtual proxy implements lazy loading

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:

1. Only applicable to objects, cannot proxy basic data types such as arrays (need to be encapsulated by built-in objects such as ArrayObject)
2. After being proxied, some interface implementations with operator overloading properties become invalid, such as the indexer of ArrayAccess and the iterator of Itreator. If the proxy is used to handle lazy loading of collection types, a subclass needs to be inherited to do special Processed so that it can be iterated externally using foreach

See my blog for details: http://tonyseek.tumblr.com/post/6166066775/virtual-proxy-lazy-load

// 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 by the constructor is called
// To achieve the delay of loading object operation
echo $v->abc . $v->offsetGet(50);

/**
 * 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();
 }
 }
}