cvs commit: jakarta-tomcat/src/share/org/apache/tomcat/util/hooks Hooks.java

[co...@apache.org]

costin      01/06/28 00:26:14

  Modified:    src/share/org/apache/tomcat/util/hooks Hooks.java
  Log:
  Decouple the Hook ( and the core ) from introspection, open it for
  better ( declarative or code generation ) mechanisms.
  
  The current implementation will still use the introspection ( until
  modules.xml will include the correct declarations about the callbacks ).
  
  As a side note, I repeated an old benchamark to find out if "too many hooks
  will affect performance"
  Surprisingly for me ( I didn't expected that ) - it does, with about 5%
  If you disable the code that sets up the hook chains with only the
  modules that are actually involved ( that's avg 3-4 calls per chain, most
  have 1-2 ), and if you run ~100.000 requests ( few times ), you may find
   a statistical difference ( now that we cut most of the hotspots from
  tomcat - a year ago it was none ).
  
  The surprise is that I expected the JIT to just eliminate the empty calls -
  5% is not insignificant.
  ( of course, this is just theoretical - there is no reason to
  add all the modules in all chains - that have been resolved a long ago, but
  it's interesting to know that it had such a small impact. )
  
  Revision  Changes    Path
  1.5       +24 -25    jakarta-tomcat/src/share/org/apache/tomcat/util/hooks/Hooks.java
  
  Index: Hooks.java
  ===================================================================
  RCS file: /home/cvs/jakarta-tomcat/src/share/org/apache/tomcat/util/hooks/Hooks.java,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- Hooks.java	2001/02/20 03:14:11	1.4
  +++ Hooks.java	2001/06/28 07:26:08	1.5
  @@ -62,7 +62,7 @@
   import java.io.*;
   import java.net.*;
   import java.util.*;
  -import java.lang.reflect.*;
  +import org.apache.tomcat.util.IntrospectionUtils;
   
   /** Hooks support. Hooks implement a chain-of-command pattern, and
    * are commonly used in most web servers as a mechanism of extensibility.
  @@ -201,30 +201,29 @@
       /** Test if the interceptor implements a particular
        *  method
        */
  -    public static boolean hasHook( Object obj, String methodN ) {
  -	try {
  -	    Method myMethods[]=obj.getClass().getMethods();
  -	    for( int i=0; i< myMethods.length; i++ ) {
  -		if( methodN.equals ( myMethods[i].getName() )) {
  -		    // check if it's overriden
  -		    Class declaring=myMethods[i].getDeclaringClass();
  -		    Class parentOfDeclaring=declaring.getSuperclass();
  -		    // this works only if the base class doesn't extend
  -		    // another class.
  -
  -		    // if the method is declared in a top level class
  -		    // like BaseInterceptor parent is Object, otherwise
  -		    // parent is BaseInterceptor or an intermediate class
  -		    if( ! "java.lang.Object".
  -			equals(parentOfDeclaring.getName() )) {
  -			return true;
  -		    }
  -		}
  -	    }
  -	} catch ( Exception ex ) {
  -	    ex.printStackTrace();
  -	}
  -	return false;
  +    private static boolean hasHook( Object obj, String methodN ) {
  +	if( hookFinder==null ) 
  +	    return true;
  +	return hookFinder.hasHook( obj, methodN );
  +
       }
   
  +    // -------------------- hook for hook detection --------------------
  +    
  +    /** Interface that decouples the Hooks from the introspection code.
  +	We want to allow future modes that are not based on introspection -
  +	for example declarative	( using modules.xml declarations ) or
  +	based on code generation ( introspection done at deploy time ).
  +    */
  +    public static interface HookFinder {
  +	public boolean hasHook( Object obj, String hookName );
  +    }
  +    
  +    // 
  +    static HookFinder hookFinder=null;
  +    
  +    public static void setHookFinder( HookFinder hf ) {
  +	hookFinder=hf;
  +    }
  +    
   }