docs: public Object invoke(Object proxy, Method method, Object[] args)
  	{
  		Object subject;
  		String methodName = method.getName();
  
  		try
  		{
  			// [andrew clute]
  			// short-circuit any calls to a finalize methjod if the subject
  			// has not been retrieved yet
  			if ("finalize".equals(methodName) && _realSubject == null)
  			{
  				return null;
  			}
  
  			// [andrew clute]
  			// When trying to serialize a proxy, we need to determine how to
  			// handle it
  			if ("writeReplace".equals(methodName))
  			{
  				if (_realSubject == null)
  				{
  					// Unmaterialized proxies are replaced by simple
  					// serializable
  					// objects that can be unserialized without classloader
  					// issues
  					return generateSerializableProxy();
  				} else
  				{
  					// Materiliazed objects should be passed back as they might
  					// have
  					// been mutated
  					return getRealSubject();
  				}
  			}
  
  			// [tomdz]
  			// Previously the hashcode of the identity would have been used
  			// but this requires a compatible hashCode implementation in the
  			// proxied object (which is somewhat unlikely, even the default
  			// hashCode implementation does not fulfill this requirement)
  			// for those that require this behavior, a custom indirection
  			// handler can be used, or the hashCode of the identity
  			/*
  			 * if ("hashCode".equals(methodName)) { return new
  			 * Integer(_id.hashCode()); }
  			 */
  
  			// [tomdz]
  			// this would handle toString differently for non-materialized
  			// proxies
  			// (to avoid materialization due to logging)
  			// however toString should be a normal business method which
  			// materializes the proxy
  			// if this is not desired, then the ProxyHandler.toString(Object)
  			// method
  			// should be used instead (e.g. for logging within OJB)
  			/*
  			 * if ((realSubject == null) && "toString".equals(methodName)) {
  			 * return "unmaterialized proxy for " + id; }
  			 */
  
  			// BRJ: make sure that the object to be compared is a real object
  			// otherwise equals may return false.
  			if ("equals".equals(methodName) && args[0] != null)
  			{
                  TemporaryBrokerWrapper tmp = getBroker();
                  try
                  {
                      args[0] = tmp.broker.getProxyFactory().getRealObject(args[0]);
                  }
                  finally
                  {
                      tmp.close();
                  }
              }
  
  			if ("getIndirectionHandler".equals(methodName) && args[0] != null)
  			{
  				return this;
  			}
  
  			subject = getRealSubject();
  
              //kuali modification start
  			try {
                  method.setAccessible(true);
              } catch (SecurityException ex) {
                  LoggerFactory.getLogger(IndirectionHandler.class).warn(
                          "Error calling setAccessible for method " + method.getName(), ex);
              }
              //kuali modification end
  
  			return method.invoke(subject, args);
  			// [olegnitz] I've changed the following strange lines
  			// to the above one. Why was this done in such complicated way?
  			// Is it possible that subject doesn't implement the method's
  			// interface?
  			// Method m = subject.getClass().getMethod(method.getName(),
  			// method.getParameterTypes());
  			// return m.invoke(subject, args);
  		} catch (Exception ex)
  		{
  			throw new PersistenceBrokerException("Error invoking method " + method.getName(), ex);
  		}
  	}