コード例 #1
0
  @Override
  protected Object retrieveAction(
      GroovyObject controller, String actionName, HttpServletResponse response) {

    Class<?> controllerClass = AopProxyUtils.ultimateTargetClass(controller);

    Method mAction =
        ReflectionUtils.findMethod(
            controllerClass, actionName, MethodGrailsControllerHelper.NOARGS);
    if (mAction != null) {
      ReflectionUtils.makeAccessible(mAction);
      if (mAction.getAnnotation(Action.class) != null) {
        return mAction;
      }
    }

    try {
      return controller.getProperty(actionName);
    } catch (MissingPropertyException mpe) {
      try {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return null;
      } catch (IOException e) {
        throw new ControllerExecutionException("I/O error sending 404 error", e);
      }
    }
  }
  public final Collection<ConfigAttribute> getAttributes(Object object) {
    if (object instanceof MethodInvocation) {
      MethodInvocation mi = (MethodInvocation) object;
      Object target = mi.getThis();
      Class<?> targetClass = null;

      if (target != null) {
        targetClass =
            target instanceof Class<?>
                ? (Class<?>) target
                : AopProxyUtils.ultimateTargetClass(target);
      }
      Collection<ConfigAttribute> attrs = getAttributes(mi.getMethod(), targetClass);
      if (attrs != null && !attrs.isEmpty()) {
        return attrs;
      }
      if (target != null && !(target instanceof Class<?>)) {
        attrs = getAttributes(mi.getMethod(), target.getClass());
      }
      return attrs;
    }

    throw new IllegalArgumentException("Object must be a non-null MethodInvocation");
  }
コード例 #3
0
  @Override
  protected void doFilter(
      HttpServletRequest request, HttpServletResponse response, FilterChain chain)
      throws Exception {
    // TODO need blocking cache stuff from CachingFilter
    initContext();

    try {

      Object controller = lookupController(getContext().getControllerClass());
      if (controller == null) {
        log.debug(
            "Not a controller request {}:{} {}",
            request.getMethod(),
            request.getRequestURI(),
            getContext());
        chain.doFilter(request, response);
        return;
      }

      Class<?> controllerClass = AopProxyUtils.ultimateTargetClass(controller);
      if (controllerClass == null) {
        controllerClass = controller.getClass();
      }
      Method method = getContext().getMethod();
      if (method == null) {
        log.debug(
            "No cacheable method found for {}:{} {}",
            request.getMethod(),
            request.getRequestURI(),
            getContext());
        chain.doFilter(request, response);
        return;
      }
      Collection<CacheOperation> cacheOperations =
          cacheOperationSource.getCacheOperations(method, controllerClass, true);

      if (CollectionUtils.isEmpty(cacheOperations)) {
        log.debug(
            "No cacheable annotation found for {}:{} {}",
            request.getMethod(),
            request.getRequestURI(),
            getContext());
        chain.doFilter(request, response);
        return;
      }

      Map<String, Collection<CacheOperationContext>> operationsByType =
          createOperationContext(cacheOperations, method, controllerClass, request);

      // start with evictions
      if (inspectBeforeCacheEvicts(operationsByType.get(EVICT))) {
        chain.doFilter(request, response);
        return;
      }

      // follow up with cacheable
      CacheStatus status = inspectCacheables(operationsByType.get(CACHEABLE));

      Map<CacheOperationContext, Object> updates =
          inspectCacheUpdates(operationsByType.get(UPDATE));

      if (status != null) {
        if (status.updateRequired) {
          updates.putAll(status.updates);
        }
        // render cached response
        else {
          logRequestDetails(request, getContext(), "Caching enabled for request");
          PageInfo pageInfo = buildCachedPageInfo(request, response, status);
          writeResponse(request, response, pageInfo);
          return;
        }
      }

      logRequestDetails(request, getContext(), "Caching enabled for request");
      PageInfo pageInfo = buildNewPageInfo(request, response, chain, status, operationsByType);
      writeResponse(request, response, pageInfo);

      inspectAfterCacheEvicts(operationsByType.get(EVICT));

      if (!updates.isEmpty()) {
        Collection<Cache> caches = new ArrayList<Cache>();
        for (Map.Entry<CacheOperationContext, Object> entry : updates.entrySet()) {
          for (Cache cache : entry.getKey().getCaches()) {
            caches.add(cache);
          }
        }
        update(caches, pageInfo, status, calculateKey(request));
      }
    } finally {
      destroyContext();
    }
  }
コード例 #4
0
 @SuppressWarnings("unchecked")
 protected final <T> Class<T> getClass(T object) {
   return (Class<T>) AopProxyUtils.ultimateTargetClass(object);
 }