Java tutorial
/** * Licensed to Apereo under one or more contributor license agreements. See the NOTICE file * distributed with this work for additional information regarding copyright ownership. Apereo * licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use * this file except in compliance with the License. You may obtain a copy of the License at the * following location: * * <p>http://www.apache.org/licenses/LICENSE-2.0 * * <p>Unless required by applicable law or agreed to in writing, software distributed under the * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing permissions and * limitations under the License. */ package org.apereo.portal.concurrency.caching; import java.io.Serializable; import java.lang.annotation.AnnotationFormatError; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import javax.management.InstanceAlreadyExistsException; import javax.management.MBeanRegistrationException; import javax.management.MalformedObjectNameException; import javax.management.NotCompliantMBeanException; import javax.management.ObjectName; import javax.servlet.http.HttpServletRequest; import net.sf.ehcache.hibernate.management.impl.EhcacheHibernateMbeanNames; import org.apereo.portal.url.IPortalRequestUtils; import org.apereo.portal.utils.ConcurrentMapUtils; import org.apereo.portal.utils.cache.CacheKey; import org.apereo.portal.utils.web.PortalWebUtils; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jmx.export.MBeanExportOperations; import org.springframework.stereotype.Component; import org.springframework.web.context.request.RequestAttributes; /** * Aspect that caches the results of a method invocation in the current {@link RequestAttributes} * * @author Eric Dalquist */ @Aspect @Component("requestCacheAspect") public class RequestCacheAspect implements InitializingBean { private static final String CACHE_MAP = RequestCacheAspect.class.getName() + ".CACHE_MAP"; private static final Object NULL_PLACEHOLDER = new Object(); protected final Logger logger = LoggerFactory.getLogger(getClass()); private final ConcurrentMap<String, CacheStatistics> methodStats = new ConcurrentHashMap<String, CacheStatistics>(); private final CacheStatistics overallStats = new CacheStatistics(); private IPortalRequestUtils portalRequestUtils; private MBeanExportOperations mBeanExportOperations; @Autowired public void setPortalRequestUtils(IPortalRequestUtils portalRequestUtils) { this.portalRequestUtils = portalRequestUtils; } @Autowired(required = false) public void setmBeanExportOperations(MBeanExportOperations mBeanExportOperations) { this.mBeanExportOperations = mBeanExportOperations; } @Override public void afterPropertiesSet() throws Exception { if (this.mBeanExportOperations != null) { final ObjectName name = new ObjectName( "uPortal:section=Cache,RequestCache=RequestCache,name=OverallStatistics"); registerMbean(this.overallStats, name); } } @Pointcut(value = "execution(public * *(..))") public void anyPublicMethod() { } @Around("anyPublicMethod() && @annotation(requestCache)") public Object cacheRequest(ProceedingJoinPoint pjp, RequestCache requestCache) throws Throwable { final long start = System.nanoTime(); final CacheKey cacheKey = createCacheKey(pjp, requestCache); final HttpServletRequest currentPortalRequest; try { currentPortalRequest = this.portalRequestUtils.getCurrentPortalRequest(); } catch (IllegalStateException e) { logger.trace("No current portal request, will not cache result of: {}", cacheKey); //No current request, simply proceed return pjp.proceed(); } final CacheStatistics cacheStatistics = this.getCacheStatistics(pjp, requestCache); //Check in the cache for a result final ConcurrentMap<CacheKey, Object> cache = PortalWebUtils.getMapRequestAttribute(currentPortalRequest, CACHE_MAP); Object result = cache.get(cacheKey); //Return null if placeholder was cached if (requestCache.cacheNull() && result == NULL_PLACEHOLDER) { final long time = System.nanoTime() - start; cacheStatistics.recordHit(time); overallStats.recordHit(time); logger.debug("Found cached null for invocation of: {}", cacheKey); return null; } //Rethrow if exception was cached if (requestCache.cacheException() && result instanceof ExceptionHolder) { final long time = System.nanoTime() - start; cacheStatistics.recordHit(time); overallStats.recordHit(time); logger.debug("Found cached exception for invocation of: {}", cacheKey); throw ((ExceptionHolder) result).getThrowable(); } //Return cached result if (result != null) { final long time = System.nanoTime() - start; cacheStatistics.recordHit(time); overallStats.recordHit(time); logger.debug("Found cached result for invocation of: {}", cacheKey); return result; } try { //Execute the annotated method result = pjp.proceed(); final long time = System.nanoTime() - start; cacheStatistics.recordMissAndLoad(time); overallStats.recordMissAndLoad(time); if (result != null) { //Cache the not-null result cache.put(cacheKey, result); logger.debug("Cached result for invocation of: {}", cacheKey); } else if (requestCache.cacheNull()) { //If caching nulls cache the placeholder cache.put(cacheKey, NULL_PLACEHOLDER); logger.debug("Cached null for invocation of: {}", cacheKey); } return result; } catch (Throwable t) { final long time = System.nanoTime() - start; cacheStatistics.recordMissAndException(time); overallStats.recordMissAndException(time); if (requestCache.cacheException()) { //If caching exceptions wrapp the exception and cache it cache.put(cacheKey, new ExceptionHolder(t)); logger.debug("Cached exception for invocation of: {}", cacheKey); } throw t; } } protected void registerMbean(Object object, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { this.mBeanExportOperations.registerManagedResource(object, name); } protected final CacheStatistics getCacheStatistics(ProceedingJoinPoint pjp, RequestCache requestCache) { final Signature signature = pjp.getSignature(); final String signatureString = signature.toString(); CacheStatistics cacheStatistics = this.methodStats.get(signatureString); if (cacheStatistics == null) { final CacheStatistics newStats = new CacheStatistics(); cacheStatistics = ConcurrentMapUtils.putIfAbsent(this.methodStats, signatureString, newStats); if (this.mBeanExportOperations != null && cacheStatistics == newStats) { final String nameString = "uPortal:section=Cache,RequestCache=RequestCache,name=" + EhcacheHibernateMbeanNames.mbeanSafe(signatureString); try { final ObjectName name = new ObjectName(nameString); registerMbean(cacheStatistics, name); } catch (MalformedObjectNameException e) { logger.warn( "Failed to create ObjectName {} the corresponding CacheStatistics will not be registered with JMX", nameString, e); } catch (NullPointerException e) { logger.warn( "Failed to create ObjectName {} the corresponding CacheStatistics will not be registered with JMX", nameString, e); } catch (InstanceAlreadyExistsException e) { logger.warn( "ObjectName {} is already registered, the corresponding CacheStatistics will not be registered with JMX", nameString, e); } catch (MBeanRegistrationException e) { logger.warn( "Failed to register ObjectName {} the corresponding CacheStatistics will not be registered with JMX", nameString, e); } catch (NotCompliantMBeanException e) { logger.warn( "Failed to register ObjectName {} the corresponding CacheStatistics will not be registered with JMX", nameString, e); } } } return cacheStatistics; } protected CacheKey createCacheKey(ProceedingJoinPoint pjp, RequestCache requestCache) { final Signature signature = pjp.getSignature(); final Class<?> declaringType = signature.getDeclaringType(); final String signatureLongString = signature.toLongString(); final boolean[] keyMask = requestCache.keyMask(); final Object[] args = pjp.getArgs(); final Object[] keyArgs; if (keyMask.length == 0) { keyArgs = args; } else if (keyMask.length != args.length) { throw new AnnotationFormatError( "RequestCache.keyMask has an invalid length on: " + signature.toLongString()); } else { keyArgs = new Object[args.length]; for (int i = 0; i < args.length; i++) { if (keyMask[i]) { keyArgs[i] = args[i]; } } } return CacheKey.build(signatureLongString, declaringType, keyArgs); } private static class ExceptionHolder implements Serializable { private static final long serialVersionUID = 1L; private final Throwable t; public ExceptionHolder(Throwable t) { this.t = t; } public Throwable getThrowable() { return this.t; } } }