Java callback / Calling object identification

Question

This runs on very similar lines to the topic by rishab, "Knowing the identity of the calling application."
Basically, when an arbitrary method is called on an arbitrary object, I need to be able to get a reference to the calling object, for authorization and callback purposes.
Details...
* All objects that require this will be subclasses of a common class, so this functionality can be implemented in that class.
* These objects should be pluggable - created by anyone, compiled and added on the fly, therefore implementation of this should not be required in subclasses.
* A reference to the calling object is required, without the object being passed, so such authorization cannot be compromised by providing proxy accessors or passing bogus objects.
* Reflection to call a method from a base class and force passing the calling method appears to be infeasible, since exact method-type matching appears to prevent polymorphism in reflection.
SecurityManager.getClassContext() is halfway there, in that is exposes what kind of object called the method, but for complete authorization and callback it is necessary to know which instance called the method.
If anyone has any information that might get me on the right track, I would be most grateful.
Regards,
-Troy

Answer 1

As you mentioned, this is very similar to another topic posted. To obtain an object reference to a caller WITHOUT sending an object reference is "de facto" problematic. Any solution will require a compromise to the design terms you described.
I think there's no pratical way to get around passing an object reference as a parameter. However, you could create an interface implemented by all calling classes that would contain a specific call-back method that would authorize the client before allowing the method to proceed.
This would require some sort of basic shared secret or handshake to be returned by the client's implementation of the interface method. Otherwise, you could implant the correct response into the client's superclass and declare it final. That way, when the shared object invokes the superclass method on the client, it could verify the instance and simply return a boolean.
public class SharedObject {
myMethod(Object O) {
...check if O implements myInterface...
...call ((myInterface)O).checkMyClient()
...if I'm satified, continue to interact with O
...else do nothing
}