当前位置：首页 > PHP

php实现惰性加载

2026-03-13 06:18:24PHP

PHP 惰性加载的实现方法

惰性加载（Lazy Loading）是一种延迟加载资源的策略，直到真正需要时才进行加载。在 PHP 中，惰性加载常用于优化性能，减少不必要的资源消耗。

使用魔术方法 __get()

通过 __get() 魔术方法可以在访问未初始化的属性时动态加载资源。

class LazyLoader {
    private $data = null;

    public function __get($property) {
        if ($property === 'data' && $this->data === null) {
            $this->data = $this->loadExpensiveData();
        }
        return $this->data;
    }

    private function loadExpensiveData() {
        // 模拟耗时操作
        sleep(2);
        return "Loaded data";
    }
}

$loader = new LazyLoader();
echo $loader->data; // 只在第一次访问时加载

使用闭包实现延迟初始化

将初始化逻辑封装在闭包中，只有在需要时才执行。

class LazyClosure {
    private $loader;

    public function __construct(callable $loader) {
        $this->loader = $loader;
    }

    public function get() {
        if (is_callable($this->loader)) {
            $this->loader = call_user_func($this->loader);
        }
        return $this->loader;
    }
}

$lazy = new LazyClosure(function() {
    sleep(1);
    return "Closure-based lazy data";
});
echo $lazy->get();

代理模式实现惰性加载

通过代理对象控制对实际对象的访问。

interface ExpensiveObject {
    public function process();
}

class RealExpensiveObject implements ExpensiveObject {
    public function process() {
        echo "Processing expensive operation\n";
    }
}

class ProxyObject implements ExpensiveObject {
    private $realObject = null;

    public function process() {
        if ($this->realObject === null) {
            $this->realObject = new RealExpensiveObject();
        }
        $this->realObject->process();
    }
}

$proxy = new ProxyObject();
$proxy->process(); // 实际对象只在第一次调用时创建

PSR-11 容器中的惰性加载

现代 PHP 框架通常通过依赖注入容器实现惰性加载。

use Psr\Container\ContainerInterface;

class LazyServiceContainer implements ContainerInterface {
    private $services = [];
    private $factories = [];

    public function get($id) {
        if (!isset($this->services[$id]) && isset($this->factories[$id])) {
            $this->services[$id] = $this->factories[$id]($this);
        }
        return $this->services[$id];
    }

    public function has($id) {
        return isset($this->factories[$id]);
    }

    public function set($id, callable $factory) {
        $this->factories[$id] = $factory;
    }
}

$container = new LazyServiceContainer();
$container->set('expensive', function() {
    sleep(2);
    return new stdClass();
});

$obj = $container->get('expensive'); // 只在第一次获取时初始化

数据库查询的惰性加载

对于 ORM 框架，可以实现关联关系的惰性加载。

php实现惰性加载

class User {
    private $posts = null;

    public function getPosts() {
        if ($this->posts === null) {
            $this->posts = $this->loadPosts();
        }
        return $this->posts;
    }

    private function loadPosts() {
        // 模拟数据库查询
        return ['Post 1', 'Post 2'];
    }
}

$user = new User();
print_r($user->getPosts()); // 只在调用时加载