public interface Interceptor extends Advice {

}

public interface Advised {
    
    /**
     * 被代理的"源"信息
	 * Return the {@code TargetSource} used by this {@code Advised} object.
	 */
	TargetSource getTargetSource();

}

((Advised) proxy).getTargetSource()

@Component
@Aspect
@Slf4j
public class JedisLockAnnotationProcessor {

    @Pointcut("@annotation(com.jacoffee.contentcenter.configuration.JedisLockDesc)")
    public void pointCut() {

    }

    @Around(value = "pointCut()")
    public Object intercept(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        JedisLockDesc jedisLockDesc = signature.getMethod().getAnnotation(JedisLockDesc.class);
        int acquireTimeoutMillis = jedisLockDesc.acquireTimeoutMillis();
        System.out.println("method invocated");
        return pjp.proceed();
    }

}

@Component
public class NodeScheduler {

    @Autowired
    private ShareController shareController;

    @Scheduled(fixedRate = 5000L)
    // @JedisLockDesc(lockPath = "xx", acquireTimeoutMillisString = "${node.lock.timeout}")
    // @JedisLockDesc(lockPath = "xx", acquireTimeoutMillisString = "#{nodeConfig.acquireTimeout}")
    @JedisLockDesc(lockPath = "xx", acquireTimeoutMillisString = "5000")
    public Long testScheduled() {
        shareController.reallyRun();
        return 1L;
    }

}

public class MetadataStore {

    
	static final String METADATA_PATH = "META-INF/spring-configuration-metadata.json";

	private static final String ADDITIONAL_METADATA_PATH = "META-INF/additional-spring-configuration-metadata.json";

    // 初始化的时候会调用该方法进行配置解析
    public ConfigurationMetadata readMetadata() {
 		....       
    }
}

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

    }
    
}

@Import(AspectJAutoProxyRegistrar.class)
public class @interface EnableAspectJAutoProxy {
    
}

// 扫描@Aspect
public class AspectJAutoProxyRegistrar {
    
    public void registerBeanDefinitions(
        AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry
    ) {

        ...
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            // 该方法调用完之后，会将AnnotationAwareAspectJAutoProxyCreator的proxyTargetClass属性设置为true
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        ...
    }

}

public abstract class AopConfigUtils { 

    /**
	 * The bean name of the internally managed auto-proxy creator.
	 */
	public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
			"org.springframework.aop.config.internalAutoProxyCreator";
    
    static {
		// Set up the escalation list...
		APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
		APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
		APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
	}
    
	@Nullable
	private static BeanDefinition registerOrEscalateApcAsRequired(
			Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
        
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        
    }
    
   
}

/**
* 是否需要生成代理的标志位
*/
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);


/**
Subclasses should override this method to return {@code true} if the
given bean should not be considered for auto-proxying by this post-processor.
*/	 
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    return false;
}

if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return null;
}

@Component
@Aspect
@Slf4j
public class JedisLockAnnotationProcessor implements EmbeddedValueResolverAware {
    
}

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    
    return wrapIfNecessary(bean, beanName, cacheKey);
	        
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    
    // 如果不是advisedBean 即不需要生成相应代理的 则直接返回
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    
    // Create proxy if we have advice.
    // 寻找当前bean是否在beforeInitialization阶段注册了Advice
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    
    // 然后正式创建代理
    Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
}

// org.springframework.aop.aspectj.annotation.BeanFactoryAspectJAdvisorsBuilder
public List<Advisor> buildAspectJAdvisors() {
    
    // 判断
    if (this.advisorFactory.isAspect(beanType)) {
        
    }
}

// org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory

@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    
	for (Method method : getAdvisorMethods(aspectClass)) {
        // Advisor具体实现类 InstantiationModelAwarePointcutAdvisorImpl
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

}

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
			int declarationOrderInAspect, String aspectName) {
    
    AspectJExpressionPointcut expressionPointcut = getPointcut(
				candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    
    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    
}

public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
			Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
    this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);

}

List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
	this.advisorsCache.put(beanName, classAdvisors);
}

// org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {

    if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return null;
    }
    
}

// org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator
@Override
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);
}

// org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
     ....
	 return wrapIfNecessary(bean, beanName, cacheKey);
     ....
}

// Generate the proxy class and create a proxy instance.
return createProxyClassAndInstance(enhancer, callbacks);

// org.springframework.aop.aspectj.AspectJAroundAdvice

@Override
public Object invoke(MethodInvocation mi) throws Throwable {

}

@JedisLockDesc(lockPath = "xx", acquireTimeoutMillisString = "5000")
@Scheduled(fixedRate = 5000L)
public Long testScheduled() {}

@Scheduled(fixedRate = 5000L)
@JedisLockDesc(lockPath = "xx", acquireTimeoutMillisString = "5000")
public Long testScheduled() {}

public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable { 

    // this.aspectJAdviceMethod.toString ---> public java.lang.Object com.jacoffee.contentcenter.component.JedisLockAnnotationProcessor.intercept(org.aspectj.lang.ProceedingJoinPoint) throws java.lang.Throwable
    // this.aspectInstanceFactory.getAspectInstance() ---> com.jacoffee.contentcenter.component.JedisLockAnnotationProcessor@cdfc980
    this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs)
    
}

@Transactional
public void A() {
  B()
}

@Transactional
public void B() {}

public SimplePojo implements Pojo {
    
    public void foo() {
        // 若foo是通过代理调用。那么bar方法的调用，将是直接调用
        this.bar()
    }
    
    public void bar() {
    }

}

public SimplePojo implements Pojo {
    
    public void foo() {
        ((Pojo)AopContext.currentProxy()).bar();
    }
    
    public void bar() {
    }

}

@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    // 这里存放的是代理之前的，所以肯定和下面的一样了 = this.earlyProxyReferences.remove(cacheKey)
    this.earlyProxyReferences.put(cacheKey, bean);
    return wrapIfNecessary(bean, beanName, cacheKey);
}

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}