在日常的开发中，我们经常会用到类似的缓存。通常的想法是：
先查询缓存，如果缓存中存在，返回缓存中的值，如果缓存不存在，调用相应的业务系统操作查询（这里业务操作查询通常是需要费点时间的）并返回。若有数据，放入缓存中供下次使用。
这句话第一反应就是，如果缓存中没有值，且业务查询也没有返回值。这样，就需要设定一个特别的标识，避免这种没值的多次查询。
sping中到处都是这样的例子，拿 AbstractFallbackTransactionAttributeSource 参考，getTransactionAttribute就是很好的例子：
/* * Copyright 2002-2015 the original author or authors. * * Licensed 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 * * http://www.apache.org/licenses/LICENSE-2.0 * * 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.springframework.transaction.interceptor;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.core.BridgeMethodResolver;import org.springframework.util.ClassUtils;import org.springframework.util.ObjectUtils;/** * Abstract implementation of {@link TransactionAttributeSource} that caches * attributes for methods and implements a fallback policy: 1. specific target * method; 2. target class; 3. declaring method; 4. declaring class/interface. * * Defaults to using the target class's transaction attribute if none is * associated with the target method. Any transaction attribute associated with * the target method completely overrides a class transaction attribute. * If none found on the target class, the interface that the invoked method * has been called through (in case of a JDK proxy) will be checked. * *
This implementation caches attributes by method after they are first used. * If it is ever desirable to allow dynamic changing of transaction attributes * (which is very unlikely), caching could be made configurable. Caching is * desirable because of the cost of evaluating rollback rules. * * @author Rod Johnson * @author Juergen Hoeller * @since 1.1 */public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource { /** * Canonical value held in cache to indicate no transaction attribute was * found for this method, and we don't need to look again. */ private final static TransactionAttribute NULL_TRANSACTION_ATTRIBUTE = new DefaultTransactionAttribute(); /** * Logger available to subclasses. *
As this base class is not marked Serializable, the logger will be recreated * after serialization - provided that the concrete subclass is Serializable. */ protected final Log logger = LogFactory.getLog(getClass()); /** * Cache of TransactionAttributes, keyed by DefaultCacheKey (Method + target Class). *
As this base class is not marked Serializable, the cache will be recreated * after serialization - provided that the concrete subclass is Serializable. */ final Map
attributeCache = new ConcurrentHashMap (1024); /** * Determine the transaction attribute for this method invocation. * Defaults to the class's transaction attribute if no method attribute is found. * @param method the method for the current invocation (never {@code null}) * @param targetClass the target class for this invocation (may be {@code null}) * @return TransactionAttribute for this method, or {@code null} if the method * is not transactional */ @Override public TransactionAttribute getTransactionAttribute(Method method, Class
targetClass) { // First, see if we have a cached value. Object cacheKey = getCacheKey(method, targetClass); Object cached = this.attributeCache.get(cacheKey); if (cached != null) { // Value will either be canonical value indicating there is no transaction attribute, // or an actual transaction attribute. if (cached == NULL_TRANSACTION_ATTRIBUTE) { return null; } else { return (TransactionAttribute) cached; } } else { // We need to work it out. TransactionAttribute txAtt = computeTransactionAttribute(method, targetClass); // Put it in the cache. if (txAtt == null) { this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE); } else { if (logger.isDebugEnabled()) { Class classToLog = (targetClass != null ? targetClass : method.getDeclaringClass()); logger.debug("Adding transactional method '" + classToLog.getSimpleName() + "." + method.getName() + "' with attribute: " + txAtt); } this.attributeCache.put(cacheKey, txAtt); } return txAtt; } } /** * Determine a cache key for the given method and target class. * Must not produce same key for overloaded methods. * Must produce same key for different instances of the same method. * @param method the method (never {@code null}) * @param targetClass the target class (may be {@code null}) * @return the cache key (never {@code null}) */ protected Object getCacheKey(Method method, Class
targetClass) { return new DefaultCacheKey(method, targetClass); } /** * Same signature as {@link #getTransactionAttribute}, but doesn't cache the result. * {@link #getTransactionAttribute} is effectively a caching decorator for this method. * As of 4.1.8, this method can be overridden. * @since 4.1.8 * @see #getTransactionAttribute */ protected TransactionAttribute computeTransactionAttribute(Method method, Class
targetClass) { // Don't allow no-public methods as required. if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) { return null; } // Ignore CGLIB subclasses - introspect the actual user class. Class userClass = ClassUtils.getUserClass(targetClass); // The method may be on an interface, but we need attributes from the target class. // If the target class is null, the method will be unchanged. Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass); // If we are dealing with method with generic parameters, find the original method. specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod); // First try is the method in the target class. TransactionAttribute txAtt = findTransactionAttribute(specificMethod); if (txAtt != null) { return txAtt; } // Second try is the transaction attribute on the target class. txAtt = findTransactionAttribute(specificMethod.getDeclaringClass()); if (txAtt != null) { return txAtt; } if (specificMethod != method) { // Fallback is to look at the original method. txAtt = findTransactionAttribute(method); if (txAtt != null) { return txAtt; } // Last fallback is the class of the original method. return findTransactionAttribute(method.getDeclaringClass()); } return null; } /** * Subclasses need to implement this to return the transaction attribute * for the given method, if any. * @param method the method to retrieve the attribute for * @return all transaction attribute associated with this method * (or {@code null} if none) */ protected abstract TransactionAttribute findTransactionAttribute(Method method); /** * Subclasses need to implement this to return the transaction attribute * for the given class, if any. * @param clazz the class to retrieve the attribute for * @return all transaction attribute associated with this class * (or {@code null} if none) */ protected abstract TransactionAttribute findTransactionAttribute(Class clazz); /** * Should only public methods be allowed to have transactional semantics? * The default implementation returns {@code false}. */ protected boolean allowPublicMethodsOnly() { return false; } /** * Default cache key for the TransactionAttribute cache. */ private static class DefaultCacheKey { private final Method method; private final Class
targetClass; public DefaultCacheKey(Method method, Class targetClass) { this.method = method; this.targetClass = targetClass; } @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof DefaultCacheKey)) { return false; } DefaultCacheKey otherKey = (DefaultCacheKey) other; return (this.method.equals(otherKey.method) && ObjectUtils.nullSafeEquals(this.targetClass, otherKey.targetClass)); } @Override public int hashCode() { return this.method.hashCode() + (this.targetClass != null ? this.targetClass.hashCode() * 29 : 0); } }}