commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rmannibu...@apache.org
Subject svn commit: r1806978 - /commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/
Date Fri, 01 Sep 2017 15:18:16 GMT
Author: rmannibucau
Date: Fri Sep  1 15:18:16 2017
New Revision: 1806978

URL: http://svn.apache.org/viewvc?rev=1806978&view=rev
Log:
JCS-183 reduce reflection at runtime in our jcache cdi integration

Modified:
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CDIJCacheHelper.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheInvocationContextImpl.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheKeyInvocationContextImpl.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheMethodDetailsImpl.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CachePutInterceptor.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveAllInterceptor.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveInterceptor.java
    commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheResultInterceptor.java

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CDIJCacheHelper.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CDIJCacheHelper.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CDIJCacheHelper.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CDIJCacheHelper.java Fri Sep  1 15:18:16 2017
@@ -18,28 +18,36 @@
  */
 package org.apache.commons.jcs.jcache.cdi;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.logging.Logger;
+
 import javax.annotation.PreDestroy;
 import javax.cache.annotation.CacheDefaults;
 import javax.cache.annotation.CacheKey;
 import javax.cache.annotation.CacheKeyGenerator;
+import javax.cache.annotation.CachePut;
+import javax.cache.annotation.CacheRemove;
+import javax.cache.annotation.CacheRemoveAll;
 import javax.cache.annotation.CacheResolverFactory;
+import javax.cache.annotation.CacheResult;
 import javax.cache.annotation.CacheValue;
 import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.context.Dependent;
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.inject.Inject;
 import javax.interceptor.InvocationContext;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.logging.Logger;
 
 @ApplicationScoped
 public class CDIJCacheHelper
@@ -49,8 +57,9 @@ public class CDIJCacheHelper
 
     private volatile CacheResolverFactoryImpl defaultCacheResolverFactory = null; // lazy to not create any cache if not needed
     private final CacheKeyGeneratorImpl defaultCacheKeyGenerator = new CacheKeyGeneratorImpl();
-    private final ConcurrentMap<Method, String> generatedNames = new ConcurrentHashMap<Method, String>();
-    private final ConcurrentMap<Method, Integer[]> parameterIndexes = new ConcurrentHashMap<Method, Integer[]>();
+
+    private final Collection<CreationalContext<?>> toRelease = new ArrayList<CreationalContext<?>>();
+    private final ConcurrentMap<MethodKey, MethodMeta> methods = new ConcurrentHashMap<MethodKey, MethodMeta>();
 
     @Inject
     private BeanManager beanManager;
@@ -61,9 +70,152 @@ public class CDIJCacheHelper
         {
             defaultCacheResolverFactory.release();
         }
+        for (final CreationalContext<?> cc : toRelease)
+        {
+            try
+            {
+                cc.release();
+            }
+            catch (final RuntimeException re)
+            {
+                LOGGER.warning(re.getMessage());
+            }
+        }
+    }
+
+    public MethodMeta findMeta(final InvocationContext ic)
+    {
+        final Method mtd = ic.getMethod();
+        final MethodKey key = new MethodKey(mtd);
+        MethodMeta methodMeta = methods.get(key);
+        if (methodMeta == null)
+        {
+            synchronized (this)
+            {
+                methodMeta = methods.get(key);
+                if (methodMeta == null)
+                {
+                    methodMeta = createMeta(ic);
+                }
+            }
+        }
+        return methodMeta;
+    }
+
+    // it is unlikely we have all annotations but for now we have a single meta model
+    private MethodMeta createMeta(final InvocationContext ic)
+    {
+        final CacheDefaults defaults = findDefaults(ic.getTarget() == null ? null : ic.getTarget()
+                                                      .getClass(), ic.getMethod());
+
+        final Class<?>[] parameterTypes = ic.getMethod().getParameterTypes();
+        final Annotation[][] parameterAnnotations = ic.getMethod().getParameterAnnotations();
+        final List<Set<Annotation>> annotations = new ArrayList<Set<Annotation>>();
+        for (final Annotation[] parameterAnnotation : parameterAnnotations)
+        {
+            final Set<Annotation> set = new HashSet<Annotation>(parameterAnnotation.length);
+            set.addAll(Arrays.asList(parameterAnnotation));
+            annotations.add(set);
+        }
+
+        final Set<Annotation> mtdAnnotations = new HashSet<Annotation>();
+        mtdAnnotations.addAll(Arrays.asList(ic.getMethod().getAnnotations()));
+
+        final CacheResult cacheResult = ic.getMethod().getAnnotation(CacheResult.class);
+        final String cacheResultCacheResultName = cacheResult == null ? null : defaultName(ic.getMethod(), defaults, cacheResult.cacheName());
+        final CacheResolverFactory cacheResultCacheResolverFactory = cacheResult == null ?
+                null : cacheResolverFactoryFor(defaults, cacheResult.cacheResolverFactory());
+        final CacheKeyGenerator cacheResultCacheKeyGenerator = cacheResult == null ?
+                null : cacheKeyGeneratorFor(defaults, cacheResult.cacheKeyGenerator());
+
+        final CachePut cachePut = ic.getMethod().getAnnotation(CachePut.class);
+        final String cachePutCachePutName = cachePut == null ? null : defaultName(ic.getMethod(), defaults, cachePut.cacheName());
+        final CacheResolverFactory cachePutCacheResolverFactory = cachePut == null ?
+                null : cacheResolverFactoryFor(defaults, cachePut.cacheResolverFactory());
+        final CacheKeyGenerator cachePutCacheKeyGenerator = cachePut == null ?
+                null : cacheKeyGeneratorFor(defaults, cachePut.cacheKeyGenerator());
+
+        final CacheRemove cacheRemove = ic.getMethod().getAnnotation(CacheRemove.class);
+        final String cacheRemoveCacheRemoveName = cacheRemove == null ? null : defaultName(ic.getMethod(), defaults, cacheRemove.cacheName());
+        final CacheResolverFactory cacheRemoveCacheResolverFactory = cacheRemove == null ?
+                null : cacheResolverFactoryFor(defaults, cacheRemove.cacheResolverFactory());
+        final CacheKeyGenerator cacheRemoveCacheKeyGenerator = cacheRemove == null ?
+                null : cacheKeyGeneratorFor(defaults, cacheRemove.cacheKeyGenerator());
+
+        final CacheRemoveAll cacheRemoveAll = ic.getMethod().getAnnotation(CacheRemoveAll.class);
+        final String cacheRemoveAllCacheRemoveAllName = cacheRemoveAll == null ? null : defaultName(ic.getMethod(), defaults, cacheRemoveAll.cacheName());
+        final CacheResolverFactory cacheRemoveAllCacheResolverFactory = cacheRemoveAll == null ?
+                null : cacheResolverFactoryFor(defaults, cacheRemoveAll.cacheResolverFactory());
+
+        return new MethodMeta(
+                parameterTypes,
+                annotations,
+                mtdAnnotations,
+                keyParameterIndexes(ic.getMethod()),
+                getValueParameter(annotations),
+                getKeyParameters(annotations),
+                cacheResultCacheResultName,
+                cacheResultCacheResolverFactory,
+                cacheResultCacheKeyGenerator,
+                cacheResult,
+                cachePutCachePutName,
+                cachePutCacheResolverFactory,
+                cachePutCacheKeyGenerator,
+                cachePut != null && cachePut.afterInvocation(),
+                cachePut,
+                cacheRemoveCacheRemoveName,
+                cacheRemoveCacheResolverFactory,
+                cacheRemoveCacheKeyGenerator,
+                cacheRemove != null && cacheRemove.afterInvocation(),
+                cacheRemove,
+                cacheRemoveAllCacheRemoveAllName,
+                cacheRemoveAllCacheResolverFactory,
+                cacheRemoveAll != null && cacheRemoveAll.afterInvocation(),
+                cacheRemoveAll);
+    }
+
+    private Integer[] getKeyParameters(final List<Set<Annotation>> annotations)
+    {
+        final Collection<Integer> list = new ArrayList<Integer>();
+        int idx = 0;
+        for (final Set<Annotation> set : annotations)
+        {
+            for (final Annotation a : set)
+            {
+                if (a.annotationType() == CacheKey.class)
+                {
+                    list.add(idx);
+                }
+            }
+            idx++;
+        }
+        if (list.isEmpty())
+        {
+            for (int i = 0; i < annotations.size(); i++)
+            {
+                list.add(i);
+            }
+        }
+        return list.toArray(new Integer[list.size()]);
     }
 
-    public String defaultName(final Method method, final CacheDefaults defaults, final String cacheName)
+    private Integer getValueParameter(final List<Set<Annotation>> annotations)
+    {
+        int idx = 0;
+        for (final Set<Annotation> set : annotations)
+        {
+            for (final Annotation a : set)
+            {
+                if (a.annotationType() == CacheValue.class)
+                {
+                    return idx;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private String defaultName(final Method method, final CacheDefaults defaults, final String cacheName)
     {
         if (!cacheName.isEmpty())
         {
@@ -78,35 +230,30 @@ public class CDIJCacheHelper
             }
         }
 
-        String computedName = generatedNames.get(method);
-        if (computedName == null)
+        final StringBuilder name = new StringBuilder(method.getDeclaringClass().getName());
+        name.append(".");
+        name.append(method.getName());
+        name.append("(");
+        final Class<?>[] parameterTypes = method.getParameterTypes();
+        for (int pIdx = 0; pIdx < parameterTypes.length; pIdx++)
         {
-            final StringBuilder name = new StringBuilder(method.getDeclaringClass().getName());
-            name.append(".");
-            name.append(method.getName());
-            name.append("(");
-            final Class<?>[] parameterTypes = method.getParameterTypes();
-            for (int pIdx = 0; pIdx < parameterTypes.length; pIdx++)
+            name.append(parameterTypes[pIdx].getName());
+            if ((pIdx + 1) < parameterTypes.length)
             {
-                name.append(parameterTypes[pIdx].getName());
-                if ((pIdx + 1) < parameterTypes.length)
-                {
-                    name.append(",");
-                }
+                name.append(",");
             }
-            name.append(")");
-            computedName = name.toString();
-            generatedNames.putIfAbsent(method, computedName);
         }
-        return computedName;
+        name.append(")");
+        return name.toString();
     }
 
-    public CacheDefaults findDefaults(final InvocationContext ic)
+    private CacheDefaults findDefaults(final Class<?> targetType, final Method method)
     {
-        if (ic.getTarget() != null && Proxy.isProxyClass(ic.getTarget().getClass())) // target doesnt hold annotations
+        if (Proxy.isProxyClass(targetType)) // target doesnt hold annotations
         {
-            final Class<?> api = ic.getMethod().getDeclaringClass();
-            for (final Class<?> type : ic.getTarget().getClass().getInterfaces())
+            final Class<?> api = method.getDeclaringClass();
+            for (final Class<?> type : targetType
+                                         .getInterfaces())
             {
                 if (!api.isAssignableFrom(type))
                 {
@@ -115,7 +262,7 @@ public class CDIJCacheHelper
                 return extractDefaults(type);
             }
         }
-        return extractDefaults(ic.getTarget().getClass());
+        return extractDefaults(targetType);
     }
 
     private CacheDefaults extractDefaults(final Class<?> type)
@@ -157,7 +304,7 @@ public class CDIJCacheHelper
         return false;
     }
 
-    public CacheKeyGenerator cacheKeyGeneratorFor(final CacheDefaults defaults, final Class<? extends CacheKeyGenerator> cacheKeyGenerator)
+    private CacheKeyGenerator cacheKeyGeneratorFor(final CacheDefaults defaults, final Class<? extends CacheKeyGenerator> cacheKeyGenerator)
     {
         if (!CacheKeyGenerator.class.equals(cacheKeyGenerator))
         {
@@ -174,7 +321,7 @@ public class CDIJCacheHelper
         return defaultCacheKeyGenerator;
     }
 
-    public CacheResolverFactory cacheResolverFactoryFor(final CacheDefaults defaults, final Class<? extends CacheResolverFactory> cacheResolverFactory)
+    private CacheResolverFactory cacheResolverFactoryFor(final CacheDefaults defaults, final Class<? extends CacheResolverFactory> cacheResolverFactory)
     {
         if (!CacheResolverFactory.class.equals(cacheResolverFactory))
         {
@@ -191,7 +338,7 @@ public class CDIJCacheHelper
         return defaultCacheResolverFactory();
     }
 
-    public <T> T instance(final Class<T> type)
+    private <T> T instance(final Class<T> type)
     {
         final Set<Bean<?>> beans = beanManager.getBeans(type);
         if (beans.isEmpty())
@@ -207,19 +354,20 @@ public class CDIJCacheHelper
         final Bean<?> bean = beanManager.resolve(beans);
         final CreationalContext<?> context = beanManager.createCreationalContext(bean);
         final Class<? extends Annotation> scope = bean.getScope();
-        final boolean dependent = Dependent.class.equals(scope);
-        if (!dependent && !beanManager.isNormalScope(scope))
-        {
-            LOGGER.warning("Not normal scope beans (" + type.getName() + ") can leak");
-        }
+        final boolean normalScope = beanManager.isNormalScope(scope);
         try
         {
-            return (T) beanManager.getReference(bean, bean.getBeanClass(), context);
+            final Object reference = beanManager.getReference(bean, bean.getBeanClass(), context);
+            if (!normalScope)
+            {
+                toRelease.add(context);
+            }
+            return (T) reference;
         }
         finally
         {
-            if (dependent)
-            { // TODO: depent or pseudo scope?
+            if (normalScope)
+            { // TODO: release at the right moment, @PreDestroy? question is: do we assume it is thread safe?
                 context.release();
             }
         }
@@ -239,51 +387,271 @@ public class CDIJCacheHelper
         return defaultCacheResolverFactory;
     }
 
-    public Integer[] keyParameterIndexes(final Method method)
+    private Integer[] keyParameterIndexes(final Method method)
     {
-        Integer[] val = parameterIndexes.get(method);
-        if (val == null)
+        final List<Integer> keys = new LinkedList<Integer>();
+        final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
+
+        // first check if keys are specified explicitely
+        for (int i = 0; i < method.getParameterTypes().length; i++)
+        {
+            final Annotation[] annotations = parameterAnnotations[i];
+            for (final Annotation a : annotations)
+            {
+                if (a.annotationType().equals(CacheKey.class))
+                {
+                    keys.add(i);
+                    break;
+                }
+            }
+        }
+
+        // if not then use all parameters but value ones
+        if (keys.isEmpty())
         {
-            final List<Integer> keys = new LinkedList<Integer>();
-            final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
-            
-            // first check if keys are specified explicitely
             for (int i = 0; i < method.getParameterTypes().length; i++)
             {
                 final Annotation[] annotations = parameterAnnotations[i];
+                boolean value = false;
                 for (final Annotation a : annotations)
                 {
-                    if (a.annotationType().equals(CacheKey.class))
+                    if (a.annotationType().equals(CacheValue.class))
                     {
-                        keys.add(i);
+                        value = true;
                         break;
                     }
                 }
+                if (!value) {
+                    keys.add(i);
+                }
             }
+        }
+        return keys.toArray(new Integer[keys.size()]);
+    }
+
+    private static final class MethodKey
+    {
+        private final Method delegate;
+        private final int hash;
+
+        private MethodKey(final Method delegate)
+        {
+            this.delegate = delegate;
+            this.hash = delegate.hashCode();
+        }
 
-            // if not then use all parameters but value ones
-            if (keys.isEmpty())
+        @Override
+        public boolean equals(final Object o)
+        {
+            if (this == o)
             {
-                for (int i = 0; i < method.getParameterTypes().length; i++)
-                {
-                    final Annotation[] annotations = parameterAnnotations[i];
-                    boolean value = false;
-                    for (final Annotation a : annotations)
-                    {
-                        if (a.annotationType().equals(CacheValue.class))
-                        {
-                            value = true;
-                            break;
-                        }
-                    }
-                    if (!value) {
-                        keys.add(i);
-                    }
-                }
+                return true;
             }
-            val = keys.toArray(new Integer[keys.size()]);
-            parameterIndexes.putIfAbsent(method, val);
+            if (o == null || getClass() != o.getClass())
+            {
+                return false;
+            }
+            final MethodKey classKey = MethodKey.class.cast(o);
+            return delegate.equals(classKey.delegate);
+        }
+
+        @Override
+        public int hashCode()
+        {
+            return hash;
+        }
+    }
+
+    // TODO: split it in 5?
+    public static class MethodMeta
+    {
+        private final Class<?>[] parameterTypes;
+        private final List<Set<Annotation>> parameterAnnotations;
+        private final Set<Annotation> annotations;
+        private final Integer[] keysIndices;
+        private final Integer valueIndex;
+        private final Integer[] parameterIndices;
+
+        private final String cacheResultCacheName;
+        private final CacheResolverFactory cacheResultResolverFactory;
+        private final CacheKeyGenerator cacheResultKeyGenerator;
+        private final CacheResult cacheResult;
+
+        private final String cachePutCacheName;
+        private final CacheResolverFactory cachePutResolverFactory;
+        private final CacheKeyGenerator cachePutKeyGenerator;
+        private final boolean cachePutAfter;
+        private final CachePut cachePut;
+
+        private final String cacheRemoveCacheName;
+        private final CacheResolverFactory cacheRemoveResolverFactory;
+        private final CacheKeyGenerator cacheRemoveKeyGenerator;
+        private final boolean cacheRemoveAfter;
+        private final CacheRemove cacheRemove;
+
+        private final String cacheRemoveAllCacheName;
+        private final CacheResolverFactory cacheRemoveAllResolverFactory;
+        private final boolean cacheRemoveAllAfter;
+        private final CacheRemoveAll cacheRemoveAll;
+
+        public MethodMeta(Class<?>[] parameterTypes, List<Set<Annotation>> parameterAnnotations, Set<Annotation> 
+                annotations, Integer[] keysIndices, Integer valueIndex, Integer[] parameterIndices, String 
+                cacheResultCacheName, CacheResolverFactory cacheResultResolverFactory, CacheKeyGenerator 
+                cacheResultKeyGenerator, CacheResult cacheResult, String cachePutCacheName, CacheResolverFactory 
+                cachePutResolverFactory, CacheKeyGenerator cachePutKeyGenerator, boolean cachePutAfter, CachePut cachePut, String
+                cacheRemoveCacheName, CacheResolverFactory cacheRemoveResolverFactory, CacheKeyGenerator 
+                cacheRemoveKeyGenerator, boolean cacheRemoveAfter, CacheRemove cacheRemove, String cacheRemoveAllCacheName,
+                          CacheResolverFactory cacheRemoveAllResolverFactory, boolean
+                                  cacheRemoveAllAfter, CacheRemoveAll cacheRemoveAll)
+        {
+            this.parameterTypes = parameterTypes;
+            this.parameterAnnotations = parameterAnnotations;
+            this.annotations = annotations;
+            this.keysIndices = keysIndices;
+            this.valueIndex = valueIndex;
+            this.parameterIndices = parameterIndices;
+            this.cacheResultCacheName = cacheResultCacheName;
+            this.cacheResultResolverFactory = cacheResultResolverFactory;
+            this.cacheResultKeyGenerator = cacheResultKeyGenerator;
+            this.cacheResult = cacheResult;
+            this.cachePutCacheName = cachePutCacheName;
+            this.cachePutResolverFactory = cachePutResolverFactory;
+            this.cachePutKeyGenerator = cachePutKeyGenerator;
+            this.cachePutAfter = cachePutAfter;
+            this.cachePut = cachePut;
+            this.cacheRemoveCacheName = cacheRemoveCacheName;
+            this.cacheRemoveResolverFactory = cacheRemoveResolverFactory;
+            this.cacheRemoveKeyGenerator = cacheRemoveKeyGenerator;
+            this.cacheRemoveAfter = cacheRemoveAfter;
+            this.cacheRemove = cacheRemove;
+            this.cacheRemoveAllCacheName = cacheRemoveAllCacheName;
+            this.cacheRemoveAllResolverFactory = cacheRemoveAllResolverFactory;
+            this.cacheRemoveAllAfter = cacheRemoveAllAfter;
+            this.cacheRemoveAll = cacheRemoveAll;
+        }
+
+        public boolean isCacheRemoveAfter()
+        {
+            return cacheRemoveAfter;
+        }
+
+        public boolean isCachePutAfter()
+        {
+            return cachePutAfter;
+        }
+
+        public Class<?>[] getParameterTypes()
+        {
+            return parameterTypes;
+        }
+
+        public List<Set<Annotation>> getParameterAnnotations()
+        {
+            return parameterAnnotations;
+        }
+
+        public String getCacheResultCacheName()
+        {
+            return cacheResultCacheName;
+        }
+
+        public CacheResolverFactory getCacheResultResolverFactory()
+        {
+            return cacheResultResolverFactory;
+        }
+
+        public CacheKeyGenerator getCacheResultKeyGenerator()
+        {
+            return cacheResultKeyGenerator;
+        }
+
+        public CacheResult getCacheResult() {
+            return cacheResult;
+        }
+
+        public Integer[] getParameterIndices()
+        {
+            return parameterIndices;
+        }
+
+        public Set<Annotation> getAnnotations()
+        {
+            return annotations;
+        }
+
+        public Integer[] getKeysIndices()
+        {
+            return keysIndices;
+        }
+
+        public Integer getValuesIndex()
+        {
+            return valueIndex;
+        }
+
+        public Integer getValueIndex()
+        {
+            return valueIndex;
+        }
+
+        public String getCachePutCacheName()
+        {
+            return cachePutCacheName;
+        }
+
+        public CacheResolverFactory getCachePutResolverFactory()
+        {
+            return cachePutResolverFactory;
+        }
+
+        public CacheKeyGenerator getCachePutKeyGenerator()
+        {
+            return cachePutKeyGenerator;
+        }
+
+        public CachePut getCachePut()
+        {
+            return cachePut;
+        }
+
+        public String getCacheRemoveCacheName()
+        {
+            return cacheRemoveCacheName;
+        }
+
+        public CacheResolverFactory getCacheRemoveResolverFactory()
+        {
+            return cacheRemoveResolverFactory;
+        }
+
+        public CacheKeyGenerator getCacheRemoveKeyGenerator()
+        {
+            return cacheRemoveKeyGenerator;
+        }
+
+        public CacheRemove getCacheRemove()
+        {
+            return cacheRemove;
+        }
+
+        public String getCacheRemoveAllCacheName()
+        {
+            return cacheRemoveAllCacheName;
+        }
+
+        public CacheResolverFactory getCacheRemoveAllResolverFactory()
+        {
+            return cacheRemoveAllResolverFactory;
+        }
+
+        public boolean isCacheRemoveAllAfter()
+        {
+            return cacheRemoveAllAfter;
+        }
+
+        public CacheRemoveAll getCacheRemoveAll()
+        {
+            return cacheRemoveAll;
         }
-        return val;
     }
 }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheInvocationContextImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheInvocationContextImpl.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheInvocationContextImpl.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheInvocationContextImpl.java Fri Sep  1 15:18:16 2017
@@ -18,13 +18,13 @@
  */
 package org.apache.commons.jcs.jcache.cdi;
 
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Set;
+
 import javax.cache.annotation.CacheInvocationContext;
 import javax.cache.annotation.CacheInvocationParameter;
 import javax.interceptor.InvocationContext;
-import java.lang.annotation.Annotation;
-import java.util.HashSet;
-
-import static java.util.Arrays.asList;
 
 public class CacheInvocationContextImpl<A extends Annotation> extends CacheMethodDetailsImpl<A> implements CacheInvocationContext<A>
 {
@@ -32,9 +32,10 @@ public class CacheInvocationContextImpl<
 
     private CacheInvocationParameter[] parameters = null;
 
-    public CacheInvocationContextImpl(final InvocationContext delegate, final A cacheAnnotation, final String cacheName)
+    public CacheInvocationContextImpl(final InvocationContext delegate, final A cacheAnnotation, final String cacheName,
+                                      final CDIJCacheHelper.MethodMeta meta)
     {
-        super(delegate, cacheAnnotation, cacheName);
+        super(delegate, cacheAnnotation, cacheName, meta);
     }
 
     @Override
@@ -67,15 +68,15 @@ public class CacheInvocationContextImpl<
     {
         final Object[] parameters = delegate.getParameters();
         final Object[] args = parameters == null ? EMPTY_ARGS : parameters;
-        final Class<?>[] parameterTypes = getMethod().getParameterTypes();
-        final Annotation[][] parameterAnnotations = getMethod().getParameterAnnotations();
+        final Class<?>[] parameterTypes = meta.getParameterTypes();
+        final List<Set<Annotation>> parameterAnnotations = meta.getParameterAnnotations();
 
         final CacheInvocationParameter[] parametersAsArray = new CacheInvocationParameter[indexes == null ? args.length : indexes.length];
         if (indexes == null)
         {
             for (int i = 0; i < args.length; i++)
             {
-                parametersAsArray[i] = newCacheInvocationParameterImpl(parameterTypes[i], args[i], parameterAnnotations[i], i);
+                parametersAsArray[i] = newCacheInvocationParameterImpl(parameterTypes[i], args[i], parameterAnnotations.get(i), i);
             }
         }
         else
@@ -83,14 +84,14 @@ public class CacheInvocationContextImpl<
             for (int idx = 0; idx < indexes.length; idx++)
             {
                 final int i = indexes[idx];
-                parametersAsArray[i] = newCacheInvocationParameterImpl(parameterTypes[i], args[i], parameterAnnotations[i], i);
+                parametersAsArray[i] = newCacheInvocationParameterImpl(parameterTypes[i], args[i], parameterAnnotations.get(i), i);
             }
         }
         return parametersAsArray;
     }
 
     private CacheInvocationParameterImpl newCacheInvocationParameterImpl(final Class<?> type, final Object arg,
-                                                                         final Annotation[] annotations, final int i) {
-        return new CacheInvocationParameterImpl(type, arg, new HashSet<Annotation>(asList(annotations)), i);
+                                                                         final Set<Annotation> annotations, final int i) {
+        return new CacheInvocationParameterImpl(type, arg, annotations, i);
     }
 }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheKeyInvocationContextImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheKeyInvocationContextImpl.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheKeyInvocationContextImpl.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheKeyInvocationContextImpl.java Fri Sep  1 15:18:16 2017
@@ -18,26 +18,21 @@
  */
 package org.apache.commons.jcs.jcache.cdi;
 
+import java.lang.annotation.Annotation;
+
 import javax.cache.annotation.CacheInvocationParameter;
-import javax.cache.annotation.CacheKey;
 import javax.cache.annotation.CacheKeyInvocationContext;
-import javax.cache.annotation.CacheValue;
 import javax.interceptor.InvocationContext;
-import java.lang.annotation.Annotation;
-import java.util.Collection;
-import java.util.LinkedList;
 
 public class CacheKeyInvocationContextImpl<A extends Annotation> extends CacheInvocationContextImpl<A> implements CacheKeyInvocationContext<A>
 {
-    private final Integer[] keyIndexes;
     private CacheInvocationParameter[] keyParams = null;
     private CacheInvocationParameter valueParam = null;
 
     public CacheKeyInvocationContextImpl(final InvocationContext delegate, final A annotation, final String name,
-                                         final Integer[] keyIndexes)
+                                         final CDIJCacheHelper.MethodMeta methodMeta)
     {
-        super(delegate, annotation, name);
-        this.keyIndexes = keyIndexes;
+        super(delegate, annotation, name, methodMeta);
     }
 
     @Override
@@ -45,25 +40,7 @@ public class CacheKeyInvocationContextIm
     {
         if (keyParams == null)
         {
-            final Collection<CacheInvocationParameter> keys = new LinkedList<CacheInvocationParameter>();
-            for (final CacheInvocationParameter param : getAllParameters())
-            {
-                for (final Annotation a : param.getAnnotations())
-                {
-                    if (a.annotationType().equals(CacheKey.class))
-                    {
-                        keys.add(param);
-                    }
-                }
-            }
-            if (keys.isEmpty())
-            {
-                keyParams = doGetAllParameters(keyIndexes);
-            }
-            else
-            {
-                keyParams = keys.toArray(new CacheInvocationParameter[keys.size()]);
-            }
+            keyParams = doGetAllParameters(meta.getKeysIndices());
         }
         return keyParams;
     }
@@ -73,17 +50,7 @@ public class CacheKeyInvocationContextIm
     {
         if (valueParam == null)
         {
-            for (final CacheInvocationParameter param : getAllParameters())
-            {
-                for (final Annotation a : param.getAnnotations())
-                {
-                    if (a.annotationType().equals(CacheValue.class))
-                    {
-                        valueParam = param;
-                        return valueParam;
-                    }
-                }
-            }
+            valueParam = meta.getValueIndex() >= 0 ? doGetAllParameters(new Integer[]{meta.getValueIndex()})[0] : null;
         }
         return valueParam;
     }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheMethodDetailsImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheMethodDetailsImpl.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheMethodDetailsImpl.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheMethodDetailsImpl.java Fri Sep  1 15:18:16 2017
@@ -33,13 +33,16 @@ public class CacheMethodDetailsImpl<A ex
     private final Set<Annotation> annotations;
     private final A cacheAnnotation;
     private final String cacheName;
+    protected final CDIJCacheHelper.MethodMeta meta;
 
-    public CacheMethodDetailsImpl(final InvocationContext delegate, final A cacheAnnotation, final String cacheName)
+    public CacheMethodDetailsImpl(final InvocationContext delegate, final A cacheAnnotation, final String cacheName,
+                                  final CDIJCacheHelper.MethodMeta meta)
     {
         this.delegate = delegate;
-        this.annotations = new HashSet<Annotation>(asList(delegate.getMethod().getAnnotations()));
+        this.annotations = meta.getAnnotations();
         this.cacheAnnotation = cacheAnnotation;
         this.cacheName = cacheName;
+        this.meta = meta;
     }
 
     @Override

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CachePutInterceptor.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CachePutInterceptor.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CachePutInterceptor.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CachePutInterceptor.java Fri Sep  1 15:18:16 2017
@@ -19,12 +19,13 @@
 package org.apache.commons.jcs.jcache.cdi;
 
 import java.io.Serializable;
-import java.lang.reflect.Method;
+
 import javax.annotation.Priority;
 import javax.cache.Cache;
-import javax.cache.annotation.CacheDefaults;
 import javax.cache.annotation.CacheKeyInvocationContext;
 import javax.cache.annotation.CachePut;
+import javax.cache.annotation.CacheResolver;
+import javax.cache.annotation.CacheResolverFactory;
 import javax.cache.annotation.GeneratedCacheKey;
 import javax.inject.Inject;
 import javax.interceptor.AroundInvoke;
@@ -42,18 +43,23 @@ public class CachePutInterceptor impleme
     @AroundInvoke
     public Object cache(final InvocationContext ic) throws Throwable
     {
-        final CacheDefaults defaults = helper.findDefaults(ic);
+        final CDIJCacheHelper.MethodMeta methodMeta = helper.findMeta(ic);
 
-        final Method method = ic.getMethod();
-        final CachePut cachePut = method.getAnnotation(CachePut.class);
-        final String cacheName = helper.defaultName(method, defaults, cachePut.cacheName());
-        final boolean afterInvocation = cachePut.afterInvocation();
+        final String cacheName = methodMeta.getCacheResultCacheName();
 
+        final CacheResolverFactory cacheResolverFactory = methodMeta.getCacheResultResolverFactory();
         final CacheKeyInvocationContext<CachePut> context = new CacheKeyInvocationContextImpl<CachePut>(
-                ic, cachePut, cacheName, helper.keyParameterIndexes(method));
+                ic, methodMeta.getCachePut(), cacheName, methodMeta);
+        final CacheResolver cacheResolver = cacheResolverFactory.getCacheResolver(context);
+        final Cache<Object, Object> cache = cacheResolver.resolveCache(context);
+
+        final GeneratedCacheKey cacheKey = methodMeta.getCacheResultKeyGenerator().generateCacheKey(context);
+        final CachePut cachePut = methodMeta.getCachePut();
+        final boolean afterInvocation = methodMeta.isCachePutAfter();
+
         if (!afterInvocation)
         {
-            doCache(context, defaults, cachePut);
+            cache.put(cacheKey, context.getValueParameter());
         }
 
         final Object result;
@@ -67,7 +73,7 @@ public class CachePutInterceptor impleme
             {
                 if (helper.isIncluded(t.getClass(), cachePut.cacheFor(), cachePut.noCacheFor()))
                 {
-                    doCache(context, defaults, cachePut);
+                    cache.put(cacheKey, context.getValueParameter());
                 }
             }
 
@@ -76,16 +82,9 @@ public class CachePutInterceptor impleme
 
         if (afterInvocation)
         {
-            doCache(context, defaults, cachePut);
+            cache.put(cacheKey, context.getValueParameter());
         }
 
         return result;
     }
-
-    private void doCache(final CacheKeyInvocationContext<CachePut> context, final CacheDefaults defaults, final CachePut cachePut)
-    {
-        final Cache<Object, Object> cache = helper.cacheResolverFactoryFor(defaults, cachePut.cacheResolverFactory()).getCacheResolver(context).resolveCache(context);
-        final GeneratedCacheKey key = helper.cacheKeyGeneratorFor(defaults, cachePut.cacheKeyGenerator()).generateCacheKey(context);
-        cache.put(key, context.getValueParameter().getValue());
-    }
 }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveAllInterceptor.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveAllInterceptor.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveAllInterceptor.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveAllInterceptor.java Fri Sep  1 15:18:16 2017
@@ -19,12 +19,13 @@
 package org.apache.commons.jcs.jcache.cdi;
 
 import java.io.Serializable;
-import java.lang.reflect.Method;
+
 import javax.annotation.Priority;
 import javax.cache.Cache;
-import javax.cache.annotation.CacheDefaults;
 import javax.cache.annotation.CacheKeyInvocationContext;
 import javax.cache.annotation.CacheRemoveAll;
+import javax.cache.annotation.CacheResolver;
+import javax.cache.annotation.CacheResolverFactory;
 import javax.inject.Inject;
 import javax.interceptor.AroundInvoke;
 import javax.interceptor.Interceptor;
@@ -41,18 +42,20 @@ public class CacheRemoveAllInterceptor i
     @AroundInvoke
     public Object cache(final InvocationContext ic) throws Throwable
     {
-        final CacheDefaults defaults = helper.findDefaults(ic);
+        final CDIJCacheHelper.MethodMeta methodMeta = helper.findMeta(ic);
 
-        final Method method = ic.getMethod();
-        final CacheRemoveAll cacheRemoveAll = method.getAnnotation(CacheRemoveAll.class);
-        final String cacheName = helper.defaultName(method, defaults, cacheRemoveAll.cacheName());
-        final boolean afterInvocation = cacheRemoveAll.afterInvocation();
+        final String cacheName = methodMeta.getCacheResultCacheName();
 
+        final CacheResolverFactory cacheResolverFactory = methodMeta.getCacheResultResolverFactory();
         final CacheKeyInvocationContext<CacheRemoveAll> context = new CacheKeyInvocationContextImpl<CacheRemoveAll>(
-                ic, cacheRemoveAll, cacheName, helper.keyParameterIndexes(method));
+                ic, methodMeta.getCacheRemoveAll(), cacheName, methodMeta);
+        final CacheResolver cacheResolver = cacheResolverFactory.getCacheResolver(context);
+        final Cache<Object, Object> cache = cacheResolver.resolveCache(context);
+
+        final boolean afterInvocation = methodMeta.isCachePutAfter();
         if (!afterInvocation)
         {
-            removeAll(context, defaults, cacheRemoveAll);
+            cache.removeAll();
         }
 
         final Object result;
@@ -64,9 +67,9 @@ public class CacheRemoveAllInterceptor i
         {
             if (afterInvocation)
             {
-                if (helper.isIncluded(t.getClass(), cacheRemoveAll.evictFor(), cacheRemoveAll.noEvictFor()))
+                if (helper.isIncluded(t.getClass(), methodMeta.getCacheRemoveAll().evictFor(), methodMeta.getCacheRemoveAll().noEvictFor()))
                 {
-                    removeAll(context, defaults, cacheRemoveAll);
+                    cache.removeAll();
                 }
             }
             throw t;
@@ -74,15 +77,9 @@ public class CacheRemoveAllInterceptor i
 
         if (afterInvocation)
         {
-            removeAll(context, defaults, cacheRemoveAll);
+            cache.removeAll();
         }
 
         return result;
     }
-
-    private void removeAll(final CacheKeyInvocationContext<CacheRemoveAll> context, final CacheDefaults defaults, final CacheRemoveAll cacheRemoveAll)
-    {
-        final Cache<Object, Object> cache = helper.cacheResolverFactoryFor(defaults, cacheRemoveAll.cacheResolverFactory()).getCacheResolver(context).resolveCache(context);
-        cache.removeAll();
-    }
 }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveInterceptor.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveInterceptor.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveInterceptor.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheRemoveInterceptor.java Fri Sep  1 15:18:16 2017
@@ -19,12 +19,13 @@
 package org.apache.commons.jcs.jcache.cdi;
 
 import java.io.Serializable;
-import java.lang.reflect.Method;
+
 import javax.annotation.Priority;
 import javax.cache.Cache;
-import javax.cache.annotation.CacheDefaults;
 import javax.cache.annotation.CacheKeyInvocationContext;
 import javax.cache.annotation.CacheRemove;
+import javax.cache.annotation.CacheResolver;
+import javax.cache.annotation.CacheResolverFactory;
 import javax.cache.annotation.GeneratedCacheKey;
 import javax.inject.Inject;
 import javax.interceptor.AroundInvoke;
@@ -42,19 +43,23 @@ public class CacheRemoveInterceptor impl
     @AroundInvoke
     public Object cache(final InvocationContext ic) throws Throwable
     {
-        final CacheDefaults defaults = helper.findDefaults(ic);
+        final CDIJCacheHelper.MethodMeta methodMeta = helper.findMeta(ic);
 
-        final Method method = ic.getMethod();
-        final CacheRemove cacheRemove = method.getAnnotation(CacheRemove.class);
-        final String cacheName = helper.defaultName(method, defaults, cacheRemove.cacheName());
-        final boolean afterInvocation = cacheRemove.afterInvocation();
+        final String cacheName = methodMeta.getCacheResultCacheName();
 
-        final CacheKeyInvocationContext<CacheRemove> context =
-                new CacheKeyInvocationContextImpl<CacheRemove>(ic, cacheRemove, cacheName, helper.keyParameterIndexes(method));
+        final CacheResolverFactory cacheResolverFactory = methodMeta.getCacheResultResolverFactory();
+        final CacheKeyInvocationContext<CacheRemove> context = new CacheKeyInvocationContextImpl<CacheRemove>(
+                ic, methodMeta.getCacheRemove(), cacheName, methodMeta);
+        final CacheResolver cacheResolver = cacheResolverFactory.getCacheResolver(context);
+        final Cache<Object, Object> cache = cacheResolver.resolveCache(context);
+
+        final GeneratedCacheKey cacheKey = methodMeta.getCacheResultKeyGenerator().generateCacheKey(context);
+        final CacheRemove cacheRemove = methodMeta.getCacheRemove();
+        final boolean afterInvocation = methodMeta.isCacheRemoveAfter();
 
         if (!afterInvocation)
         {
-            doRemove(context, defaults, cacheRemove);
+            cache.remove(cacheKey);
         }
 
         final Object result;
@@ -68,7 +73,7 @@ public class CacheRemoveInterceptor impl
             {
                 if (helper.isIncluded(t.getClass(), cacheRemove.evictFor(), cacheRemove.noEvictFor()))
                 {
-                    doRemove(context, defaults, cacheRemove);
+                    cache.remove(cacheKey);
                 }
             }
 
@@ -77,16 +82,9 @@ public class CacheRemoveInterceptor impl
 
         if (afterInvocation)
         {
-            doRemove(context, defaults, cacheRemove);
+            cache.remove(cacheKey);
         }
 
         return result;
     }
-
-    private void doRemove(final CacheKeyInvocationContext<CacheRemove> context, final CacheDefaults defaults, final CacheRemove cacheRemove)
-    {
-        final Cache<Object, Object> cache = helper.cacheResolverFactoryFor(defaults, cacheRemove.cacheResolverFactory()).getCacheResolver(context).resolveCache(context);
-        final GeneratedCacheKey key = helper.cacheKeyGeneratorFor(defaults, cacheRemove.cacheKeyGenerator()).generateCacheKey(context);
-        cache.remove(key);
-    }
 }

Modified: commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheResultInterceptor.java
URL: http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheResultInterceptor.java?rev=1806978&r1=1806977&r2=1806978&view=diff
==============================================================================
--- commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheResultInterceptor.java (original)
+++ commons/proper/jcs/trunk/commons-jcs-jcache/src/main/java/org/apache/commons/jcs/jcache/cdi/CacheResultInterceptor.java Fri Sep  1 15:18:16 2017
@@ -22,7 +22,6 @@ import java.io.Serializable;
 import java.lang.reflect.Method;
 import javax.annotation.Priority;
 import javax.cache.Cache;
-import javax.cache.annotation.CacheDefaults;
 import javax.cache.annotation.CacheKeyInvocationContext;
 import javax.cache.annotation.CacheResolver;
 import javax.cache.annotation.CacheResolverFactory;
@@ -44,20 +43,19 @@ public class CacheResultInterceptor impl
     @AroundInvoke
     public Object cache(final InvocationContext ic) throws Throwable
     {
-        final CacheDefaults defaults = helper.findDefaults(ic);
+        final CDIJCacheHelper.MethodMeta methodMeta = helper.findMeta(ic);
 
-        final Method method = ic.getMethod();
-        final CacheResult cacheResult = method.getAnnotation(CacheResult.class);
-        final String cacheName = helper.defaultName(method, defaults, cacheResult.cacheName());
+        final String cacheName = methodMeta.getCacheResultCacheName();
 
+        final CacheResult cacheResult = methodMeta.getCacheResult();
         final CacheKeyInvocationContext<CacheResult> context = new CacheKeyInvocationContextImpl<CacheResult>(
-                ic, cacheResult, cacheName, helper.keyParameterIndexes(method));
+                ic, cacheResult, cacheName, methodMeta);
 
-        final CacheResolverFactory cacheResolverFactory = helper.cacheResolverFactoryFor(defaults, cacheResult.cacheResolverFactory());
+        final CacheResolverFactory cacheResolverFactory = methodMeta.getCacheResultResolverFactory();
         final CacheResolver cacheResolver = cacheResolverFactory.getCacheResolver(context);
         final Cache<Object, Object> cache = cacheResolver.resolveCache(context);
 
-        final GeneratedCacheKey cacheKey = helper.cacheKeyGeneratorFor(defaults, cacheResult.cacheKeyGenerator()).generateCacheKey(context);
+        final GeneratedCacheKey cacheKey = methodMeta.getCacheResultKeyGenerator().generateCacheKey(context);
 
         Cache<Object, Object> exceptionCache = null; // lazily created
 



Mime
View raw message