public void refresh() throws BeansException, IllegalStateException {    synchronized (this.startupShutdownMonitor) {  // Prepare this context for refreshing. 准备刷新    prepareRefresh();
    // Tell the subclass to refresh the internal bean factory.    /*     * 刷新内部BeanFactory     * ClassPathXmlApplicationContext：1.新建BeanFactory，2.解析xml，3.封装成BeanDefintion对象     * AnnotationConfigApplicationContext: 获取GenericApplicationContext中的beanFactory     */    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // Prepare the bean factory for use in this context.    // 为BeanFactory进行必要的准备工作    prepareBeanFactory(beanFactory);
    try {        // Allows post-processing of the bean factory in context subclasses.        // 进行额外的后置处理        postProcessBeanFactory(beanFactory);
        // Invoke factory processors registered as beans in the context.        // 执行1.BeanDefinitionResgistryPostProcessor、2.BeanFactoryPostProcessor的回调        invokeBeanFactoryPostProcessors(beanFactory);
        // Register bean processors that intercept bean creation.        // 实例化所有实现了BeanPostProcessor接口的类并注册到容器中去        registerBeanPostProcessors(beanFactory);
        // Initialize message source for this context. 国际化        initMessageSource();
        // Initialize event multicaster for this context. 初始化事件类        initApplicationEventMulticaster();
        // Initialize other special beans in specific context subclasses. 子容器自定义实现        onRefresh();
        // Check for listener beans and register them. 注册事件        registerListeners();
        // Instantiate all remaining (non-lazy-init) singletons.        //1.bean实例化，2.ioc 3.注解支持 4.BeanPostProssor执行 5.AOP入口        finishBeanFactoryInitialization(beanFactory);
        // Last step: publish corresponding event.        finishRefresh();    }  catch (BeansException ex) {        if (logger.isWarnEnabled()) {            logger.warn("Exception encountered during context initialization - " +                    "cancelling refresh attempt: " + ex);        }
        // Destroy already created singletons to avoid dangling resources.        destroyBeans();
        // Reset 'active' flag.        cancelRefresh(ex);
        // Propagate exception to caller.        throw ex;    }
    finally {        // Reset common introspection caches in Spring's core, since we        // might not ever need metadata for singleton beans anymore...        resetCommonCaches();    }}

@Componentpublic class CircleClassA {    public CircleClassA() {        System.out.println("====CircleClassA====");    }
    @Autowired    private CircleClassB circleClassB;}
@Componentpublic class CircleClassB {    public CircleClassB() {        System.out.println("====CircleClassB====");    }
    @Autowired    private CircleClassA circleClassA;}

@Component@Aspect@Slf4jpublic class MyAspect {    @Pointcut("execution( * org.example.springaop.*.*(..))")    public void pointCut(){};
    @Around("pointCut()")    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {        long start=System.currentTimeMillis();        Object result = joinPoint.proceed();        long end = System.currentTimeMillis();        log.info("{} invoke before at {} , after at {} cost: {}ms",joinPoint.getSignature().getName(),start,end,(end-start));        return result;    }}

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Import(AspectJAutoProxyRegistrar.class)public @interface EnableAspectJAutoProxy {
   boolean proxyTargetClass() default false;
   boolean exposeProxy() default false;
}

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override    public void registerBeanDefinitions(            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {        //注册AnnotationAwareAspectJAutoProxyCreator，AOP注解解析类        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy =                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);        if (enableAspectJAutoProxy != null) {            /*             * false：1。实现了接口的使用JDK的Proxy实现代理。2.没有接口的使用cglib实现代理             * true：全部使用cglib实现代理             */            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);            }            // 是否暴露代理对象            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);            }        }    }}

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {  if (bean != null) {      Object cacheKey = getCacheKey(bean.getClass(), beanName);      if (this.earlyProxyReferences.remove(cacheKey) != bean) {        //如果它适合被代理，则需要封装指定 bean            return wrapIfNecessary(bean, beanName, cacheKey);        }    }    return bean;}
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;  }  //给定的 bean 类是否代表一个基础设施类 ，基础设施类不应代理 ，或者配置了指定 bean 不需要自动代理  if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {      this.advisedBeans.put(cacheKey, Boolean.FALSE);      return bean;  }    //如果当前的Bean有advice则创建当前类的代理类  // 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 Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    MethodInvocation invocation;    Object oldProxy = null;    boolean setProxyContext = false;
    TargetSource targetSource = this.advised.targetSource;    Object target = null;
    try {        //忽略equals、hashcode        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {            // The target does not implement the equals(Object) method itself.            return equals(args[0]);        }        else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {            // The target does not implement the hashCode() method itself.            return hashCode();        }        else if (method.getDeclaringClass() == DecoratingProxy.class) {            // There is only getDecoratedClass() declared -> dispatch to proxy config.            return AopProxyUtils.ultimateTargetClass(this.advised);        }        else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&                method.getDeclaringClass().isAssignableFrom(Advised.class)) {            // Service invocations on ProxyConfig with the proxy config...            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);        }
        Object retVal;        //暴露代理类        if (this.advised.exposeProxy) {            // Make invocation available if necessary.            oldProxy = AopContext.setCurrentProxy(proxy);            setProxyContext = true;        }
        // Get as late as possible to minimize the time we "own" the target,        // in case it comes from a pool.获取被代理类        target = targetSource.getTarget();        Class<?> targetClass = (target != null ? target.getClass() : null);
        // Get the interception chain for this method.从代理工厂中拿到拦截器链        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        // Check whether we have any advice. If we don't, we can fallback on direct        // reflective invocation of the target, and avoid creating a MethodInvocation.        //如果该方法没有拦截器，直接反射调用        if (chain.isEmpty()) {            // 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);        }        else {            // We need to create a method invocation...            //如果该方法有拦截器，则调用拦截器的proceed            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);            // Proceed to the joinpoint through the interceptor chain.            retVal = invocation.proceed();        }
        // Massage return value if necessary.        Class<?> returnType = method.getReturnType();        if (retVal != null && retVal == target &&                returnType != Object.class && returnType.isInstance(proxy) &&                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {            // Special case: it returned "this" and the return type of the method            // is type-compatible. Note that we can't help if the target sets            // a reference to itself in another returned object.            retVal = proxy;        }        else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {            throw new AopInvocationException(                    "Null return value from advice does not match primitive return type for: " + method);        }        return retVal;    }    finally {        if (target != null && !targetSource.isStatic()) {            // Must have come from TargetSource.            targetSource.releaseTarget(target);        }        if (setProxyContext) {            // Restore old proxy.            AopContext.setCurrentProxy(oldProxy);        }    }}

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;        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {            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);    }}