12:06 p.m.
Author: manik.surtani(a)jboss.com
Date: 2008-05-09 13:06:20 -0400 (Fri, 09 May 2008)
New Revision: 5821
Removed:
core/trunk/src/main/java/org/jboss/cache/util/reflect/CachedMethod.java
Modified:
core/trunk/src/main/java/org/jboss/cache/factories/ComponentRegistry.java
core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java
Log:
Removed unnecessary class
Modified: core/trunk/src/main/java/org/jboss/cache/factories/ComponentRegistry.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/factories/ComponentRegistry.java 2008-05-09
12:32:19 UTC (rev 5820)
+++ core/trunk/src/main/java/org/jboss/cache/factories/ComponentRegistry.java 2008-05-09
17:06:20 UTC (rev 5821)
@@ -16,7 +16,6 @@
import org.jboss.cache.factories.annotations.Start;
import org.jboss.cache.factories.annotations.Stop;
import org.jboss.cache.util.BeanUtils;
-import org.jboss.cache.util.reflect.CachedMethod;
import org.jboss.cache.util.reflect.ReflectionUtil;
import javax.management.MBeanServerFactory;
@@ -25,7 +24,6 @@
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -72,9 +70,6 @@
// component and method containers
final Map<String, Component> componentLookup = new HashMap<String,
Component>();
- final List<PrioritizedMethod> startMethods = new
ArrayList<PrioritizedMethod>();
- final List<PrioritizedMethod> stopMethods = new
ArrayList<PrioritizedMethod>();
- final List<PrioritizedMethod> destroyMethods = new
ArrayList<PrioritizedMethod>();
CacheStatus state = CacheStatus.INSTANTIATED;
@@ -88,7 +83,6 @@
*/
private boolean invokedFromShutdownHook;
-
/**
* Creates an instance of the component registry. The configuration passed in is
automatically registered.
*
@@ -132,10 +126,12 @@
{
try
{
- List<CachedMethod> methods =
ReflectionUtil.getAllCachedMethods(target.getClass(), Inject.class);
+ // don't use the reflection cache for wireDependencies calls since these are
not managed by the ComponentRegistry
+ // and may be invoked at any time, even after the cache starts.
+ List<Method> methods = ReflectionUtil.getAllMethods(target.getClass(),
Inject.class);
// search for anything we need to inject
- for (CachedMethod method : methods) invokeInjectionMethod(target, method);
+ for (Method method : methods) invokeInjectionMethod(target, method);
}
catch (Exception e)
{
@@ -208,6 +204,7 @@
{
if (trace) log.trace("Replacing old component " + old + " with
new instance " + component);
old.instance = component;
+ old.methodsScanned = false;
c = old;
if (state == CacheStatus.STARTED) populateLifecycleMethods();
@@ -234,13 +231,13 @@
protected void addComponentDependencies(Component c)
{
Class type = c.instance.getClass();
- List<CachedMethod> methods = ReflectionUtil.getAllCachedMethods(type,
Inject.class);
+ List<Method> methods = ReflectionUtil.getAllMethods(type, Inject.class);
c.injectionMethods.clear();
- for (CachedMethod m : methods) c.injectionMethods.add(m);
+ c.injectionMethods.addAll(methods);
}
@SuppressWarnings("unchecked")
- protected void invokeInjectionMethod(Object o, CachedMethod m)
+ protected void invokeInjectionMethod(Object o, Method m)
{
Class[] dependencies = m.getParameterTypes();
Object[] params = new Object[dependencies.length];
@@ -250,7 +247,7 @@
params[i] = getOrCreateComponent(dependencies[i]);
}
- ReflectionUtil.invokeAccessibly(o, m.getMethod(), params);
+ ReflectionUtil.invokeAccessibly(o, m, params);
}
/**
@@ -478,54 +475,46 @@
*/
private void populateLifecycleMethods()
{
- // cache a list of the start annotated methods
- startMethods.clear();
for (Component c : componentLookup.values())
{
- List<Method> methods = ReflectionUtil.getAllMethods(c.instance.getClass(),
Start.class);
- for (Method m : methods)
+ if (!c.methodsScanned)
{
- PrioritizedMethod em = new PrioritizedMethod();
- em.component = c;
- em.method = m;
- em.priority = m.getAnnotation(Start.class).priority();
- startMethods.add(em);
- }
- }
+ c.methodsScanned = true;
+ c.startMethods.clear();
+ c.stopMethods.clear();
+ c.destroyMethods.clear();
- // cache a list of the stop annotated methods
- stopMethods.clear();
- for (Component c : componentLookup.values())
- {
- List<Method> methods = ReflectionUtil.getAllMethods(c.instance.getClass(),
Stop.class);
- for (Method m : methods)
- {
- PrioritizedMethod em = new PrioritizedMethod();
- em.component = c;
- em.method = m;
- em.priority = m.getAnnotation(Stop.class).priority();
- stopMethods.add(em);
- }
- }
+ List<Method> methods =
ReflectionUtil.getAllMethods(c.instance.getClass(), Start.class);
+ for (Method m : methods)
+ {
+ PrioritizedMethod em = new PrioritizedMethod();
+ em.component = c;
+ em.method = m;
+ em.priority = m.getAnnotation(Start.class).priority();
+ c.startMethods.add(em);
+ }
- // cache a list of the destroy annotated methods
- destroyMethods.clear();
- for (Component c : componentLookup.values())
- {
- List<Method> methods = ReflectionUtil.getAllMethods(c.instance.getClass(),
Destroy.class);
- for (Method m : methods)
- {
- PrioritizedMethod em = new PrioritizedMethod();
- em.component = c;
- em.method = m;
- em.priority = m.getAnnotation(Destroy.class).priority();
- destroyMethods.add(em);
+ methods = ReflectionUtil.getAllMethods(c.instance.getClass(), Stop.class);
+ for (Method m : methods)
+ {
+ PrioritizedMethod em = new PrioritizedMethod();
+ em.component = c;
+ em.method = m;
+ em.priority = m.getAnnotation(Stop.class).priority();
+ c.startMethods.add(em);
+ }
+
+ methods = ReflectionUtil.getAllMethods(c.instance.getClass(),
Destroy.class);
+ for (Method m : methods)
+ {
+ PrioritizedMethod em = new PrioritizedMethod();
+ em.component = c;
+ em.method = m;
+ em.priority = m.getAnnotation(Destroy.class).priority();
+ c.startMethods.add(em);
+ }
}
}
-
- Collections.sort(startMethods);
- Collections.sort(stopMethods);
- Collections.sort(destroyMethods);
}
/**
@@ -722,6 +711,12 @@
// first cache all start, stop and destroy methods.
populateLifecycleMethods();
+ List<PrioritizedMethod> startMethods = new
ArrayList<PrioritizedMethod>(componentLookup.size());
+ for (Component c : componentLookup.values()) startMethods.addAll(c.startMethods);
+
+ // sort the start methods by priority
+ Collections.sort(startMethods);
+
// fire all START methods according to priority
for (PrioritizedMethod em : startMethods) em.invoke();
@@ -776,6 +771,11 @@
// if this is called from a source other than the shutdown hook, deregister the
shutdown hook.
if (!invokedFromShutdownHook && shutdownHook != null)
Runtime.getRuntime().removeShutdownHook(shutdownHook);
+ List<PrioritizedMethod> stopMethods = new
ArrayList<PrioritizedMethod>(componentLookup.size());
+ for (Component c : componentLookup.values()) stopMethods.addAll(c.stopMethods);
+
+ Collections.sort(stopMethods);
+
// fire all STOP methods according to priority
for (PrioritizedMethod em : stopMethods) em.invoke();
@@ -792,6 +792,11 @@
resetNonVolatile();
+ List<PrioritizedMethod> destroyMethods = new
ArrayList<PrioritizedMethod>(componentLookup.size());
+ for (Component c : componentLookup.values())
destroyMethods.addAll(c.destroyMethods);
+
+ Collections.sort(destroyMethods);
+
// fire all DESTROY methods according to priority
for (PrioritizedMethod em : destroyMethods) em.invoke();
@@ -878,10 +883,14 @@
* The name of the component
*/
String name;
+ boolean methodsScanned;
/**
* List of injection methods used to inject dependencies into the component
*/
- List<CachedMethod> injectionMethods = new LinkedList<CachedMethod>();
+ List<Method> injectionMethods = new ArrayList<Method>(2);
+ List<PrioritizedMethod> startMethods = new
ArrayList<PrioritizedMethod>(2);
+ List<PrioritizedMethod> stopMethods = new
ArrayList<PrioritizedMethod>(2);
+ List<PrioritizedMethod> destroyMethods = new
ArrayList<PrioritizedMethod>(2);
/**
* If true, then this component is not flushed before starting the
ComponentRegistry.
*/
@@ -902,7 +911,7 @@
*/
public void injectDependencies()
{
- for (CachedMethod m : injectionMethods) invokeInjectionMethod(instance, m);
+ for (Method m : injectionMethods) invokeInjectionMethod(instance, m);
}
}
Deleted: core/trunk/src/main/java/org/jboss/cache/util/reflect/CachedMethod.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/util/reflect/CachedMethod.java 2008-05-09
12:32:19 UTC (rev 5820)
+++ core/trunk/src/main/java/org/jboss/cache/util/reflect/CachedMethod.java 2008-05-09
17:06:20 UTC (rev 5821)
@@ -1,39 +0,0 @@
-package org.jboss.cache.util.reflect;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-
-/**
- * A cached Method object, so that calls to getParameterTypes, getAnnotations, etc are
cached.
- *
- * @author Manik Surtani (<a
href="mailto:manik@jboss.org">manik@jboss.org</a>)
- * @since 2.1.0
- */
-public class CachedMethod
-{
- Method method;
- Class[] parameterTypes;
- Annotation[][] parameterAnnotations;
-
- public CachedMethod(Method method)
- {
- this.method = method;
- this.parameterTypes = method.getParameterTypes();
- this.parameterAnnotations = method.getParameterAnnotations();
- }
-
- public Method getMethod()
- {
- return method;
- }
-
- public Class[] getParameterTypes()
- {
- return parameterTypes;
- }
-
- public Annotation[][] getParameterAnnotations()
- {
- return parameterAnnotations;
- }
-}
Modified: core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java 2008-05-09
12:32:19 UTC (rev 5820)
+++ core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java 2008-05-09
17:06:20 UTC (rev 5821)
@@ -38,21 +38,6 @@
}
/**
- * Returns a set of Methods that contain the given method annotation. This includes
all public, protected, package and private
- * methods, as well as those of superclasses. Note that this does *not* include
overridden methods.
- *
- * @param c class to inspect
- * @param annotationType the type of annotation to look for
- * @return List of Method objects that require injection.
- */
- public static List<CachedMethod> getAllCachedMethods(Class c, Class<? extends
Annotation> annotationType)
- {
- List<CachedMethod> annotated = new LinkedList<CachedMethod>();
- inspectRecursivelyCached(c, annotated, annotationType);
- return annotated;
- }
-
- /**
* Inspects a class and it's superclasses (all the way to {@link Object} for
method instances that contain a given annotation.
* This even identifies private, package and protected methods, not just public ones.
*
@@ -76,29 +61,6 @@
}
/**
- * Inspects a class and it's superclasses (all the way to {@link Object} for
method instances that contain a given annotation.
- * This even identifies private, package and protected methods, not just public ones.
- *
- * @param c
- * @param s
- * @param annotationType
- */
- private static void inspectRecursivelyCached(Class c, List<CachedMethod> s,
Class<? extends Annotation> annotationType)
- {
- // Superclass first
- if (!c.equals(Object.class)) inspectRecursivelyCached(c.getSuperclass(), s,
annotationType);
-
- for (Method m : c.getDeclaredMethods())
- {
- // don't bother if this method has already been overridden by a subclass
- if (!alreadyFoundCached(m, s) && m.isAnnotationPresent(annotationType))
- {
- s.add(new CachedMethod(m));
- }
- }
- }
-
- /**
* Tests whether a method has already been found, i.e., overridden.
*
* @param m method to inspect
@@ -116,24 +78,6 @@
return false;
}
- /**
- * Tests whether a method has already been found, i.e., overridden.
- *
- * @param m method to inspect
- * @param s collection of methods found
- * @return true a method with the same signature already exists.
- */
- private static boolean alreadyFoundCached(Method m, Collection<CachedMethod> s)
- {
- for (CachedMethod found : s)
- {
- if (m.getName().equals(found.getMethod().getName()) &&
- Arrays.equals(m.getParameterTypes(), found.getParameterTypes()))
- return true;
- }
- return false;
- }
-
public static void setValue(Object instance, String fieldName, Object value)
{
try