Spring源码分析之组件扫描事件监听处理器

// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition();
  try {
    def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
        AnnotationConfigUtils.class.getClassLoader()));
  }
  catch (ClassNotFoundException ex) {
    throw new IllegalStateException(
        "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  }
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}


if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}

if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}

public void afterSingletonsInstantiated() {
  List<EventListenerFactory> factories = getEventListenerFactories();
  String[] beanNames = this.applicationContext.getBeanNamesForType(Object.class);
  for (String beanName : beanNames) {
    if (!ScopedProxyUtils.isScopedTarget(beanName)) {
      Class<?> type = null;
      try {
        type = AutoProxyUtils.determineTargetClass(this.applicationContext.getBeanFactory(), beanName);
      }
      catch (Throwable ex) {
        // An unresolvable bean type, probably from a lazy bean - let's ignore it.
        if (logger.isDebugEnabled()) {
          logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
        }
      }
      if (type != null) {
        if (ScopedObject.class.isAssignableFrom(type)) {
          try {
            type = AutoProxyUtils.determineTargetClass(this.applicationContext.getBeanFactory(),
                ScopedProxyUtils.getTargetBeanName(beanName));
          }
          catch (Throwable ex) {
            // An invalid scoped proxy arrangement - let's ignore it.
            if (logger.isDebugEnabled()) {
              logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
            }
          }
        }
        try {
          processBean(factories, beanName, type);
        }
        catch (Throwable ex) {
          throw new BeanInitializationException("Failed to process @EventListener " +
              "annotation on bean with name '" + beanName + "'", ex);
        }
      }
    }
  }
}

protected List<EventListenerFactory> getEventListenerFactories() {
  Map<String, EventListenerFactory> beans = this.applicationContext.getBeansOfType(EventListenerFactory.class);
  List<EventListenerFactory> allFactories = new ArrayList<EventListenerFactory>(beans.values());
  AnnotationAwareOrderComparator.sort(allFactories);
  return allFactories;
}

private static final String TARGET_NAME_PREFIX = "scopedTarget.";
public static boolean isScopedTarget(String beanName) {
  return (beanName != null && beanName.startsWith(TARGET_NAME_PREFIX));
}

public static final String ORIGINAL_TARGET_CLASS_ATTRIBUTE =
      Conventions.getQualifiedAttributeName(AutoProxyUtils.class, "originalTargetClass");


public static Class<?> determineTargetClass(ConfigurableListableBeanFactory beanFactory, String beanName) {
  if (beanName == null) {
    return null;
  }
  if (beanFactory.containsBeanDefinition(beanName)) {
    BeanDefinition bd = beanFactory.getMergedBeanDefinition(beanName);
    Class<?> targetClass = (Class<?>) bd.getAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE);
    if (targetClass != null) {
      return targetClass;
    }
  }
  return beanFactory.getType(beanName);
}

protected void processBean(final List<EventListenerFactory> factories, final String beanName, final Class<?> targetType) {
  if (!this.nonAnnotatedClasses.contains(targetType)) {
    Map<Method, EventListener> annotatedMethods = null;
    try {
      annotatedMethods = MethodIntrospector.selectMethods(targetType,
          new MethodIntrospector.MetadataLookup<EventListener>() {
            @Override
            public EventListener inspect(Method method) {
              return AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class);
            }
          });
    }
    catch (Throwable ex) {
      // An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.
      if (logger.isDebugEnabled()) {
        logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
      }
    }
    if (CollectionUtils.isEmpty(annotatedMethods)) {
      this.nonAnnotatedClasses.add(targetType);
      if (logger.isTraceEnabled()) {
        logger.trace("No @EventListener annotations found on bean class: " + targetType);
      }
    }
    else {
      // Non-empty set of methods
      for (Method method : annotatedMethods.keySet()) {
        for (EventListenerFactory factory : factories) {
          if (factory.supportsMethod(method)) {
            Method methodToUse = AopUtils.selectInvocableMethod(
                method, this.applicationContext.getType(beanName));
            ApplicationListener<?> applicationListener =
                factory.createApplicationListener(beanName, targetType, methodToUse);
            if (applicationListener instanceof ApplicationListenerMethodAdapter) {
              ((ApplicationListenerMethodAdapter) applicationListener)
                  .init(this.applicationContext, this.evaluator);
            }
            this.applicationContext.addApplicationListener(applicationListener);
            break;
          }
        }
      }
      if (logger.isDebugEnabled()) {
        logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
            beanName + "': " + annotatedMethods);
      }
    }
  }
}

public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
  return new ApplicationListenerMethodAdapter(beanName, type, method);
}


public ApplicationListenerMethodAdapter(String beanName, Class<?> targetClass, Method method) {
  this.beanName = beanName;
  this.method = method;
  this.targetClass = targetClass;
  this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);


  EventListener ann = AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class);
  this.declaredEventTypes = resolveDeclaredEventTypes(method, ann);
  this.condition = (ann != null ? ann.condition() : null);
  this.order = resolveOrder(method);


  this.methodKey = new AnnotatedElementKey(method, targetClass);
}

void init(ApplicationContext applicationContext, EventExpressionEvaluator evaluator) {
  this.applicationContext = applicationContext;
  this.evaluator = evaluator;
}