延迟加载模式：别让程序“未老先胖”

说实话，我见过太多系统，一启动就加载所有数据，结果内存爆了，用户等得直骂娘。这种“全都要”的思维，在小型项目里还能忍，一旦数据量上来，立马崩给你看。

延迟加载（Lazy Load）就是专门治这个毛病的。它的核心思想很简单：不到万不得已，绝不加载。你想想看，用户打开一个页面，可能根本不会点那个“查看详情”按钮，你干嘛提前把详情数据塞进内存？

四种实现方式，各有各的玩法

延迟加载不是一种固定的写法，而是有四种常见套路。我在不同项目里都用过，每种都有它的适用场景。

1. 延迟初始化（Lazy Initialization）

这是最直接的方式。对象一开始是null，第一次访问时才创建。我早期做Java桌面应用时，经常这么干。

// Java 示例
public class HeavyObject {
    private ExpensiveResource resource = null;
    
    public ExpensiveResource getResource() {
        if (resource == null) {
            resource = new ExpensiveResource(); // 真正创建
        }
        return resource;
    }
}

嗯，这里要注意：多线程环境下，这个写法有坑。两个线程同时调用getResource()，可能会创建两个实例。我建议用双重检查锁定（Double-Checked Locking）或者直接上Java的LazyHolder模式。

2. 虚拟代理（Virtual Proxy）

虚拟代理是代理模式的一种变体。它看起来跟真实对象一样，但内部其实是个“空壳子”。只有当你真正调用它的方法时，它才去加载真实对象。

// Java 示例：虚拟代理
public interface Image {
    void display();
}

public class RealImage implements Image {
    private String filename;
    
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(); // 很重的操作
    }
    
    public void display() {
        System.out.println("Displaying " + filename);
    }
}

public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;
    
    public ProxyImage(String filename) {
        this.filename = filename;
    }
    
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename); // 延迟加载
        }
        realImage.display();
    }
}

说白了，虚拟代理就是个“替身”。用户以为自己在操作真实对象，其实操作的是代理。代理在背后偷偷帮你完成真正的加载工作。

3. 值持有者（Value Holder）

这个模式在C++里用得比较多。它本质上是一个包装类，内部持有一个值，但只有第一次访问时才去计算或加载这个值。

// C++ 示例：值持有者
template<typename T>
class ValueHolder {
private:
    T* value;
    bool loaded;
    
public:
    ValueHolder() : value(nullptr), loaded(false) {}
    
    T& get() {
        if (!loaded) {
            value = new T(); // 延迟创建
            loaded = true;
        }
        return *value;
    }
    
    ~ValueHolder() {
        delete value;
    }
};

我个人习惯把值持有者用在配置加载的场景。系统启动时只加载基础配置，那些高级功能配置，等用户真正用到时才去加载。这样启动速度能快好几倍。

4. 幽灵对象（Ghost Object）

幽灵对象有点意思。它跟虚拟代理不同——幽灵对象本身是真实对象，但只加载了部分数据（比如ID和名称）。当你访问其他属性时，它才去数据库把剩余数据补全。

// Java 示例：幽灵对象
public class GhostUser {
    private Long id;
    private String name;
    private String email;      // 延迟加载
    private String address;    // 延迟加载
    private boolean loaded = false;
    
    public GhostUser(Long id, String name) {
        this.id = id;
        this.name = name; // 只加载了基本数据
    }
    
    public String getEmail() {
        if (!loaded) {
            loadFullData(); // 从数据库补全
        }
        return email;
    }
    
    private void loadFullData() {
        // 执行SQL查询，补全email、address等字段
        loaded = true;
    }
}

Hibernate中的懒加载：实战中的典范

说到延迟加载，不得不提Hibernate。它把这四种方式都用到了极致。你想想看，ORM框架面对的是数据库，一个实体可能关联着几十张表，如果全加载，那还得了？

Hibernate的懒加载主要通过代理对象实现。当你调用session.get()时，它返回的其实是一个代理对象。只有当你真正访问某个属性时，它才去发SQL查询。

// Hibernate 懒加载示例
@Entity
public class Order {
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY) // 懒加载
    private Customer customer;
    
    @OneToMany(fetch = FetchType.LAZY) // 懒加载
    private List<OrderItem> items;
}

这里有个经典问题：LazyInitializationException。为什么会这样？因为Hibernate的Session关闭后，代理对象就无法再访问数据库了。我曾经在项目里遇到过，一个Service方法返回了实体对象，但事务已经提交了，Session也关了。前端一调用getItems()，直接抛异常。

一张图看懂延迟加载

下面这张图展示了延迟加载的核心流程。你可以看到，客户端请求数据时，代理对象先检查数据是否已加载。如果没加载，就去数据库或工厂获取；如果已加载，直接返回缓存的结果。

什么时候该用，什么时候别用

延迟加载不是银弹。我见过有人滥用它，结果系统性能反而更差。这里我总结了几条经验：

场景	推荐使用	原因
对象创建成本高，但使用频率低	✅ 强烈推荐	避免不必要的资源消耗
对象创建成本低，但使用频率高	❌ 不推荐	延迟加载反而增加代理开销
数据量大，但只显示部分	✅ 推荐	分页+懒加载，性能最优
需要频繁访问所有属性	❌ 不推荐	提前加载更高效
多线程环境	⚠️ 谨慎使用	需要处理线程安全问题

最后说一句：延迟加载是个好工具，但别滥用。每次加懒加载之前，先问问自己——这个数据真的需要延迟吗？如果答案是肯定的，那就大胆用。如果只是“可能用不到”，那还是老老实实提前加载吧。

---

公众号:蓝海资料掘金营，微信deep3321