/**
 * Monitors performance timing and execution counts for 
 * <code>HttpServlet</code> operations
 */
public aspect HttpServletMonitor {
 
  /** Execution of any Servlet request methods. */
  public pointcut monitoredOperation(Object operation) : 
    execution(void HttpServlet.do*(..)) && this(operation);
 
  /** Advice that records statistics for each monitored operation. */
  void around(Object operation) : monitoredOperation(operation) {
      long start = getTime();
 
      proceed(operation);
 
      PerfStats stats = lookupStats(operation);
      stats.recordExecution(getTime(), start);
  }
 
  /**
   * Find the appropriate statistics collector object for this
   * operation.
   * 
   * @param operation
   *            the instance of the operation being monitored
   */
  protected PerfStats lookupStats(Object operation) {
      Class keyClass = operation.getClass();
      synchronized(operations) {
          stats = (PerfStats)operations.get(keyClass);
          if (stats == null) {                
              stats = perfStatsFactory.
                createTopLevelOperationStats(HttpServlet.class, 
                       keyClass);
              operations.put(keyClass, stats);
          }
      }
      return stats;        
  }
 
  /**
   * Helper method to collect time in milliseconds. Could plug in
   * nanotimer.
   */
  public long getTime() {
      return System.currentTimeMillis();
  }
 
  public void setPerfStatsFactory(PerfStatsFactory 
    perfStatsFactory) {
      this.perfStatsFactory = perfStatsFactory;
  }
 
  public PerfStatsFactory getPerfStatsFactory() {
      return perfStatsFactory;
  }
 
  /** Track top-level operations. */ 
  private Map/*<Class,PerfStats>*/ operations  = 
    new WeakIdentityHashMap();
  private PerfStatsFactory perfStatsFactory;
}
 
/**
 * Holds summary performance statistics for a 
 * given topic of interest
 * (e.g., a subclass of Servlet).
 */ 
public interface PerfStats {
  /**
   * Record that a single execution occurred.
   * 
   * @param start time in milliseconds
   * @param end time in milliseconds
   */
  void recordExecution(long start, long end);
 
  /**
   * Reset these statistics back to zero. Useful to track statistics
   * during an interval.
   */
  void reset();
 
  /**
   * @return total accumulated time in milliseconds from all
   *         executions (since last reset).
   */
  int getAccumulatedTime();
 
  /**
   * @return the largest time for any single execution, in
   *         milliseconds (since last reset).
   */
  int getMaxTime();
 
  /** 
   * @return the number of executions recorded (since last reset). 
   */
  int getCount();
}
 
/**
 * Implementation of the
 * 
 * @link PerfStats interface.
 */
public class PerfStatsImpl implements PerfStats {
  private int accumulatedTime=0L;
  private int maxTime=0L;
  private int count=0;
 
  public void recordExecution(long start, long end) {
      int time = (int)(getTime()-start);
      accumulatedTime += time;
      maxTime = Math.max(time, maxTime);
      count++;
  }
 
  public void reset() {
      accumulatedTime=0L;
      maxTime=0L;
      count=0;
  }
 
  int getAccumulatedTime() { return accumulatedTime; }
  int getMaxTime() { return maxTime; }
  int getCount() { return count; }
}
 
public interface PerfStatsFactory {
    PerfStats 
      createTopLevelOperationStats(Object type, Object key);
}

				
/** Reusable aspect that automatically registers
 *  beans for management
 */
public aspect JmxManagement {
    /** Defines classes to be managed and 
     *  defines basic management operation
     */
    public interface ManagedBean {
        /** Define a JMX operation name for this bean. 
         *  Not to be confused with a Web request operation.
         */
        String getOperationName();
        /** Returns the underlying JMX MBean that 
         *  provides management
         *  information for this bean (POJO).
         */
        Object getMBean();
    } 
    /** After constructing an instance of 
     *  <code>ManagedBean</code>, register it
     */
    after() returning (ManagedBean bean): 
      call(ManagedBean+.new(..)) {
        String keyName = bean.getOperationName();
        ObjectName objectName = 
          new 
            ObjectName("glassbox.inspector:" + keyName);
        Object mBean = bean.getMBean();
        if (mBean != null) {
            server.registerMBean(mBean, objectName);
        }
    }
    /** 
     * Utility method to encode a JMX key name, 
     *  escaping illegal characters.
     * @param jmxName unescaped string buffer of form 
     * JMX keyname=key 
     * @param attrPos position of key in String
     */ 
    public static StringBuffer 
      jmxEncode(StringBuffer jmxName, int attrPos) {
        for (int i=attrPos; i<jmxName.length(); i++) {
            if (jmxName.charAt(i)==',' ) {
                jmxName.setCharAt(i, ';');
            } else if (jmxName.charAt(i)=='?' 
                || jmxName.charAt(i)=='*' || 
                jmxName.charAt(i)=='\\' ) {
                jmxName.insert(i, '\\');
                i++;
            } else if (jmxName.charAt(i)=='\n') {
                jmxName.insert(i, '\\');
                i++;
                jmxName.setCharAt(i, 'n');
            }
        }
        return jmxName;
    }
    /** Defines the MBeanServer with which beans
     *   are auto-registered.
     */
    private MBeanServer server;
    public void setMBeanServer(MBeanServer server) {
        this.server = server;
    }
    public MBeanServer getMBeanServer() {
        return server;
    }
}

				
/** Applies JMX management to performance statistics beans. */
public aspect StatsJmxManagement {
    /** Management interface for performance statistics. 
     *  A subset of @link PerfStats
     */
    public interface PerfStatsMBean extends ManagedBean {
        int getAccumulatedTime();
        int getMaxTime();
        int getCount();
        void reset();
    }
    
    /** 
     * Make the @link PerfStats interface 
     * implement @link PerfStatsMBean, 
     * so all instances can be managed 
     */
    declare parents: PerfStats implements PerfStatsMBean;
    /** Creates a JMX MBean to represent this PerfStats instance. */ 
    public DynamicMBean PerfStats.getMBean() {
        try {
            RequiredModelMBean mBean = new RequiredModelMBean();
            mBean.setModelMBeanInfo
              (assembler.getMBeanInfo(this, getOperationName()));
            mBean.setManagedResource(this, 
              "ObjectReference");
            return mBean;
        } catch (Exception e) {
            /* This is safe because @link ErrorHandling
            *  will resolve it. This is described later!
            */
            throw new 
              AspectConfigurationException("can't 
                register bean ", e);
        }
    }
    /** Determine JMX operation name for this
     *  performance statistics bean. 
     */    
    public String PerfStats.getOperationName() {        
        StringBuffer keyStr = 
          new StringBuffer("operation=\"");
        int pos = keyStr.length();
        if (key instanceof Class) {
            keyStr.append(((Class)key).getName());
        } else {
            keyStr.append(key.toString());
        }
        
        JmxManagement.jmxEncode(keyStr, pos);
        
        keyStr.append("\"");
        return keyStr.toString();
    }
    private static Class[] managedInterfaces = 
      { PerfStatsMBean.class };
    /** 
     * Spring JMX utility MBean Info Assembler. 
     * Allows @link PerfStatsMBean to serve 
     * as the management interface of all performance 
     * statistics implementors. 
     */
    static InterfaceBasedMBeanInfoAssembler assembler;
    static {
        assembler = new InterfaceBasedMBeanInfoAssembler();
        assembler.setManagedInterfaces(managedInterfaces);
    }
}

				
/** Base aspect for monitoring functionality. 
 *  Uses the worker object pattern.
 */
public abstract aspect AbstractRequestMonitor {
    /** Matches execution of the worker object
     *  for a monitored request.
     */
    public pointcut 
      requestExecution(RequestContext requestContext) :
        execution(* RequestContext.execute(..)) 
          && this(requestContext);
    
    /** In the control flow of a monitored request,
     *  i.e., of the execution of a worker object. 
     */
    public pointcut inRequest(RequestContext requestContext) :
        cflow(requestExecution(requestContext));
    /** establish parent relationships
     *  for request context objects.
     */ 
    // use of call is cleaner since constructors are called
    // once but executed many times
    after(RequestContext parentContext) 
      returning (RequestContext childContext) : 
      call(RequestContext+.new(..)) && 
        inRequest(parentContext) {
        childContext.setParent(parentContext);
    }
    public long getTime() {
        return System.currentTimeMillis();
    }
    /** Worker object that holds context information
     *  for a monitored request.
     */
    public abstract class RequestContext {
        /** Containing request context, if any. 
         *  Maintained by @link AbstractRequestMonitor
         */
        protected RequestContext parent = null;        
        /** Associated performance statistics. 
         *  Used to cache results of @link #lookupStats()
         */
        protected PerfStats stats;
        /** Start time for monitored request. */ 
        protected long startTime;
        /** 
         * Record execution and elapsed time 
         * for each monitored request.
         * Relies on @link #doExecute() to proceed
         * with original request. 
         */
        public final Object execute() {
            startTime = getTime();
            
            Object result = doExecute();
            
            PerfStats stats = getStats();
            if (stats != null) {
                stats.recordExecution(startTime, getTime());
            }
            
            return result;
        }
        
        /** template method: proceed with original request */
        public abstract Object doExecute();
        /** template method: determines appropriate performance
         *  statistics for this request 
         */
        protected abstract PerfStats lookupStats();
        
        /** returns performance statistics for this method */ 
        public PerfStats getStats() {
            if (stats == null) {
                stats = lookupStats(); // get from cache if available
            }
            return stats;
        }
        public RequestContext getParent() {
            return parent;            
        }
        
        public void setParent(RequestContext parent) {
            this.parent = parent;            
        }
    }
}

				
清单 5 should now read
public aspect HttpServletMonitor extends AbstractRequestMonitor {  
  /** Monitor Servlet requests using the worker object pattern */
  Object around(final Object operation) : 
    monitoredOperation(operation) {
      RequestContext requestContext = new RequestContext() {
          public Object doExecute() {
              return proceed(operation);
          }
          
          public PerfStats lookupStats() {                
              if (getParent() != null) {
                  // nested operation
                  OperationStats parentStats =
(OperationStats)getParent().getStats();
                  return
parentStats.getOperationStats(operation.getClass());
              }
              return lookupStats(operation.getClass());
          }
        };
        return requestContext.execute();
    }
 ...
 

				
/** 
 * Monitor performance for JDBC connections, 
 * and track database connection information associated with them. 
 */ 
public aspect JdbcConnectionMonitor extends AbstractRequestMonitor {
    
    /** A call to establish a connection using a 
     *  <code>DataSource</code> 
     */
    public pointcut dataSourceConnectionCall(DataSource dataSource) : 
        call(Connection+ DataSource.getConnection(..)) 
          && target(dataSource);
    /** A call to establish a connection using a URL string */
    public pointcut directConnectionCall(String url) :
        (call(Connection+ Driver.connect(..))  || call(Connection+ 
          DriverManager.getConnection(..))) && 
        args(url, ..);
    /** A database connection call nested beneath another one
     *  (common with proxies).
     */    
    public pointcut nestedConnectionCall() : 
        cflowbelow(dataSourceConnectionCall(*) || 
          directConnectionCall(*));
    
    /** Monitor data source connections using
     *  the worker object pattern 
     */
    Connection around(final DataSource dataSource) : 
      dataSourceConnectionCall(dataSource) 
        && !nestedConnectionCall() {
        RequestContext requestContext = 
          new ConnectionRequestContext() {
            public Object doExecute() {                
                accessingConnection(dataSource); 
                // set up stats early in case needed
                Connection connection = proceed(dataSource);
                return addConnection(connection);
            }
            
        };
        return (Connection)requestContext.execute();
    }
    /** Monitor url connections using the worker object pattern */
    Connection around(final String url) : directConnectionCall(url) 
      && !nestedConnectionCall() {
        RequestContext requestContext = 
          new ConnectionRequestContext() {
            public Object doExecute() {
                accessingConnection(url);
                Connection connection = proceed(url);
                
                return addConnection(connection);
            }
        };
        return (Connection)requestContext.execute();
    }
    /** Get stored name associated with this data source. */ 
    public String getDatabaseName(Connection connection) {
        synchronized (connections) {
            return (String)connections.get(connection);
        }
    }
    /** Use common accessors to return meaningful name
     *  for the resource accessed by this data source.
     */
    public String getNameForDataSource(DataSource ds) {
        // methods used to get names are listed in descending
        // preference order 
        String possibleNames[] = 
          { "getDatabaseName", 
              "getDatabasename", 
              "getUrl", "getURL", 
              "getDataSourceName", 
              "getDescription" };
        String name = null;
        for (int i=0; name == null && 
          i<possibleNames.length; i++) {
            try {            
                Method method = 
                  ds.getClass().getMethod(possibleNames[i], null);
                name = (String)method.invoke(ds, null);
            } catch (Exception e) {
                // keep trying
            }
        }
        return (name != null) ? name : "unknown";
    }    
    /** Holds JDBC connection-specific context information:
     *  a database name and statistics
     */
    protected abstract class ConnectionRequestContext
      extends RequestContext {
        private ResourceStats dbStats;
        
        /** set up context statistics for accessing
         *  this data source
         */ 
        protected void 
          accessingConnection(final DataSource dataSource) {
            addConnection(getNameForDataSource(dataSource), 
              connection);
        }
        
        /** set up context statistics for accessing this database */ 
        protected void accessingConnection(String databaseName) {
            this.databaseName = databaseName;
            // might be null if there is database access
            // caused from a request I'm not tracking...
            if (getParent() != null) {
                OperationStats opStats = 
                  (OperationStats)getParent().getStats();
                dbStats = opStats.getDatabaseStats(databaseName);                
            }
        }
        /** record the database name for this database connection */ 
        protected Connection 
          addConnection(final Connection connection) {
            synchronized(connections) {
                connections.put(connection, databaseName);
            }
            return connection;
        }
        protected PerfStats lookupStats() {
            return dbStats;
        }
    };    
    /** Associates connections with their database names */    
    private Map/*<Connection,String>*/ connections = 
      new WeakIdentityHashMap();
}

				
/**
 * Monitor performance for executing JDBC statements, 
 * and track the connections used to create them, 
 * and the SQL used to prepare them (if appropriate).
 */
public aspect JdbcStatementMonitor extends AbstractRequestMonitor {
    
    /** Matches any execution of a JDBC statement */
    public pointcut statementExec(Statement statement) : 
        call(* java.sql..*.execute*(..)) && 
          target(statement);
    
    /**
     * Store the sanitized SQL for dynamic statements. 
     */
    before(Statement statement, String sql, 
      RequestContext parentContext): 
      statementExec(statement) && args(sql, ..) 
        && inRequest(parentContext) {
        sql = stripAfterWhere(sql);
        setUpStatement(statement, sql, parentContext);
    }
    
    /** Monitor performance for executing a JDBC statement. */ 
   Object around(final Statement statement) : 
     statementExec(statement) {
        RequestContext requestContext = 
          new StatementRequestContext() {
            public Object doExecute() {
                return proceed(statement);
            }
        };
        return requestContext.execute();
    }
       
    /**
     * Call to create a Statement.
     * @param connection the connection called to
     * create the statement, which is bound to 
     * track the statement's origin 
     */
    public pointcut callCreateStatement(Connection connection):
        call(Statement+ Connection.*(..)) 
          && target(connection);
    /**
     * Track origin of statements, to properly 
     * associate statistics even in
     * the presence of wrapped connections 
     */
    after(Connection connection) returning (Statement statement):
      callCreateStatement(connection) {
        synchronized (JdbcStatementMonitor.this) {
            statementCreators.put(statement, connection);
        }
    }
    /** 
     * A call to prepare a statement.
     * @param sql The SQL string prepared by the statement. 
     */
    public pointcut callCreatePreparedStatement(String sql):
        call(PreparedStatement+ Connection.*(String, ..)) 
          && args(sql, ..);
    /** Track SQL used to prepare a prepared statement */
    after(String sql) returning (PreparedStatement statement): 
      callCreatePreparedStatement(sql) {
        setUpStatement(statement, sql);
    }
            
    protected abstract class StatementRequestContext 
      extends RequestContext {
        /** 
         * Find statistics for this statement, looking for its 
         * SQL string in the parent request's statistics context 
         */
        protected PerfStats lookupStats() {
            if (getParent() != null) {
                Connection connection = null;
                String sql = null;
                synchronized (JdbcStatementMonitor.this) {
                    connection = 
                      (Connection) statementCreators.get(statement);
                    sql = (String) statementSql.get(statement);
                }
                if (connection != null) {
                    String databaseName = 
                      JdbcConnectionMonitor.aspectOf().
                        getDatabaseName(connection);
                    if (databaseName != null && sql != null) {
                        OperationStats opStats = 
                          (OperationStats) getParent().getStats();
                        if (opStats != null) {
                            ResourceStats dbStats = 
                              opStats.getDatabaseStats(databaseName);
                            return dbStats.getRequestStats(sql);
                        }
                    }
                }
            }
            return null;
        }
    }
    /** 
     * To group sensibly and to avoid recording sensitive data,
     * I don't record the where clause (only used for dynamic
     * SQL since parameters aren't included
     * in prepared statements)
     * @return subset of passed SQL up to the where clause
     */
    public static String stripAfterWhere(String sql) {
        for (int i=0; i<sql.length()-4; i++) {
            if (sql.charAt(i)=='w' || sql.charAt(i)==
              'W') {
                if (sql.substring(i+1, i+5).equalsIgnoreCase(
                  "here"))
                  {
                    sql = sql.substring(0, i);
                }
            }
        }
        return sql;
    }    
    private synchronized void 
      setUpStatement(Statement statement, String sql) {
        statementSql.put(statement, sql);
    }
    /** associate statements with the connections
     *  called to create them
     */
    private Map/*<Statement,Connection>*/ statementCreators = 
      new WeakIdentityHashMap();
    /** associate statements with the
     *  underlying string they execute
     */
    private Map/*<Statement,String>*/ statementSql = 
      new WeakIdentityHashMap();
}