springboot学习demo

/* * Copyright 2002-2021 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 * * https://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.pearl.thread.demo.cache.interceptor; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Supplier; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.aop.framework.AopProxyUtils; import org.springframework.aop.support.AopUtils; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.NoUniqueBeanDefinitionException; import org.springframework.beans.factory.SmartInitializingSingleton; import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils; import org.springframework.cache.Cache; import org.springframework.cache.CacheManager; import org.springframework.context.expression.AnnotatedElementKey; import org.springframework.core.BridgeMethodResolver; import org.springframework.expression.EvaluationContext; import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; import org.springframework.util.CollectionUtils; import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.MultiValueMap; import org.springframework.util.ObjectUtils; import org.springframework.util.ReflectionUtils; import org.springframework.util.StringUtils; import org.springframework.util.function.SingletonSupplier; import org.springframework.util.function.SupplierUtils; /** * Base class for caching aspects, such as the {@link CacheInterceptor} or an * AspectJ aspect. * * <p>This enables the underlying Spring caching infrastructure to be used easily * to implement an aspect for any aspect system. * * <p>Subclasses are responsible for calling relevant methods in the correct order. * * <p>Uses the <b>Strategy</b> design pattern. A {@link CacheOperationSource} is * used for determining caching operations, a {@link KeyGenerator} will build the * cache keys, and a {@link CacheResolver} will resolve the actual cache(s) to use. * * <p>Note: A cache aspect is serializable but does not perform any actual caching * after deserialization. * * @author Costin Leau * @author Juergen Hoeller * @author Chris Beams * @author Phillip Webb * @author Sam Brannen * @author Stephane Nicoll * @since 3.1 */ public abstract class CacheAspectSupport extends AbstractCacheInvoker implements BeanFactoryAware, InitializingBean, SmartInitializingSingleton { protected final Log logger = LogFactory.getLog(getClass()); private final Map<CacheOperationCacheKey, CacheOperationMetadata> metadataCache = new ConcurrentHashMap<>(1024); private final CacheOperationExpressionEvaluator evaluator = new CacheOperationExpressionEvaluator(); @Nullable private CacheOperationSource cacheOperationSource; private SingletonSupplier<KeyGenerator> keyGenerator = SingletonSupplier.of(SimpleKeyGenerator::new); @Nullable private SingletonSupplier<CacheResolver> cacheResolver; @Nullable private BeanFactory beanFactory; private boolean initialized = false; /** * Configure this aspect with the given error handler, key generator and cache resolver/manager * suppliers, applying the corresponding default if a supplier is not resolvable. * @since 5.1 */ public void configure( @Nullable Supplier<CacheErrorHandler> errorHandler, @Nullable Supplier<KeyGenerator> keyGenerator, @Nullable Supplier<CacheResolver> cacheResolver, @Nullable Supplier<CacheManager> cacheManager) { this.errorHandler = new SingletonSupplier<>(errorHandler, SimpleCacheErrorHandler::new); this.keyGenerator = new SingletonSupplier<>(keyGenerator, SimpleKeyGenerator::new); this.cacheResolver = new SingletonSupplier<>(cacheResolver, () -> SimpleCacheResolver.of(SupplierUtils.resolve(cacheManager))); } /** * Set one or more cache operation sources which are used to find the cache * attributes. If more than one source is provided, they will be aggregated * using a {@link CompositeCacheOperationSource}. * @see #setCacheOperationSource */ public void setCacheOperationSources(CacheOperationSource... cacheOperationSources) { Assert.notEmpty(cacheOperationSources, "At least 1 CacheOperationSource needs to be specified"); this.cacheOperationSource = (cacheOperationSources.length > 1 ? new CompositeCacheOperationSource(cacheOperationSources) : cacheOperationSources[0]); } /** * Set the CacheOperationSource for this cache aspect. * @since 5.1 * @see #setCacheOperationSources */ public void setCacheOperationSource(@Nullable CacheOperationSource cacheOperationSource) { this.cacheOperationSource = cacheOperationSource; } /** * Return the CacheOperationSource for this cache aspect. */ @Nullable public CacheOperationSource getCacheOperationSource() { return this.cacheOperationSource; } /** * Set the default {@link KeyGenerator} that this cache aspect should delegate to * if no specific key generator has been set for the operation. * <p>The default is a {@link SimpleKeyGenerator}. */ public void setKeyGenerator(KeyGenerator keyGenerator) { this.keyGenerator = SingletonSupplier.of(keyGenerator); } /** * Return the default {@link KeyGenerator} that this cache aspect delegates to. */ public KeyGenerator getKeyGenerator() { return this.keyGenerator.obtain(); } /** * Set the default {@link CacheResolver} that this cache aspect should delegate * to if no specific cache resolver has been set for the operation. * <p>The default resolver resolves the caches against their names and the * default cache manager. * @see #setCacheManager * @see SimpleCacheResolver */ public void setCacheResolver(@Nullable CacheResolver cacheResolver) { this.cacheResolver = SingletonSupplier.ofNullable(cacheResolver); } /** * Return the default {@link CacheResolver} that this cache aspect delegates to. */ @Nullable public CacheResolver getCacheResolver() { return SupplierUtils.resolve(this.cacheResolver); } /** * Set the {@link CacheManager} to use to create a default {@link CacheResolver}. * Replace the current {@link CacheResolver}, if any. * @see #setCacheResolver * @see SimpleCacheResolver */ public void setCacheManager(CacheManager cacheManager) { this.cacheResolver = SingletonSupplier.of(new SimpleCacheResolver(cacheManager)); } /** * Set the containing {@link BeanFactory} for {@link CacheManager} and other * service lookups. * @since 4.3 */ @Override public void setBeanFactory(BeanFactory beanFactory) { this.beanFactory = beanFactory; } @Override public void afterPropertiesSet() { Assert.state(getCacheOperationSource() != null, "The 'cacheOperationSources' property is required: " + "If there are no cacheable methods, then don't use a cache aspect."); } @Override public void afterSingletonsInstantiated() { if (getCacheResolver() == null) { // Lazily initialize cache resolver via default cache manager... Assert.state(this.beanFactory != null,