@Aspect
@Component
public class CrmCacheAspect {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private ConcurrentHashMap<String, ICacheResultParser> parserMap = new ConcurrentHashMap();

    private ConcurrentHashMap<String, IKeyGenerator> generatorMap = new ConcurrentHashMap();

    private ConcurrentHashMap<String,Boolean> keyMap = new ConcurrentHashMap<>();
    @Pointcut("@annotation(com.bjh.hms.crm.annotation.CrmCache)")
    public void pointCut(){}

    @Around("pointCut() && @annotation(crmCache)")
    public Object joinPoint(ProceedingJoinPoint joinPoint, CrmCache crmCache) throws InstantiationException, IllegalAccessException {
        String value = "";
        String key = "";
        Object result = "";
        try {
            key = getKey(crmCache,joinPoint);
            value = stringRedisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            XxlJobHelper.log("获取缓存{}失败：{}",crmCache.key(),e);
        } finally {
            if (StringUtils.isBlank(value)) {
                value = synchronizeCache(key, joinPoint, crmCache);
            }
            result = getResult(crmCache, value, joinPoint);
        }
        return result;
    }

    private Object getResult(CrmCache crmCache,
                             String value,
                             ProceedingJoinPoint joinPoint) throws InstantiationException, IllegalAccessException {
        if (value == null) {
            return null;
        }
        String name = crmCache.parser().getName();
        ICacheResultParser iCacheResultParser;
        if (parserMap.containsKey(name)) {
            iCacheResultParser = parserMap.get(name);
        } else {
            iCacheResultParser = crmCache.parser().newInstance();
            parserMap.put(name,iCacheResultParser);
        }
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Class returnType = signature.getReturnType();
        Object parse = iCacheResultParser.parse(value, returnType);
        return parse;
    }

    /**
     * Title: 解决redis并发穿透
     * @author 2021/8/13 17:15
     * @return java.lang.String
     */
    private String synchronizeCache(String key,
                                    ProceedingJoinPoint joinPoint,
                                    CrmCache crmCache) {
        String value = "";
        //暂停100-200ms，线程顺序执行
        try {
            Thread.sleep((int)(Math.random()*(200 - 100 + 1) + 100));
        } catch (InterruptedException e) {
            XxlJobHelper.log("synchronizeCache error {}", ExceptionUtil.stacktraceToString(e));
        }
        while (StringUtils.isBlank(value = stringRedisTemplate.opsForValue().get(key))
        && (keyMap.get(key) == null || keyMap.get(key))){
            //防止重复调用
            if (keyMap.get(key) == null || !keyMap.get(key)) {
                keyMap.put(key,true);
                Object proceed = null;
                try {
                    proceed = joinPoint.proceed();
                } catch (Throwable e) {
                    XxlJobHelper.log("处理失败：{}",ExceptionUtil.stacktraceToString(e));
                }
                putValueByRedis(key,proceed,crmCache);
                keyMap.put(key,false);
            }
        }
        keyMap.remove(key);
        return value;
    }

    private void putValueByRedis(String key, Object value, CrmCache crmCache) {
        if (value == null) {
            return;
        }
        if (value instanceof String) {
            stringRedisTemplate.opsForValue().set(key, value.toString());
        } else {
            String jsonString = JSONObject.toJSONString(value);
            stringRedisTemplate.opsForValue().set(key,jsonString);
        }
        //-1代表不过期
        if (crmCache.expire() != -1) {
            stringRedisTemplate.expire(key, crmCache.expire(), TimeUnit.MINUTES);
        }
    }

    private String getKey(CrmCache crmCache, ProceedingJoinPoint joinPoint) throws InstantiationException, IllegalAccessException {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Object[] args = joinPoint.getArgs();
        String iKeyGeneratorName = crmCache.generator().getName();
        String key = crmCache.key();
        IKeyGenerator iKeyGenerator = null;
        if (generatorMap.containsKey(iKeyGeneratorName)) {
            iKeyGenerator = generatorMap.get(iKeyGeneratorName);
        } else {
            iKeyGenerator = crmCache.generator().newInstance();
            generatorMap.put(iKeyGeneratorName,iKeyGenerator);
        }
        return iKeyGenerator.generate(key,method,args);
    }

}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // 确定是否有aspect注解
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    //解析注解
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        //此处会给有自定义注解的bean创建代理类返回
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }//我们主要分析一下shouldSkip方法
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        // Create proxy here if we have a custom TargetSource.
        // Suppresses unnecessary default instantiation of the target bean:
        // The TargetSource will handle target instances in a custom fashion.
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        // TODO: Consider optimization by caching the list of the aspect names
        //主要这里获取了注解
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        for (Advisor advisor : candidateAdvisors) {
            if (advisor instanceof AspectJPointcutAdvisor &&
                    ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
                return true;
            }
        }
        return super.shouldSkip(beanClass, beanName);
    }

//此方法分为两步
    protected List<Advisor> findCandidateAdvisors() {
        // Add all the Spring advisors found according to superclass rules.
        //第一步从bean工厂中找到所有Advisor的实现类
        List<Advisor> advisors = super.findCandidateAdvisors();
        // Build Advisors for all AspectJ aspects in the bean factory.
        if (this.aspectJAdvisorsBuilder != null) {
        //主要是第二步：从bean工厂中找到所有带有@aspect注解的类
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
        return advisors;
    }

public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = this.aspectBeanNames;

        if (aspectNames == null) {
            synchronized (this) {
                aspectNames = this.aspectBeanNames;
                if (aspectNames == null) {
                    List<Advisor> advisors = new ArrayList<>();
                    aspectNames = new ArrayList<>();
                    //获取所有类
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                            this.beanFactory, Object.class, true, false);
                    for (String beanName : beanNames) {
                        if (!isEligibleBean(beanName)) {
                            continue;
                        }
                        // We must be careful not to instantiate beans eagerly as in this case they
                        // would be cached by the Spring container but would not have been weaved.
                        Class<?> beanType = this.beanFactory.getType(beanName);
                        if (beanType == null) {
                            continue;
                        }
                        //改类是否是我们写的aspect注解类
                        if (this.advisorFactory.isAspect(beanType)) {
                            aspectNames.add(beanName);
                            AspectMetadata amd = new AspectMetadata(beanType, beanName);
                            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                MetadataAwareAspectInstanceFactory factory =
                                        new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                //开始在这里解析
                                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                if (this.beanFactory.isSingleton(beanName)) {
                                    this.advisorsCache.put(beanName, classAdvisors);
                                }
                                else {
                                    this.aspectFactoryCache.put(beanName, factory);
                                }
                                advisors.addAll(classAdvisors);
        .......
        return advisors;
    }

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    //获取我们的注解类
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        //获取名称
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
        validate(aspectClass);

        // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
        // so that it will only instantiate once.
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
                new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

        List<Advisor> advisors = new ArrayList<>();
        //这里循环获取我们类的方法，找到除Pointcut注解外的注解方法
        for (Method method : getAdvisorMethods(aspectClass)) {
        //解析方法，如果找到Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class注解，则返回InstantiationModelAwarePointcutAdvisorImpl生成类
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        .......

        return advisors;
    }

@Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        //遍历所有后置处理器，但是我们只看AbstractAutoProxyCreator类的
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

//调用此方法
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        //是否有注解
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //有则创建代理类返回
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    //config.isProxyTargetClass()这个默认时true，为什么走cglib代理呢？
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

public class AopAutoConfiguration {
    //jdk和cglib都有注解，但是默认只有一个生效了，就是CglibAutoProxyConfiguration，因为ConditionalOnProperty注解说明了一起
    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = false)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
    public static class JdkDynamicAutoProxyConfiguration {

    }

    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
    public static class CglibAutoProxyConfiguration {

    }

}

//这是校验配置类的时候解析的，路径-》org.springframework.context.annotation.ConditionEvaluator#shouldSkip
    public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    //由于jdk和cglib类都有Conditional的子注解，所以都通过了
        if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
            return false;
        }

        if (phase == null) {
            if (metadata instanceof AnnotationMetadata &&
                    ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
                return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
            }
            return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
        }

        List<Condition> conditions = new ArrayList<>();
        //找到ConditionalOnProperty注解
        for (String[] conditionClasses : getConditionClasses(metadata)) {
            for (String conditionClass : conditionClasses) {
                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
                conditions.add(condition);
            }
        }

        AnnotationAwareOrderComparator.sort(conditions);

        for (Condition condition : conditions) {
            ConfigurationPhase requiredPhase = null;
            if (condition instanceof ConfigurationCondition) {
                requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
            }
            //开始检验是否匹配
            if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
                return true;
            }
        }

        return false;
    }

public final boolean matches(ConditionContext context,
            AnnotatedTypeMetadata metadata) {
        String classOrMethodName = getClassOrMethodName(metadata);
        try {
        //走这里查看OnPropertyCondition匹配即可
            ConditionOutcome outcome = getMatchOutcome(context, metadata);
            logOutcome(classOrMethodName, outcome);
            recordEvaluation(context, classOrMethodName, outcome);
            return outcome.isMatch();
        }
        ......
    }

private void collectProperties(PropertyResolver resolver, List<String> missing,
                List<String> nonMatching) {
            for (String name : this.names) {
                String key = this.prefix + name;
                if (resolver.containsProperty(key)) {
                    if (!isMatch(resolver.getProperty(key), this.havingValue)) {
                        nonMatching.add(name);
                    }
                }
                else {
                //直接查看关键代码，如果配置文件中没有该属性，查看是否注解中写了matchIfMissing属性，而我们的cglib是true，所以，不会missing，而是装配起来了，所以默认走cglib代理
                    if (!this.matchIfMissing) {
                        missing.add(name);
                    }
                }
            }
        }

//CglibAopProxy
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Object target = null;
            TargetSource targetSource = this.advised.getTargetSource();
            try {
                .....
                //获取是否有拦截链，并不是我们的请求拦截器，这里把切面认为是一种拦截器了
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                Object retVal;
                // Check whether we only have one InvokerInterceptor: that is,
                // no real advice, but just reflective invocation of the target.
                if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                    // We can skip creating a MethodInvocation: just invoke the target directly.
                    // Note that the final invoker must be an InvokerInterceptor, so we know
                    // it does nothing but a reflective operation on the target, and no hot
                    // swapping or fancy proxying.
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                    retVal = methodProxy.invoke(target, argsToUse);
                }
                else {
                    // We need to create a method invocation...
                    //主要就是走后面的.proceed()方法
                    retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
                }
                retVal = processReturnType(proxy, target, method, retVal);
                return retVal;
            .....
                }
            }
        }

//这里就像走我们的请求过滤器一样，每个拦截器都走一遍，最后都调用proceed()再回到这个方法，直到++this.currentInterceptorIndex到头终止
    public Object proceed() throws Throwable {
        //    We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
            //别的我们不看，就看我们自己定义的@around
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }