/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.axis.utils.cache;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.apache.axis.utils.ClassUtils;
/**
* A cache for methods.
* Used to get methods by their signature and stores them in a local
* cache for performance reasons.
* This class is a singleton - so use getInstance to get an instance of it.
*
* @author Davanum Srinivas <dims@yahoo.com>
* @author Sebastian Dietrich <sebastian.dietrich@anecon.com>
*/
public class MethodCache {
/**
* The only instance of this class
*/
transient private static MethodCache instance;
/**
* Cache for Methods
* In fact this is a map (with classes as keys) of a map (with method-names as keys)
*/
transient private static ThreadLocal cache;
/**
* The <i>private</i> constructor for this class.
* Use getInstance to get an instance (the only one).
*/
private MethodCache() {
cache = new ThreadLocal();
}
/**
* Gets the only instance of this class
* @return the only instance of this class
*/
public static MethodCache getInstance() {
if (instance == null) {
instance = new MethodCache();
}
return instance;
}
/**
* Returns the per thread hashmap (for method caching)
*/
private Map getMethodCache() {
Map map = (Map) cache.get();
if (map == null) {
map = new HashMap();
cache.set(map);
}
return map;
}
/**
* Class used as the key for the method cache table.
*
*/
static class MethodKey {
/** the name of the method in the cache */
private final String methodName;
/** the list of types accepted by the method as arguments */
private final Class[] parameterTypes;
/**
* Creates a new <code>MethodKey</code> instance.
*
* @param methodName a <code>String</code> value
* @param parameterTypes a <code>Class[]</code> value
*/
MethodKey(String methodName, Class[] parameterTypes) {
this.methodName = methodName;
this.parameterTypes = parameterTypes;
}
public boolean equals(Object other) {
MethodKey that = (MethodKey) other;
return this.methodName.equals(that.methodName)
&& Arrays.equals(this.parameterTypes,
that.parameterTypes);
}
public int hashCode() {
// allow overloaded methods to collide; we'll sort it out
// in equals(). Note that String's implementation of
// hashCode already caches its value, so there's no point
// in doing so here.
return methodName.hashCode();
}
}
/** used to track methods we've sought but not found in the past */
private static final Object NULL_OBJECT = new Object();
/**
* Returns the specified method - if any.
*
* @param clazz the class to get the method from
* @param methodName the name of the method
* @param parameterTypes the parameters of the method
* @return the found method
*
* @throws NoSuchMethodException if the method can't be found
*/
public Method getMethod(Class clazz,
String methodName,
Class[] parameterTypes)
throws NoSuchMethodException {
String className = clazz.getName();
Map cache = getMethodCache();
Method method = null;
Map methods = null;
// Strategy is as follows:
// construct a MethodKey to represent the name/arguments
// of a method's signature.
//
// use the name of the class to retrieve a map of that
// class' methods
//
// if a map exists, use the MethodKey to find the
// associated value object. if that object is a Method
// instance, return it. if that object is anything
// else, then it's a reference to our NULL_OBJECT
// instance, indicating that we've previously tried
// and failed to find a method meeting our requirements,
// so return null
//
// if the map of methods for the class doesn't exist,
// or if no value is associated with our key in that map,
// then we perform a reflection-based search for the method.
//
// if we find a method in that search, we store it in the
// map using the key; otherwise, we store a reference
// to NULL_OBJECT using the key.
// Check the cache first.
MethodKey key = new MethodKey(methodName, parameterTypes);
methods = (Map) cache.get(clazz);
if (methods != null) {
Object o = methods.get(key);
if (o != null) { // cache hit
if (o instanceof Method) { // good cache hit
return (Method) o;
} else { // bad cache hit
// we hit the NULL_OBJECT, so this is a search
// that previously failed; no point in doing
// it again as it is a worst case search
// through the entire classpath.
return null;
}
} else {
// cache miss: fall through to reflective search
}
} else {
// cache miss: fall through to reflective search
}
try {
method = clazz.getMethod(methodName, parameterTypes);
} catch (NoSuchMethodException e1) {
if (!clazz.isPrimitive() && !className.startsWith("java.") && !className.startsWith("javax.")) {
try {
Class helper = ClassUtils.forName(className + "_Helper");
method = helper.getMethod(methodName, parameterTypes);
} catch (ClassNotFoundException e2) {
}
}
}
// first time we've seen this class: set up its method cache
if (methods == null) {
methods = new HashMap();
cache.put(clazz, methods);
}
// when no method is found, cache the NULL_OBJECT
// so that we don't have to repeat worst-case searches
// every time.
if (null == method) {
methods.put(key, NULL_OBJECT);
} else {
methods.put(key, method);
}
return method;
}
}
|
