In this example program, we create a simple program to display an image on a JPanel when it is loaded. Rather than loading the image directly, we use a class we call ImageProxy to defer loading and draw a rectangle around the image area until loading is completed.

public class ProxyDisplay extends JxFrame {
    public ProxyDisplay() {
        super("Display proxied image");
        JPanel p = new JPanel();
        getContentPane().add(p);
        p.setLayout(new BorderLayout());
        ImageProxy image = new ImageProxy("elliott.jpg", 321, 271);

        p.add("Center", image);
        p.add("North", new Label("      "));
        p.add("West", new Label("    "));
        setSize(370, 350);
        setVisible(true);
    }

Note that we create the instance of the Image Proxy just as we would have for an Image and that we add it to the enclosing JPanel as we would an actual image.

The ImageProxy class sets up the image loading and creates a MediaTracker object to follow the loading process within the constructor.

public class ImageProxy extends JPanel
implements Runnable {
    private int height, width;
    private MediaTracker tracker;
    private Image img;
    private JFrame frame;
    private Thread imageCheck;     //to monitor loading
//-----------------
    public ImageProxy(String filename, int w, int h) {
        height = h;
        width = w;

        tracker = new MediaTracker(this);
        img =
            Toolkit.getDefaultToolkit().
            getImage(filename);
    tracker.addImage(img, 0);       //watch for image loading

        imageCheck = new Thread(this);
        imageCheck.start();        //start 2nd thread monitor

        //this begins actual image loading
        try {
            tracker.waitForID(0,1);
        } catch (InterruptedException e) {
        }
    }

The waitForID method of the MediaTracker actually initiates loading. In this case, we put in a minimum wait time of 1 millisecond so that we can minimize apparent program delays.

The constructor also creates a separate thread imageCheck that checks the loading status every few milliseconds and then starts that thread running.

public void run() {
        /**this thread monitors image loading
        and repaints when done
        the 1000 millisecond is artificially long
        to allow the demo to display with a delay*/
        try {
            Thread.sleep(1000);
            while (! tracker.checkID(0))
                Thread.sleep(1000);
        } catch (Exception e) {
        }
        repaint ();
    }

For the purposes of this illustration program, we slowed the polling time down to 1 second so that we can see the program draw the rectangle and then refresh the final image.

Finally, the Proxy is derived from the JPanel component and therefore has a paint method. In this method, we draw a rectangle if the image is not loaded. If the image has been loaded, we erase the rectangle and draw the image.

public void paint(Graphics g) {
        if (tracker.checkID(0)) {
            height = img.getHeight(frame);//get height
            width = img.getWidth(frame);  //and width

            getsetColor(Color.lightGray); //erase box
            g.fillRect(0,0, width, height);
            g.drawImage(img, 0, 0, this); //draw image
        } else {
            //draw box outlining image if not loaded yet
            g.setColor(Color.black);
            g.drawRect(1, 1, width-2, height-2);
        }
    }

The program's two states are illustrated in Figure 15.1.

Figure 15.1. The proxy image display on the left is shown until the image on the right loads.

You can also use Proxies to keep copies of large objects that may or may not change. If you create a second instance of an expensive object, a Proxy can decide that a copy is not needed yet, so it simply uses the original object. Then, if the program makes a change in the new copy, the Proxy can copy the original object and make the change in the new instance. This can save time and space when objects do not always change after they are instantiated.

Enterprise Java Beans (EJB) are a set of classes and interfaces for writing well-encapsulated server code. They are not at all related to the Java Beans you use in client GUI programs. However, they do supply a convenient approach for accessing databases and other legacy data systems.

Each time you request a line of data from a database, you are making a new connection to an EJB. Clearly, there are a limited number of these connections available, so the remaining requests are cached within the Bean and a Proxy to the connection that eventually becomes the connection when one becomes available is returned.

Both the Adapter and the Proxy patterns constitute a thin layer around an object. However, the Adapter provides a different interface for an object, whereas the Proxy provides the same interface for the object but interposes itself where it can postpone processing or data transmission effort.

A Decorator also has the same interface as the object that it surrounds, but its purpose is to add additional (sometimes visual) function to the original object. A Proxy, by contrast, controls access to the contained class.

Following is a summary of the Structural patterns: