* Provides an {@link java.lang.reflect.InvocationHandler} which * implements a series of accessor methods (those beginning with * {@code "get"} or {@code "is"}) using the content of a * {@link CompositeData} object. An instance of {@link CompositeData} * consists of a series of key-value mappings. This handler assumes * these keys to be the names of attributes, and thus provides * accessor methods by returning the associated value. *
** As an example, consider the following interface: *
*
* public interface Person
* {
* public String getName();
* public Date getBirthday();
* }
*
* * This specifies two accessor methods for retrieving the attributes, * {@code name} and {@code birthday}. An implementation of this interface * can be provided by creating an instance of this class, using a * {@link CompositeData} object with appropriate key-value mappings * (e.g. "name" => "Fred", "birthday" => 30/06/1974), and then passing * that to {@link java.lang.reflect.Proxy#newProxyInstance} along with * the interface itself. The invocation handler implements the methods * by calling {@link CompositeData#get(String)} with the appropriate key. *
** The attribute name is derived by taking the remainder of the method * name following {@code "get"}. If the first letter of this substring * is uppercase, then two attempts are made to retrieve the attribute * from the {@link CompositeData} instance: one using the original substring, * and one with the first letter changed to its lower-case equivalent. * If the first letter is lowercase, only the exact substring is used. *
** An {@link Object#equals(Object)} implementation is provided. This returns * true if the argument is a proxy with a {@link CompositeDataInvocationHandler} * using an equivalent {@link CompositeData} instance. {@link Object#hashCode()} * is also defined so as to match this implementation and give equivalent instances * the same hashcode. *
* * @author Andrew John Hughes (gnu_andrew@member.fsf.org) * @since 1.6 */ public class CompositeDataInvocationHandler implements InvocationHandler { /** * The {@link CompositeData} providing the key-value mappings. */ private CompositeData data; /** * Constructs a new {@link CompositeDataInvocationHandler} * with the specified {@link CompositeData} instance. * * @param data the {@link CompositeData} instance to use. * @throws IllegalArgumentException if {@code data} is {@code null}. */ public CompositeDataInvocationHandler(CompositeData data) { if (data == null) throw new IllegalArgumentException("The CompositeData instance " + "must be non-null."); this.data = data; } /** * Returns the {@link CompositeData} instance which provides * the key-value mappings for this instance. This is never * {@code null}. * * @return the {@link CompositeData} instance. */ public CompositeData getCompositeData() { return data; } /** * Called by the proxy class whenever a method is called. The * handler only deals with accessor methods (beginning with * {@code "get"} or {@code "is"}), {@code equals}, and * {@code "hashCode"}. Accessor methods are implemented by * returning the appropriate value from the {@link CompositeData} * instance, while {@code equals} and {@code hashCode} allow * two proxies with a {@link CompositeDataInvocationHandler} using * the same {@link CompositeData} instance to be classified * as equivalent. * * @param proxy the proxy on which the method was called. * @param method the method which was called. * @param args the arguments supplied to the method. * @return the return value from the method. * @throws Throwable if an exception is thrown in the process. */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String mName = method.getName(); if (mName.equals("equals")) { if (args[0] instanceof Proxy) { InvocationHandler h = Proxy.getInvocationHandler(args[0]); if (h instanceof CompositeDataInvocationHandler) return data.equals(((CompositeDataInvocationHandler) h).getCompositeData()); } return false; } if (mName.equals("hashCode")) { return data.hashCode(); } String attrib = null; if (mName.startsWith("get")) attrib = mName.substring(3); else if (mName.startsWith("is")) attrib = mName.substring(2); if (attrib == null) throw new NoSuchMethodException(mName + " is not an accessor."); if (!data.containsKey(attrib)) { if (Character.isLowerCase(attrib.charAt(0))) throw new NoSuchMethodException("The attribute " + attrib + " is not available " + "in the given CompositeData " + "object"); attrib = Character.toLowerCase(attrib.charAt(0)) + attrib.substring(1); if (!data.containsKey(attrib)) throw new NoSuchMethodException("The attribute " + attrib + " is not available " + "in the given CompositeData " + "object"); } return data.get(attrib); } }