@Service
public class UserService {
    public void createUser(String username) {
        // 模拟业务处理
        System.out.println("Creating user: " + username);
    }


    public void deleteUser(String username) {

        // 模拟业务处理
        System.out.println("Deleting user: " + username);
    }
}

@Aspect
@Component
public class LoggingAspect {
    //定义一个匹配userService中所有方法的切点表达式
    @Pointcut("execution(* com.example.codingInAction.service.UserService.*(..))")
    public void userServiceAllMethod() {
    }

    // 在方法执行之前执行的通知
    @Before("userServiceAllMethod()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    // 在方法执行之后执行的通知
    @After("userServiceAllMethod()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }

    // 定义一个只匹配 UserService.createUser 方法的切点表达式
    @Around("execution(* com.example.codingInAction.service.UserService.createUser(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " 方法开始执行");

        Object result = joinPoint.proceed();  // 执行目标方法

        long endTime = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " 方法执行时间: " + (endTime - startTime) + "ms");

        return result;
    }
}


@SpringBootApplication
public class CodingInActionApplication {
    public static void main(String[] args) {
        SpringApplication.run(CodingInActionApplication.class, args);
    }
}

@Override  
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)  
throws BeanCreationException {
	Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  
	if (bean != null) {  
		return bean;  
	}
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {  
	return true;  
}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport  
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {  
  
/**  
* Convenience constant for subclasses: Return value for "do not proxy".  
* @see #getAdvicesAndAdvisorsForBean  
*/  
@Nullable  
protected static final Object[] DO_NOT_PROXY = null;  
  
/**  
* Convenience constant for subclasses: Return value for  
* "proxy without additional interceptors, just the common ones".  
* @see #getAdvicesAndAdvisorsForBean  
*/  
protected static final Object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new Object[0];  
  
  
/** Logger available to subclasses. */  
protected final Log logger = LogFactory.getLog(getClass());  
  
/** Default is global AdvisorAdapterRegistry. */  
private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();  
  
/**  
* Indicates whether or not the proxy should be frozen. Overridden from super  
* to prevent the configuration from becoming frozen too early.  
*/  
private boolean freezeProxy = false;  
  
/** Default is no common interceptors. */  
private String[] interceptorNames = new String[0];  
  
private boolean applyCommonInterceptorsFirst = true;  
  
@Nullable  
private TargetSourceCreator[] customTargetSourceCreators;  
  
@Nullable  
private BeanFactory beanFactory;  
  
private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));  
  
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);  
  
private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);  


// 保存已经处理过的bean信息。这个映射用于保存bean实例到布尔值的映射，指示这些bean是否已经被代理或不需要代理。缓存这些信息可以提高性能，避免重复处理。
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
}

AbstractApplicationContext.java
@Override  
public void refresh() throws BeansException, IllegalStateException {

	// 1. 创建beanFactory   
	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

	// 2.Invoke factory processors registered as beans in the context.  
invokeBeanFactoryPostProcessors(beanFactory);   

	// 3.Register bean processors that intercept bean creation. 
registerBeanPostProcessors(beanFactory);
	// 4. bean的生命周期管理和依赖关系的装配
	finishBeanFactoryInitialization(beanFactory);
}

PostProcessorRegistrationDelegate.java
public static void registerBeanPostProcessors(  
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
}

AbstractBeanFactory.java
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {  

	// Remove from old position, if any  
	this.beanPostProcessors.remove(beanPostProcessor);  
	// Track whether it is instantiation/destruction aware  
	if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {  
		this.hasInstantiationAwareBeanPostProcessors = true;  
	}  
	if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {  
		this.hasDestructionAwareBeanPostProcessors = true;  
	}  
	// Add to end of list  
	this.beanPostProcessors.add(beanPostProcessor);  
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory  
implements AutowireCapableBeanFactory {
	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {  
	
		invokeAwareMethods(beanName, bean);  
			applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);   
	  
		invokeInitMethods(beanName, wrappedBean, mbd);   
	
		applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
	}
	
	@Override  
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  
	throws BeansException {  
	  
		Object result = existingBean;  
		for (BeanPostProcessor processor : getBeanPostProcessors()) {  
			Object current = processor.postProcessAfterInitialization(result, beanName);  
			if (current == null) {  
				return result;  
			}  
			result = current;  
		}  
		return result;  
	}
}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    @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;
    }
  
  
  
  	// 用于为Bean创建代理对象以实现AOP（面向切面编程）的功能
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		// 检查Bean名称是否非空且是否已经在targetSourcedBeans集合中。
		// 如果满足条件，说明这个Bean不需要代理，直接返回原始Bean。
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		// 从advisedBeans缓存中检查是否已经记录了该Bean不需要代理,即缓存中存在且值为Boolean.FALSE，直接返回原始Bean。
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		// 检查Bean是否是Spring的基础设施类，比如Advice、Advisor等
		// 检查是否应该跳过代理该Bean
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			// 如果满足以上条件，记录该Bean不需要代理并返回原始Bean，看又出现了缓存用于提升性能
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		// 获取可以用在该bean 上的增强
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			// 如果没有需要用在该bean的Advice,
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			// 创建该bean的代理对象并记录
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}
		// 如果没有需要用在该bean的Advice, 记录该bean不需要代理直接返回即可
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}
    
}

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
  @Override
	@Nullable
	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}
  
  protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 先找出当前Spring 容器中存在的所有Advisor
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 根据Advisor 找出可以用在当前bean上的增强
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}
  
  // 找出当前Spring 容器中存在的所有Advisor
  protected List<Advisor> findCandidateAdvisors() {
		Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
		return this.advisorRetrievalHelper.findAdvisorBeans();
	}
  
  // 根据Advisor 找出可以用在当前bean上的增强
 	protected List<Advisor> findAdvisorsThatCanApply(
			List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

		ProxyCreationContext.setCurrentProxiedBeanName(beanName);
		try {
			return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
		}
		finally {
			ProxyCreationContext.setCurrentProxiedBeanName(null);
		}
	}


}

public abstract class AopUtils {
  
  public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
		if (candidateAdvisors.isEmpty()) {
			return candidateAdvisors;
		}
		List<Advisor> eligibleAdvisors = new ArrayList<>();
		// 先处理 IntroductionAdvisor
		for (Advisor candidate : candidateAdvisors) {
			if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
				eligibleAdvisors.add(candidate);
			}
		}
		boolean hasIntroductions = !eligibleAdvisors.isEmpty();
		// 再处理其他类型的Advisor
		for (Advisor candidate : candidateAdvisors) {
			if (candidate instanceof IntroductionAdvisor) {
				// already processed
				continue;
			}
			if (canApply(candidate, clazz, hasIntroductions)) {
				eligibleAdvisors.add(candidate);
			}
		}
		return eligibleAdvisors;
	}
  
  // 对于IntroductionAdvisor，canApply(candidate, clazz)最终也是使用这个方法
  public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
		if (advisor instanceof IntroductionAdvisor) {
			return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
		}
		else if (advisor instanceof PointcutAdvisor) {
			PointcutAdvisor pca = (PointcutAdvisor) advisor;
			return canApply(pca.getPointcut(), targetClass, hasIntroductions);
		}
		else {
			// It doesn't have a pointcut so we assume it applies.
			return true;
		}
	}
  
  
  // 这里是真正的过滤逻辑， 先匹配类，再匹配方法
  public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
		Assert.notNull(pc, "Pointcut must not be null");
		if (!pc.getClassFilter().matches(targetClass)) {
			return false;
		}

		MethodMatcher methodMatcher = pc.getMethodMatcher();
		if (methodMatcher == MethodMatcher.TRUE) {
			// No need to iterate the methods if we're matching any method anyway...
			return true;
		}

		IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
		if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
			introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
		}

		Set<Class<?>> classes = new LinkedHashSet<>();
		if (!Proxy.isProxyClass(targetClass)) {
			classes.add(ClassUtils.getUserClass(targetClass));
		}
		classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

		for (Class<?> clazz : classes) {
			Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
			for (Method method : methods) {
				if (introductionAwareMethodMatcher != null ?
						introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
						methodMatcher.matches(method, targetClass)) {
					return true;
				}
			}
		}

		return false;
	}

}

canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) 

public class ProxyFactory extends ProxyCreatorSupport {
	public Object getProxy(@Nullable ClassLoader classLoader) { 
		return createAopProxy().getProxy(classLoader);  
	}
}