@Component public class MovieRecommender {     private final String catalog;     public MovieRecommender(@Value("${catalog.name}") String catalog) {         this.catalog = catalog;     } }

@Configuration @PropertySource("classpath:application.properties") public class AppConfig { }

public class MutablePropertySources implements PropertySources {
  private final Log logger;
  private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();                ... 省略部分代码}

public abstract class PropertySource<T> {
  protected final Log logger = LogFactory.getLog(getClass());
  protected final String name;
  protected final T source;                ... 省略部分代码}

    public MapPropertySource(String name, Map<String, Object> source) {                super(name, source);        }

* Properties: `org.springframework.core.env.PropertiesPropertySource`

    public PropertiesPropertySource(String name, Properties source) {    super(name, (Map) source);  }

* 命令行参数: `org.springframework.core.env.JOptCommandLinePropertySource`

    public JOptCommandLinePropertySource(String name, OptionSet options) {        super(name, options);    }

public MapPropertySource(String name, Map<String, Object> source) {    super(name, source);}
@Override@Nullablepublic Object getProperty(String name) {    return this.source.get(name);}

    @Override    protected void customizePropertySources(MutablePropertySources propertySources) {        propertySources.addLast(                        new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));        propertySources.addLast(                        new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));    }

protected AbstractEnvironment(MutablePropertySources propertySources) {    this.propertySources = propertySources;    // 新建一个 配置解析器。方法返回: new PropertySourcesPropertyResolver(propertySources);    this.propertyResolver = createPropertyResolver(propertySources);    customizePropertySources(propertySources);}

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

public ConfigurableApplicationContext run(String... args) {    StopWatch stopWatch = new StopWatch();    stopWatch.start();    ConfigurableApplicationContext context = null;    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();    configureHeadlessProperty();    SpringApplicationRunListeners listeners = getRunListeners(args);    listeners.starting();    try {            ApplicationArguments applicationArguments = new DefaultApplicationArguments(                            args);            // 预处理 Environment，如果没有的话，会新建一个。            ConfigurableEnvironment environment = prepareEnvironment(listeners,                            applicationArguments);            configureIgnoreBeanInfo(environment);            Banner printedBanner = printBanner(environment);            context = createApplicationContext();            exceptionReporters = getSpringFactoriesInstances(                            SpringBootExceptionReporter.class,                            new Class[] { ConfigurableApplicationContext.class }, context);            prepareContext(context, environment, listeners, applicationArguments,                            printedBanner);            refreshContext(context);            afterRefresh(context, applicationArguments);            stopWatch.stop();            if (this.logStartupInfo) {                    new StartupInfoLogger(this.mainApplicationClass)                                    .logStarted(getApplicationLog(), stopWatch);            }            listeners.started(context);            callRunners(context, applicationArguments);    }    catch (Throwable ex) {            handleRunFailure(context, ex, exceptionReporters, listeners);            throw new IllegalStateException(ex);    }
    try {            listeners.running(context);    }    catch (Throwable ex) {            handleRunFailure(context, ex, exceptionReporters, null);            throw new IllegalStateException(ex);    }    return context;}

private ConfigurableEnvironment prepareEnvironment(            SpringApplicationRunListeners listeners,            ApplicationArguments applicationArguments) {    // Create and configure the environment    ConfigurableEnvironment environment = getOrCreateEnvironment();    configureEnvironment(environment, applicationArguments.getSourceArgs());    listeners.environmentPrepared(environment);    bindToSpringApplication(environment);    if (this.webApplicationType == WebApplicationType.NONE) {            environment = new EnvironmentConverter(getClassLoader())                            .convertToStandardEnvironmentIfNecessary(environment);    }    ConfigurationPropertySources.attach(environment);    return environment;}

/** * Annotation used at the field or method/constructor parameter level * that indicates a default value expression for the annotated element. * * <p>Typically used for expression-driven or property-driven dependency injection. * Also supported for dynamic resolution of handler method arguments &mdash; for * example, in Spring MVC. * * <p>A common use case is to inject values using * <code>#{systemProperties.myProp}</code> style SpEL (Spring Expression Language) * expressions. Alternatively, values may be injected using * <code>${my.app.myProp}</code> style property placeholders. * * <p>Note that actual processing of the {@code @Value} annotation is performed * by a {@link org.springframework.beans.factory.config.BeanPostProcessor * BeanPostProcessor} which in turn means that you <em>cannot</em> use * {@code @Value} within * {@link org.springframework.beans.factory.config.BeanPostProcessor * BeanPostProcessor} or * {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessor} * types. Please consult the javadoc for the {@link AutowiredAnnotationBeanPostProcessor} * class (which, by default, checks for the presence of this annotation). * * @author Juergen Hoeller * @since 3.0 * @see AutowiredAnnotationBeanPostProcessor * @see Autowired * @see org.springframework.beans.factory.config.BeanExpressionResolver * @see org.springframework.beans.factory.support.AutowireCandidateResolver#getSuggestedValue */@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Value {
  /**   * The actual value expression such as <code>#{systemProperties.myProp}</code>   * or property placeholder such as <code>${my.app.myProp}</code>.   */  String value();
}

public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor,    MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {}

@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);    try {            metadata.inject(bean, beanName, pvs);    }    catch (BeanCreationException ex) {            throw ex;    }    catch (Throwable ex) {            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);    }    return pvs;}

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {        // Fall back to class name as cache key, for backwards compatibility with custom callers.        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());        // Quick check on the concurrent map first, with minimal locking.        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);        if (InjectionMetadata.needsRefresh(metadata, clazz)) {                synchronized (this.injectionMetadataCache) {                        metadata = this.injectionMetadataCache.get(cacheKey);                        if (InjectionMetadata.needsRefresh(metadata, clazz)) {                                if (metadata != null) {                                        metadata.clear(pvs);                                }                                metadata = buildAutowiringMetadata(clazz);                                this.injectionMetadataCache.put(cacheKey, metadata);                        }                }        }        return metadata;}

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {    // 判断 clazz 是否标注有待处理的注解    if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {            return InjectionMetadata.EMPTY;    }
    List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();    Class<?> targetClass = clazz;
    // 循环对当前类及父类的字段和方法做处理。    do {            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
            ReflectionUtils.doWithLocalFields(targetClass, field -> {                    MergedAnnotation<?> ann = findAutowiredAnnotation(field);                    if (ann != null) {                            if (Modifier.isStatic(field.getModifiers())) {                                    if (logger.isInfoEnabled()) {                                            logger.info("Autowired annotation is not supported on static fields: " + field);                                    }                                    return;                            }                            boolean required = determineRequiredStatus(ann);                            currElements.add(new AutowiredFieldElement(field, required));                    }            });
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {                    Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);                    if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {                            return;                    }                    MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);                    if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {                            if (Modifier.isStatic(method.getModifiers())) {                                    if (logger.isInfoEnabled()) {                                            logger.info("Autowired annotation is not supported on static methods: " + method);                                    }                                    return;                            }                            if (method.getParameterCount() == 0) {                                    if (logger.isInfoEnabled()) {                                            logger.info("Autowired annotation should only be used on methods with parameters: " +                                                            method);                                    }                            }                            boolean required = determineRequiredStatus(ann);                            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);                            currElements.add(new AutowiredMethodElement(method, required, pd));                    }            });
            elements.addAll(0, currElements);            targetClass = targetClass.getSuperclass();    }    while (targetClass != null && targetClass != Object.class);
    // 返回最终的 InjectionMetadata    return InjectionMetadata.forElements(elements, clazz);}

ReflectionUtils.doWithLocalFields(targetClass, field -> {    // 寻找 autowire 的注解    MergedAnnotation<?> ann = findAutowiredAnnotation(field);    // 如果没有对应注解则不处理    if (ann != null) {            // 如果是静态字段则不处理            if (Modifier.isStatic(field.getModifiers())) {                    if (logger.isInfoEnabled()) {                            logger.info("Autowired annotation is not supported on static fields: " + field);                    }                    return;            }            boolean required = determineRequiredStatus(ann);            currElements.add(new AutowiredFieldElement(field, required));    }});

@Nullableprivate MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {    MergedAnnotations annotations = MergedAnnotations.from(ao);    for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {            MergedAnnotation<?> annotation = annotations.get(type);            if (annotation.isPresent()) {                    return annotation;            }    }    return null;}

public AutowiredAnnotationBeanPostProcessor() {    this.autowiredAnnotationTypes.add(Autowired.class);    this.autowiredAnnotationTypes.add(Value.class);    try {            this.autowiredAnnotationTypes.add((Class<? extends Annotation>)                            ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));            logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");    }    catch (ClassNotFoundException ex) {            // JSR-330 API not available - simply skip.    }}