Mark Thomas wrote:
John Bollinger wrote:
See attached sample code for a class that would support this behavior.
Your attachment didn't make it through. Could you post it in-line?
Sure:
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package example;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* <p>
* A service class that assists in managing a "context" within an application or
* service. This version provides for creating dynamic proxies around objects
* belonging to a particular context to ensure that those objects' methods are
* invoked in that context.
* </p><p>
* Instances may be created and held on a one-per-context basis, but currently
* there is no harm in having multiple managers for the same context.
* Alternatively, {...@code ContextManager}s are lightweight, so they may be
created
* at need and released freely. Model usage:<br/>
* <tt><pre>
* ContextManager contextManager = ContextManager.forCurrentContext();
* ...
* void passRequestToForeignContext(RequestInterface request, ForeignContext
context) {
* context.handleRequest(
* contextManager.createProxy(request, RequestInterface.class)
* );
* }
* </pre></tt>
* </p>
*
* @author John C. Bollinger
*/
public class ContextManager {
/**
* The context ClassLoader for the context managed by this ContextManager
*/
private final ClassLoader contextClassLoader;
/**
* Initializes a new ContextManager managing the context defined by the
* specified context {...@code ClassLoader}
*
* @param contextClassLoader a {...@code ClassLoader} representing the
context
* to be managed by this {...@code ContextManager}
*/
public ContextManager(ClassLoader contextClassLoader) {
this.contextClassLoader = contextClassLoader;
}
/**
* Creates and returns a {...@code ContextManger} for the current context
*
* @return a {...@code ContextManger} for the current context
*/
public static ContextManager forCurrentContext() {
return new
ContextManager(Thread.currentThread().getContextClassLoader());
}
/**
* Creates a dynamic proxy object wrapping the provided object and ensuring
* that all methods of the wrapped object (when invoked via the proxy) see
* the appropriate context ClassLoader for the context managed by this
* {...@code ContextManager}. The proxy's class will implement the
specified
* interface(s) by delegating every method invocation to the wrapped object,
* setting the context ClassLoader before, and resetting it after.
*
* @param <T> an interface type that the proxy object will implement
* @param object the object to be wrapped by the
* @param iface a Class representing one of the interfaces the proxy's class
* must implement, and defining the formal type of the return value and
* the {...@code object} argument
* @param additionalIfaces {...@code Class}es representing additional
interfaces
* the proxy's class must implement
*
* @return a proxy object wrapping the specified delegate object, and whose
* class implements all the specified interfaces
*/
public <T> T createProxy(T object, Class<T> iface, Class<?>...
additionalIfaces) {
Class<?>[] interfaces;
/*
* Could test to see whether the interfaces (iface and additionalIfaces)
* are in fact interfaces (as opposed to normal classes). Haven't
tested
* what happens if they are non-interface classes, but probably Proxy
* will fail to create the proxy object.
*
* Could also test whether they are null.
*/
if (additionalIfaces != null) {
/*
* Set up the full list of interface classes the proxy will
implement.
* iface comes first, then any additionalIfaces elements, in order.
*/
/*
* Could test the additional interfaces here to make sure the
* submitted object can successfully be cast to each type. If the
* object's class does not implement one of the interfaces then
* runtime failures will occur when those interfaces' methods are
* invoked on the proxy.
*/
interfaces = new Class[1 + additionalIfaces.length];
interfaces[0] = iface;
System.arraycopy(additionalIfaces, 0, interfaces, 1,
additionalIfaces.length);
} else {
interfaces = new Class[] {iface};
}
return iface.cast(Proxy.newProxyInstance(contextClassLoader, interfaces,
new ContextManagingInvocationHandler(object,
contextClassLoader)));
}
/**
* An InvocationHandler wrapping a specified object and serving to present a
* given context ClassLoader to that object on all method invocations.
*
* @author John C. Bollinger
*/
private static class ContextManagingInvocationHandler implements
InvocationHandler {
/*
* This class doesn't really need to be nested. This version is nested
* mainly for packaging purposes.
*/
/**
* The ClassLoader to set as the current context ClassLoader when
* delegating method invocations to the {...@link #wrappedObject}
*/
private final ClassLoader contextClassLoader;
/**
* The object to which all method invocations are delegated
*/
private final Object wrappedObject;
/**
* Initializes a new ContextManagingInvocationHandler that delegates
* method invocations to the specified object while ensuring that the
* current context ClassLoader is the specified one within the scope of
* the invocation.
*
* @param wrappedObject the {...@code Object} to which method
invocations
* should be delegated
* @param contextClassLoader the {...@code ClassLoader} that should be
the
* current context {...@code ClassLoader} within the scope of
method
* invocations on the wrapped object
*/
public ContextManagingInvocationHandler(Object wrappedObject,
ClassLoader contextClassLoader) {
this.contextClassLoader = contextClassLoader;
this.wrappedObject = wrappedObject;
}
/**
* {...@inheritdoc}. This implementation sets the context ClassLoader
to the
* configured one, delegates to the wrapped object, then restores the
* context ClassLoader to its value at method entry.
*
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,
java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(@SuppressWarnings("unused") Object proxy,
Method method, Object[] args) throws Throwable {
Thread currentThread = Thread.currentThread();
ClassLoader currentContextClassLoader
= currentThread.getContextClassLoader();
try {
currentThread.setContextClassLoader(contextClassLoader);
return method.invoke(wrappedObject, args);
} finally {
currentThread.setContextClassLoader(currentContextClassLoader);
}
}
}
}
