动态与延迟加载

Question

我只知道动态代理用于AOP。
但是，它似乎也可以用于延迟加载。
以下文章中的示例旨在证明这一点。
但是，我不明白这与普通的访问器有何不同，这里到底是“懒惰”加载了什么？
感谢您对理解作者打算通过延迟加载表示的任何帮助。

private Category tupleToObject(Serializable[] tuple) {    
    Category category = new Category((String)tuple[1],
        (YearMonthDay) tuple[2]);
        category.setId((Long) tuple[0]);
    category.setParent(lazyGet((Long) tuple[3]));
    return category;
}


protected CategoryItf lazyGet(Long id) {    
    if (id == null) {        
    return null;    
    }    
    return (CategoryItf)Proxy.newProxyInstance( 
        CategoryItf.class.getClassLoader(),
        new Class[] { CategoryItf.class },
        new LazyLoadedObject() {
            protected Object loadObject() {
                return get(id);
            }        
    });
}


public abstract class LazyLoadedObject    implements InvocationHandler {
    private Object target;
    public Object invoke(Object proxy,
                         Method method, Object[] args)
                  throws Throwable {
        if (target == null) {
            target = loadObject();
        }
        return method.invoke(target, args);
    }
    protected abstract Object loadObject();
}

这与以下内容有何不同：

private Category tupleToObject(Serializable[] tuple) {    
    Category category = new Category((String)tuple[1],
        (YearMonthDay) tuple[2]);
        category.setId((Long) tuple[0]);
    category.setParent(get((Long) tuple[3]));
    return category;
}

在这两种情况下，仅在需要时才创建父对象。

Answer 1

以下代码段使实现“懒惰”：

private Object target;
public Object invoke(Object proxy,
                     Method method, Object[] args)
              throws Throwable {
    if (target == null) {
        target = loadObject();
    }

您可以看到，无论您调用此代码多少次，每次都会得到相同的对象。 因此，实际上是单例。 但是，它不是在程序开始时创建的，而仅在第一次需要它时才创建。 这就是“懒惰”的意思。

Answer 2

让我尝试从我对代码的理解中进行解释：

在此代码中：

private Category tupleToObject(Serializable[] tuple) {    
    Category category = new Category((String)tuple[1],
        (YearMonthDay) tuple[2]);
        category.setId((Long) tuple[0]);
    category.setParent(get((Long) tuple[3]));
    return category;
}

get()方法将直接返回实际对象，因此调用tupleToObject()将使用实际对象填充父类。

在这段代码中：

private Category tupleToObject(Serializable[] tuple) {    
    Category category = new Category((String)tuple[1],
        (YearMonthDay) tuple[2]);
        category.setId((Long) tuple[0]);
    category.setParent(lazyGet((Long) tuple[3]));
    return category;
}

lazyGet()方法实际上返回一个代理（不是实际的对象）。 代理上的第一个方法调用实际上将触发对象的加载。 这里的代理用于将实际对象的实际检索延迟到其实际需要之前，即延迟加载 。

希望这能回答您的问题。