Detecting the source of a method invocation.

Question

Within a given method, is there a way to detect what class/method made the invocation call?
I need to find a way to modify instance variables within a method, based on the invoking class ... I thought of navigating back through the Stack, but I am working with a multi-threaded application so I fear that I cannot absolutely depend on the last Stack call being the actual invoking class/method. Any ideas? - please help.
Many thanks,
Thomas

Answer 1

How does one access the method invocation stack?I'm not sure if an easier way exists, but you can extend SecurityManager to fetch the Class context of the current Thread, which will provide you with an array of Class obejcts, ordered according to the method invocation stack. Thus, you can determine what Class invoked a particular method, but you can not determine what Object (not via the SecurityManager funcationality).
Here is a simple class I often use for such a need (excuse any formating issues- or misspellings in the documenation)... ... although, it should be stated, this class may not work in certain environments- specifically ones that deny permission "createSecurityManager".
* This class provides static utility methods for retrieving information
* on the class context.  The methods in this class can provide a
* resource with a list of the classes that invoked it, thus allowing
* clases to determine if a particular method is being accessed by
* the proper caller or allow Class variables to be initialized statically,
* with out having to instantiate the type.
* <p>This class is meant to provide simple functionality in familiar
* environments.  Its funcationality may not work properly when executing
* in an enviroment with strigent security permissions.  Specifically, if
* permission is denied to construct a new SecurityManager instance, the
* methods of this class will fail.
* @author: Sean Flanerry
public final class ClassLookup extends SecurityManager {
  private static final ClassLookup instance = new ClassLookup();
  private ClassLookup() { }
  * This method returns the class context for the current thread in format
  * <ul>
  * <li>Class for currently executing method
  * <li>Class that invoked the above method
  * <li>Class that invoked the above method...
  * </ul>
  * The first two elements in the returned array will be of type ClassLookup.
  * @see java.lang.SecurityManager#getClassContext()
  public static Class [] fetchClassContext() {
    return instance.getClassContext();
  * This method returns the Class that invoked this method.  This method
  * is used primarily by static initializers that have to retrieve a handle
  * to the java.lang.Class instance that wraps the current type, but that
  * can not instantiate the current type, eg <br>
  * <code>public static final Class currentClass = ClassLookup.getCallingClass();
  public static Class getCallingClass() {
    return instance.getClassContext()[3];
  * This returns the Class that invoked the current method on the calling
  * Class.  If for example, Race.startRace() invokes Runner.sprint(), Runner.sprint()
  * can determine what class invoked it by calling this method.  In other
  * words, this method lets other methods determine which class invoked
  * it.
  * <p>Remember that this method returns a Class instance for which
  * ever type contains the method which invoked the caller so the
  * Object returned by this method might be the caller's type if the
  * caller was spawned by a method with in the same class.  Consider,
  * <ul>
  * <li>Race.start() invokes
  * <li>Runner.sprint() which invokes
  * <li>Runner.fatigue()
  * </ul>
  * If Runner.fatigue() invokes this method, an instance of Runner.class will
  * be returned, <b>not</b> Race.class because fatigue was invoked by sprint.
  * <p>This method is typically used by resources that wish to determine
  * if the current method is being invoked via the proper context, ie the
  * invoking class is a trused resource.
  public static Class getInvokingClass() {
    return instance.getClassContext()[4];
  public static void main(String args[]) {
    Class [] c = fetchClassContext();
    for (int i = 0; i < c.length; i++) {
      System.out.println(c.getName());