This chapter is from the book
This chapter is from the book
This chapter is from the book
6.5. Proxies
In the final section of this chapter, we discuss proxies. You can use a proxy to create, at runtime, new classes that implement a given set of interfaces. Proxies are only necessary when you don’t yet know at compile time which interfaces you need to implement. This is not a common situation for application programmers, and you should feel free to skip this section if you are not interested in advanced wizardry. However, for certain systems programming applications, the flexibility that proxies offer can be very important.
Suppose you want to construct an object of a class that implements one or more interfaces whose exact nature you may not know at compile time. This is a difficult problem. To construct an actual class, you can simply use the newInstance method or use reflection to find a constructor. But you can’t instantiate an interface. You need to define a new class in a running program.
To overcome this problem, some programs generate code, place it into a file, invoke the compiler, and then load the resulting class file. Naturally, this is slow, and it also requires deployment of the compiler together with the program. The proxy mechanism is a better solution. The proxy class can create brand-new classes at runtime. Such a proxy class implements the interfaces that you specify. In particular, the proxy class has the following methods:
- All methods required by the specified interfaces; and
- All methods defined in the Object class (toString, equals, and so on).
However, you cannot define new code for these methods at runtime. Instead, you must supply an invocation handler. An invocation handler is an object of any class that implements the InvocationHandler interface. That interface has a single method:
Object invoke(Object proxy, Method method, Object[] args)
Whenever a method is called on the proxy object, the invoke method of the invocation handler gets called, with the Method object and parameters of the original call. The invocation handler must then figure out how to handle the call.
To create a proxy object, use the newProxyInstance method of the Proxy class. The method has three parameters:
- A class loader. As part of the Java security model, different class loaders can be used for system classes, classes that are downloaded from the Internet, and so on. We will discuss class loaders in Chapter 9 of Volume II. For now, we specify null to use the default class loader.
- An array of Class objects, one for each interface to be implemented.
- An invocation handler.
There are two remaining questions. How do we define the handler? And what can we do with the resulting proxy object? The answers depend, of course, on the problem that we want to solve with the proxy mechanism. Proxies can be used for many purposes, such as
- Routing method calls to remote servers
- Associating user interface events with actions in a running program
- Tracing method calls for debugging purposes
In our example program, we use proxies and invocation handlers to trace method calls. We define a TraceHandler wrapper class that stores a wrapped object. Its invoke method simply prints the name and parameters of the method to be called and then calls the method with the wrapped object as the implicit parameter.
class TraceHandler implements InvocationHandler
{
private Object target;
public TraceHandler(Object t)
{
target = t;
}
public Object invoke(Object proxy, Method m, Object[] args)
throws Throwable
{
// print method name and parameters
. . .
// invoke actual method
return m.invoke(target, args);
}
}
Here is how you construct a proxy object that causes the tracing behavior whenever one of its methods is called:
Object value = . . .;
// construct wrapper
InvocationHandler handler = new TraceHandler(value);
// construct proxy for one or more interfaces
Class[] interfaces = new Class[] { Comparable.class};
Object proxy = Proxy.newProxyInstance(null, interfaces, handler);
Now, whenever a method from one of the interfaces is called on proxy, the method name and parameters are printed out and the method is then invoked on value.
In the program shown in Listing 6.9, we use proxy objects to trace a binary search. We fill an array with proxies to the integers 1 . . . 1000. Then we invoke the binarySearch method of the Arrays class to search for a random integer in the array. Finally, we print the matching element.
Object[] elements = new Object[1000];
// fill elements with proxies for the integers 1 . . . 1000
for (int i = 0; i < elements.length; i++)
{
Integer value = i + 1;
elements[i] = Proxy.newProxyInstance(. . .); // proxy for value;
}
// construct a random integer
Integer key = new Random().nextInt(elements.length) + 1;
// search for the key
int result = Arrays.binarySearch(elements, key);
// print match if found
if (result >= 0) System.out.println(elements[result]);
The Integer class implements the Comparable interface. The proxy objects belong to a class that is defined at runtime. (It has a name such as $Proxy0.) That class also implements the Comparable interface. However, its compareTo method calls the invoke method of the proxy object’s handler.
NOTE
As you saw earlier in this chapter, the Integer class actually implements Comparable<Integer>. However, at runtime, all generic types are erased and the proxy is constructed with the class object for the raw Comparable class.
The binarySearch method makes calls like this:
if (elements[i].compareTo(key) < 0) . . .
Since we filled the array with proxy objects, the compareTo calls call the invoke method of the TraceHandler class. That method prints the method name and parameters and then invokes compareTo on the wrapped Integer object.
Finally, at the end of the sample program, we call
System.out.println(elements[result]);
The println method calls toString on the proxy object, and that call is also redirected to the invocation handler.
Here is the complete trace of a program run:
500.compareTo(288) 250.compareTo(288) 375.compareTo(288) 312.compareTo(288) 281.compareTo(288) 296.compareTo(288) 288.compareTo(288) 288.toString()
You can see how the binary search algorithm homes in on the key by cutting the search interval in half in every step. Note that the toString method is proxied even though it does not belong to the Comparable interface—as you will see in the next section, certain Object methods are always proxied.
Listing 6.9. proxy/ProxyTest.java
1 package proxy;
2
3 import java.lang.reflect.*;
4 import java.util.*;
5 /**
6 * This program demonstrates the use of proxies.
7 * @version 1.00 2000-04-13
8 * @author Cay Horstmann
9 */
10 public class ProxyTest
11 {
12 public static void main(String[] args)
13 {
14 Object[] elements = new Object[1000];
15
16 // fill elements with proxies for the integers 1 ... 1000
17 for (int i = 0; i < elements.length; i++)
18 {
19 Integer value = i + 1;
20 InvocationHandler handler = new TraceHandler(value);
21 Object proxy = Proxy.newProxyInstance(null, new Class[] { Comparable.class }, handler);
22 elements[i] = proxy;
23 }
24
25 // construct a random integer
26 Integer key = new Random().nextInt(elements.length) + 1;
27
28 // search for the key
29 int result = Arrays.binarySearch(elements, key);
30
31 // print match if found
32 if (result >= 0) System.out.println(elements[result]);
33 }
34 }
35
36 /**
37 * An invocation handler that prints out the method name and parameters, then
38 * invokes the original method
39 */
40 class TraceHandler implements InvocationHandler
41 {
42 private Object target;
43
44 /**
45 * Constructs a TraceHandler
46 * @param t the implicit parameter of the method call
47 */
48 public TraceHandler(Object t)
49 {
50 target = t;
51 }
52
53 public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
54 {
55 // print implicit argument
56 System.out.print(target);
57 // print method name
58 System.out.print("." + m.getName() + "(");
59
60 // print explicit arguments
61 if (args != null)
62 {
63 for (int i = 0; i < args.length; i++)
64 {
65 System.out.print(args[i]);
66 if (i < args.length - 1) System.out.print(", ");
67 }
68 }
69 System.out.println(")");
70
71 // invoke actual method
72 return m.invoke(target, args);
73 }
74 }
6.5.1. Properties of Proxy Classes
Now that you have seen proxy classes in action, let’s go over some of their properties. Remember that proxy classes are created on the fly in a running program. However, once they are created, they are regular classes, just like any other classes in the virtual machine.
All proxy classes extend the class Proxy. A proxy class has only one instance field—the invocation handler, which is defined in the Proxy superclass. Any additional data required to carry out the proxy objects’ tasks must be stored in the invocation handler. For example, when we proxied Comparable objects in the program shown in Listing 6.9, the TraceHandler wrapped the actual objects.
All proxy classes override the toString, equals, and hashCode methods of the Object class. Like all proxy methods, these methods simply call invoke on the invocation handler. The other methods of the Object class (such as clone and getClass) are not redefined.
The names of proxy classes are not defined. The Proxy class in Oracle’s virtual machine generates class names that begin with the string $Proxy.
There is only one proxy class for a particular class loader and ordered set of interfaces. That is, if you call the newProxyInstance method twice with the same class loader and interface array, you get two objects of the same class. You can also obtain that class with the getProxyClass method:
Class proxyClass = Proxy.getProxyClass(null, interfaces);
A proxy class is always public and final. If all interfaces that the proxy class implements are public, the proxy class does not belong to any particular package. Otherwise, all non-public interfaces must belong to the same package, and the proxy class will also belong to that package.
You can test whether a particular Class object represents a proxy class by calling the isProxyClass method of the Proxy class.
This ends our final chapter on the fundamentals of the Java programming language. Interfaces and inner classes are concepts that you will encounter frequently. However, as we already mentioned, proxies are an advanced technique that is of interest mainly to tool builders, not application programmers. You are now ready to go on to learn about graphics and user interfaces, starting with Chapter 7.