Question

在以下示例中，来自wiki books https://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy

我不确定这比仅创建真实对象和使用显示图像更快/更有效。因为代理在displayImage方法中创建了真实对象吗？

//on System B
    class ProxyImage implements Image {

        private RealImage image = null;
        private String filename = null;
        /**
         * Constructor
         * @param FILENAME
         */
        public ProxyImage(final String FILENAME) {
            filename = FILENAME;
        }

        /**
         * Displays the image
         */
        public void displayImage() {
            if (image == null) {
               image = new RealImage(filename);
            }
            image.displayImage();
        }

    }

当然，代理模式不会节省内存，因为它需要实例化两个对象（代理和真实）而不是一个（真实的）如果你没有使用代理？

Answer 1

从您发布的链接（强调我的）：

代理类ProxyImage正在另一个系统上运行而不是真实的图像类本身，并且可以代表那里的真实图像RealImage。从磁盘访问图像信息。使用代理模式，ProxyImage 的代码可以避免多次加载图像，以节省内存的方式从其他系统访问它。

简而言之：它不会节省内存，它会加速应用程序，因为每次都不需要访问磁盘来读取真实图像。

这部分代码证明了这一点：

public void displayImage() {
    //if image is not loaded into memory
    if (image == null) {
        //then load it, go to disk only once
        image = new RealImage(filename);
    }
    //now it is in memory, display the real image
    image.displayImage();
}

为了更好地理解这个问题，让我们改变类和接口的定义：

public interface Image {
    String getName();
    byte[] getData();
}

现在，RealImage类将始终在磁盘中寻找数据，以防文件不存在（已删除或重命名）：

public class RealImage implements Image {
    //implements all the operations going to disk...
    private String fileName;
    public RealImage(String fileName) {
        this.fileName = fileName;
    }
    @Override
    public String getName() {
        String name = "";
        //fancy operations to seek for the file in disk (in case it has been deleted)
        //read the data from file in disk
        //get the name
        name = ...;
        return name;
    }
    @Override
    public byte[] getData() {
        byte[] data;
        //again, fancy operations to seek for the file in disk (in case it has been deleted)
        //read the data from file in disk
        //get the image data for displaying purposes
        data = ...;
        return data;
    }
}

现在，我们的好ProxyImage将作为RealImage的代理，通过将数据保存到内存中来节省每次进入磁盘的高成本任务：

public class ProxyImage implements Image {
    private String fileName;
    private RealImage realImage;
    private byte[] data;
    private String name;
    //implements all the operations going to disk...
    public RealImage(String fileName) {
        this.fileName = fileName;
    }
    @Override
    public String getName() {
        //in case we don't have the name of the image
        if (this.name == null) {
            //use a RealImage to retrieve the image name
            //we will create the instance of realImage only if needed
            if (realImage == null) {
                realImage = new RealImage(fileName);
            }
            //getting the image from the real image is highly costly
            //so we will do this only once
            this.name = realImage.getName();
        }
        return this.name;
    }
    @Override
    public byte[] getData() {
        //similar behavior for the data of the image
        if (this.data == null) {
            if (realImage == null) {
                realImage = new RealImage(fileName);
            }
            //highly costly operation
            this.data = realImage.getData();
        }
        return this.data;
    }
}

因此反映了我们RealImage使用代理的好东西。

Answer 2

此特定代理的目的似乎是实现所谓的“延迟加载”。＆＃39;它实际上并没有读取文件并在内存中创建图像，直到其他一些代码实际上试图显示它。与将图像放入永不使用的内存相比，这可以节省大量的时间和内存！

在小例子中，它很容易思考＆＃34;我可以只是编程聪明，而不是加载愚蠢的东西。＆＃34;但是想象一个更大的系统，你会遇到一个以List<Image>为参数的API，但实际上只有当用户点击文件名或其他东西时才会绘制一个。这可能是一个重要的推动力。

代理模式：如何比创建真实对象更有效？

2 个答案: