• Spring之环境变量配置

    本地配置实现原理

    项目启动时准备环境

    1. public class SpringApplication {
    2.  
    3.     public ConfigurableApplicationContext run(String... args) {
    4.         long startTime = System.nanoTime();
    5.         DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
    6.         ConfigurableApplicationContext context = null;
    7.         this.configureHeadlessProperty();
    8.         SpringApplicationRunListeners listeners = this.getRunListeners(args);
    9.         listeners.starting(bootstrapContext, this.mainApplicationClass);
    10.  
    11.         try {
    12.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    13.             // 获取环境变量和配置数据
    14.             ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    15.             this.configureIgnoreBeanInfo(environment);
    16.             Banner printedBanner = this.printBanner(environment);
    17.             context = this.createApplicationContext();
    18.             context.setApplicationStartup(this.applicationStartup);
    19.             this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    20.             this.refreshContext(context);
    21.             this.afterRefresh(context, applicationArguments);
    22.             Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    23.             if (this.logStartupInfo) {
    24.                 (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
    25.             }
    26.  
    27.             listeners.started(context, timeTakenToStartup);
    28.             this.callRunners(context, applicationArguments);
    29.         } catch (Throwable var12) {
    30.             this.handleRunFailure(context, var12, listeners);
    31.             throw new IllegalStateException(var12);
    32.         }
    33.  
    34.         try {
    35.             Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
    36.             listeners.ready(context, timeTakenToReady);
    37.             return context;
    38.         } catch (Throwable var11) {
    39.             this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
    40.             throw new IllegalStateException(var11);
    41.         }
    42.     }
    43. }

    获取系统环境变量和配置数据，加载为Environment

    1.     private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    2.         ConfigurableEnvironment environment = this.getOrCreateEnvironment();
    3.         this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
    4.         ConfigurationPropertySources.attach((Environment)environment);
    5.         listeners.environmentPrepared(bootstrapContext, (ConfigurableEnvironment)environment);
    6.         DefaultPropertiesPropertySource.moveToEnd((ConfigurableEnvironment)environment);
    7.         Assert.state(!((ConfigurableEnvironment)environment).containsProperty("spring.main.environment-prefix"), "Environment prefix cannot be set via properties.");
    8.         this.bindToSpringApplication((ConfigurableEnvironment)environment);
    9.         if (!this.isCustomEnvironment) {
    10.             environment = this.convertEnvironment((ConfigurableEnvironment)environment);
    11.         }
    12.  
    13.         ConfigurationPropertySources.attach((Environment)environment);
    14.         return (ConfigurableEnvironment)environment;
    15.     }

    listeners.environmentPrepared(bootstrapContext, (ConfigurableEnvironment)environment);

    1. public interface PropertySourceLoader {
    2.     String[] getFileExtensions();
    3.  
    4.     List> load(String name, Resource resource) throws IOException;
    5. }

    spring在5个路径下(classpath/*, classpath/config/*, /*, /config/*, /config/*/*)找application.properties和application.yml配置文件。

    注：默认先读取application.properties文件，如果application.properties和application.yml中有相同的属性，那么以application.properties中的值为准，一旦加载到对应的属性，后面就会跳过，不会覆盖前面加载的属性值。

    针对application.yml，实现类是YamlPropertySourceLoader

    1. public class YamlPropertySourceLoader implements PropertySourceLoader {
    2.     public YamlPropertySourceLoader() {}
    3.  
    4.     public String[] getFileExtensions() {
    5.         return new String[]{"yml", "yaml"};
    6.     }
    7.  
    8.     public List> load(String name, Resource resource) throws IOException {
    9.         if (!ClassUtils.isPresent("org.yaml.snakeyaml.Yaml", this.getClass().getClassLoader())) {
    10.             throw new IllegalStateException("Attempted to load " + name + " but snakeyaml was not found on the classpath");
    11.         } else {
    12.             List> loaded = (new OriginTrackedYamlLoader(resource)).load();
    13.             if (loaded.isEmpty()) {
    14.                 return Collections.emptyList();
    15.             } else {
    16.                 List> propertySources = new ArrayList(loaded.size());
    17.  
    18.                 for(int i = 0; i < loaded.size(); ++i) {
    19.                     String documentNumber = loaded.size() != 1 ? " (document #" + i + ")" : "";
    20.                     propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber, Collections.unmodifiableMap((Map)loaded.get(i)), true));
    21.                 }
    22.  
    23.                 return propertySources;
    24.             }
    25.         }
    26.     }
    27. }

    针对application.properties，实现类是PropertiesPropertySourceLoader

    1. public class PropertiesPropertySourceLoader implements PropertySourceLoader {
    2.     private static final String XML_FILE_EXTENSION = ".xml";
    3.  
    4.     public PropertiesPropertySourceLoader() {}
    5.  
    6.     public String[] getFileExtensions() {
    7.         return new String[]{"properties", "xml"};
    8.     }
    9.  
    10.     public List> load(String name, Resource resource) throws IOException {
    11.         List> properties = this.loadProperties(resource);
    12.         if (properties.isEmpty()) {
    13.             return Collections.emptyList();
    14.         } else {
    15.             List> propertySources = new ArrayList(properties.size());
    16.  
    17.             for(int i = 0; i < properties.size(); ++i) {
    18.                 String documentNumber = properties.size() != 1 ? " (document #" + i + ")" : "";
    19.                 propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber, Collections.unmodifiableMap((Map)properties.get(i)), true));
    20.             }
    21.  
    22.             return propertySources;
    23.         }
    24.     }
    25.  
    26.     private List> loadProperties(Resource resource) throws IOException {
    27.         String filename = resource.getFilename();
    28.         List> result = new ArrayList();
    29.         if (filename != null && filename.endsWith(".xml")) {
    30.             result.add(PropertiesLoaderUtils.loadProperties(resource));
    31.         } else {
    32.             List documents = (new OriginTrackedPropertiesLoader(resource)).load();
    33.             documents.forEach((document) -> {
    34.                 result.add(document.asMap());
    35.             });
    36.         }
    37.  
    38.         return result;
    39.     }
    40. }
    1. public final class ConfigurationPropertySources {
    2.     private static final String ATTACHED_PROPERTY_SOURCE_NAME = "configurationProperties";
    3.  
    4.     public static void attach(Environment environment) {
    5.         Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
    6.         MutablePropertySources sources = ((ConfigurableEnvironment)environment).getPropertySources();
    7.         PropertySource attached = getAttached(sources);
    8.         if (attached == null || !isUsingSources((PropertySource)attached, sources)) {
    9.             attached = new ConfigurationPropertySourcesPropertySource("configurationProperties", new SpringConfigurationPropertySources(sources));
    10.         }
    11.         sources.remove("configurationProperties");
    12.         // 将加载了配置文件的PropertySource添加到Environment中
    13.         sources.addFirst((PropertySource)attached);
    14.     }
    15. }

    刷新上下文容器

    1. public class ServletWebServerApplicationContext extends GenericWebApplicationContext implements ConfigurableWebServerApplicationContext {
    2.     private void refreshContext(ConfigurableApplicationContext context) {
    3.         if (this.registerShutdownHook) {
    4.             shutdownHook.registerApplicationContext(context);
    5.         }
    6.         this.refresh(context);
    7.     }
    8.  
    9.     protected void refresh(ConfigurableApplicationContext applicationContext) {
    10.         applicationContext.refresh();
    11.     }
    12. }
    1. public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    2.     public void refresh() throws BeansException, IllegalStateException {
    3.         synchronized(this.startupShutdownMonitor) {
    4.             StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    5.             this.prepareRefresh();
    6.             ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
    7.             this.prepareBeanFactory(beanFactory);
    8.  
    9.             try {
    10.                 this.postProcessBeanFactory(beanFactory);
    11.                 StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
    12.                 this.invokeBeanFactoryPostProcessors(beanFactory);
    13.                 this.registerBeanPostProcessors(beanFactory);
    14.                 beanPostProcess.end();
    15.                 this.initMessageSource();
    16.                 this.initApplicationEventMulticaster();
    17.                 this.onRefresh();
    18.                 this.registerListeners();
    19.                 this.finishBeanFactoryInitialization(beanFactory);
    20.                 this.finishRefresh();
    21.             } catch (BeansException var10) {
    22.                 if (this.logger.isWarnEnabled()) {
    23.                     this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
    24.                 }
    25.                 this.destroyBeans();
    26.                 this.cancelRefresh(var10);
    27.                 throw var10;
    28.             } finally {
    29.                 this.resetCommonCaches();
    30.                 contextRefresh.end();
    31.             }
    32.  
    33.         }
    34.     }
    35. }

    注册BeanPostProcessors，通过BeanPostProcessor修改bean的属性值

    1. public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    2.     protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    3.         PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    4.     }
    5. }
    1. public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    2.     public Object getBean(String name) throws BeansException {
    3.         return this.doGetBean(name, (Class)null, (Object[])null, false);
    4.     }
    5.  
    6.     protected  T doGetBean(String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    7.                 if (mbd.isSingleton()) {
    8.                     sharedInstance = this.getSingleton(beanName, () -> {
    9.                         try {
    10.                             return this.createBean(beanName, mbd, args);
    11.                         } catch (BeansException var5) {
    12.                             this.destroySingleton(beanName);
    13.                             throw var5;
    14.                         }
    15.                     });
    16.                     beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    17.                 }
    18.     }
    19. }
    1. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    2.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    3.         beanInstance = this.doCreateBean(beanName, mbdToUse, args);
    4.         return beanInstance;
    5.     }
    6.  
    7.     protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    8.         this.populateBean(beanName, mbd, instanceWrapper);
    9.     }
    10.  
    11.     protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    12.         PropertyValues pvsToUse;
    13.         for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {
    14.             InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
    15.             pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
    16.             if (pvsToUse == null) {
    17.                 if (filteredPds == null) {
    18.                     filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    19.                 }
    20.                 pvsToUse = bp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
    21.                 if (pvsToUse == null) {
    22.                     return;
    23.                 }
    24.             }
    25.         }
    26.     }
    27. }

    通过BeanPostProcessor注入bean的属性

    1. public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    2.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    3.         InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);
    4.  
    5.         try {
    6.             metadata.inject(bean, beanName, pvs);
    7.             return pvs;
    8.         } catch (BeanCreationException var6) {
    9.             throw var6;
    10.         } catch (Throwable var7) {
    11.             throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
    12.         }
    13.     }
    14. }
    1. public class InjectionMetadata {
    2.     public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    3.         Collection checkedElements = this.checkedElements;
    4.         Collection elementsToIterate = checkedElements != null ? checkedElements : this.injectedElements;
    5.         if (!((Collection)elementsToIterate).isEmpty()) {
    6.             Iterator var6 = ((Collection)elementsToIterate).iterator();
    7.  
    8.             while(var6.hasNext()) {
    9.                 InjectionMetadata.InjectedElement element = (InjectionMetadata.InjectedElement)var6.next();
    10.                 element.inject(target, beanName, pvs);
    11.             }
    12.         }
    13.     }
    14. }

    AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(bean, beanName, pvs) -> resolveFieldValue(field, bean, beanName) ->

    bean属性注入

    1.         protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    2.             Field field = (Field)this.member;
    3.             Object value;
    4.             if (this.cached) {
    5.                 try {
    6.                     value = AutowiredAnnotationBeanPostProcessor.this.resolvedCachedArgument(beanName, this.cachedFieldValue);
    7.                 } catch (NoSuchBeanDefinitionException var7) {
    8.                     value = this.resolveFieldValue(field, bean, beanName);
    9.                 }
    10.             } else {
    11.                 // 获取字段@Value对应的值
    12.                 value = this.resolveFieldValue(field, bean, beanName);
    13.             }
    14.  
    15.             if (value != null) {
    16.                 ReflectionUtils.makeAccessible(field);
    17.                 // 通过反射给目标字段赋值
    18.                 field.set(bean, value);
    19.             }
    20.         }

    获取字段的值

    1.         @Nullable
    2.         private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
    3.             DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    4.             desc.setContainingClass(bean.getClass());
    5.             Set autowiredBeanNames = new LinkedHashSet(1);
    6.             Assert.state(AutowiredAnnotationBeanPostProcessor.this.beanFactory != null, "No BeanFactory available");
    7.             TypeConverter typeConverter = AutowiredAnnotationBeanPostProcessor.this.beanFactory.getTypeConverter();
    8.  
    9.             Object value;
    10.             try {
    11.                 // 获取字段依赖的属性值
    12.                 value = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    13.             } catch (BeansException var12) {
    14.                 throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(field), var12);
    15.             }
    16.  
    17.             synchronized(this) {
    18.                 if (!this.cached) {
    19.                     Object cachedFieldValue = null;
    20.                     if (value != null || this.required) {
    21.                         cachedFieldValue = desc;
    22.                         AutowiredAnnotationBeanPostProcessor.this.registerDependentBeans(beanName, autowiredBeanNames);
    23.                         if (autowiredBeanNames.size() == 1) {
    24.                             String autowiredBeanName = (String)autowiredBeanNames.iterator().next();
    25.                             if (AutowiredAnnotationBeanPostProcessor.this.beanFactory.containsBean(autowiredBeanName) && AutowiredAnnotationBeanPostProcessor.this.beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
    26.                                 cachedFieldValue = new AutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());
    27.                             }
    28.                         }
    29.                     }
    30.  
    31.                     this.cachedFieldValue = cachedFieldValue;
    32.                     this.cached = true;
    33.                 }
    34.  
    35.                 return value;
    36.             }
    37.         }

    获取注入依赖

    1. public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    2.     @Nullable
    3.     public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    4.         descriptor.initParameterNameDiscovery(this.getParameterNameDiscoverer());
    5.         if (Optional.class == descriptor.getDependencyType()) {
    6.             return this.createOptionalDependency(descriptor, requestingBeanName);
    7.         } else if (ObjectFactory.class != descriptor.getDependencyType() && ObjectProvider.class != descriptor.getDependencyType()) {
    8.             if (javaxInjectProviderClass == descriptor.getDependencyType()) {
    9.                 return (new DefaultListableBeanFactory.Jsr330Factory()).createDependencyProvider(descriptor, requestingBeanName);
    10.             } else {
    11.                 Object result = this.getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
    12.                 if (result == null) {
    13.                     result = this.doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
    14.                 }
    15.  
    16.                 return result;
    17.             }
    18.         } else {
    19.             return new DefaultListableBeanFactory.DependencyObjectProvider(descriptor, requestingBeanName);
    20.         }
    21.     }
    22. }
    1.     @Nullable
    2.     public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    3.         InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    4.  
    5.         Object var23;
    6.         try {
    7.             Object shortcut = descriptor.resolveShortcut(this);
    8.             if (shortcut != null) {
    9.                 Object var20 = shortcut;
    10.                 return var20;
    11.             }
    12.  
    13.             Class type = descriptor.getDependencyType();
    14.             Object value = this.getAutowireCandidateResolver().getSuggestedValue(descriptor);
    15.             Object var11;
    16.             if (value == null) {
    17.                 Object multipleBeans = this.resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
    18.                 if (multipleBeans != null) {
    19.                     var23 = multipleBeans;
    20.                     return var23;
    21.                 }
    22.  
    23.                 Map matchingBeans = this.findAutowireCandidates(beanName, type, descriptor);
    24.                 if (matchingBeans.isEmpty()) {
    25.                     if (this.isRequired(descriptor)) {
    26.                         this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    27.                     }
    28.                     var11 = null;
    29.                     return var11;
    30.                 }
    31.  
    32.                 Object instanceCandidate;
    33.                 Object result;
    34.                 String autowiredBeanName;
    35.                 if (matchingBeans.size() > 1) {
    36.                     autowiredBeanName = this.determineAutowireCandidate(matchingBeans, descriptor);
    37.                     if (autowiredBeanName == null) {
    38.                         if (!this.isRequired(descriptor) && this.indicatesMultipleBeans(type)) {
    39.                             result = null;
    40.                             return result;
    41.                         }
    42.                         result = descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
    43.                         return result;
    44.                     }
    45.  
    46.                     instanceCandidate = matchingBeans.get(autowiredBeanName);
    47.                 } else {
    48.                     Entry entry = (Entry)matchingBeans.entrySet().iterator().next();
    49.                     autowiredBeanName = (String)entry.getKey();
    50.                     instanceCandidate = entry.getValue();
    51.                 }
    52.  
    53.                 if (autowiredBeanNames != null) {
    54.                     autowiredBeanNames.add(autowiredBeanName);
    55.                 }
    56.                 if (instanceCandidate instanceof Class) {
    57.                     instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
    58.                 }
    59.  
    60.                 result = instanceCandidate;
    61.                 if (instanceCandidate instanceof NullBean) {
    62.                     if (this.isRequired(descriptor)) {
    63.                         this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
    64.                     }
    65.                     result = null;
    66.                 }
    67.  
    68.                 if (!ClassUtils.isAssignableValue(type, result)) {
    69.                     throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
    70.                 }
    71.                 Object var14 = result;
    72.                 return var14;
    73.             }
    74.  
    75.             if (value instanceof String) {
    76.                 // 获取bean注入的属性值
    77.                 String strVal = this.resolveEmbeddedValue((String)value);
    78.                 BeanDefinition bd = beanName != null && this.containsBean(beanName) ? this.getMergedBeanDefinition(beanName) : null;
    79.                 value = this.evaluateBeanDefinitionString(strVal, bd);
    80.             }
    81.  
    82.             TypeConverter converter = typeConverter != null ? typeConverter : this.getTypeConverter();
    83.             try {
    84.                 var23 = converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
    85.             } catch (UnsupportedOperationException var18) {
    86.                 var11 = descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter());
    87.                 return var11;
    88.             }
    89.         } finally {
    90.             ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    91.         }
    92.  
    93.         return var23;
    94.     }

    AbstractBeanFactory.resolveEmbeddedValue(value)

    根据@Value注解的key获取对应的值

    1. public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    2.     @Nullable
    3.     public String resolveEmbeddedValue(@Nullable String value) {
    4.         if (value == null) {
    5.             return null;
    6.         } else {
    7.             String result = value;
    8.             Iterator var3 = this.embeddedValueResolvers.iterator();
    9.  
    10.             do {
    11.                 if (!var3.hasNext()) {
    12.                     return result;
    13.                 }
    14.  
    15.                 StringValueResolver resolver = (StringValueResolver)var3.next();
    16.                 result = resolver.resolveStringValue(result);
    17.             } while(result != null);
    18.  
    19.             return null;
    20.         }
    21.     }
    22. }

    最后通过反射给目标字段赋值

    1. public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    2.     private class AutowiredFieldElement extends InjectedElement {
    3.         protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    4.             Field field = (Field)this.member;
    5.             Object value;
    6.             if (this.cached) {
    7.                 try {
    8.                     value = AutowiredAnnotationBeanPostProcessor.this.resolvedCachedArgument(beanName, this.cachedFieldValue);
    9.                 } catch (NoSuchBeanDefinitionException var7) {
    10.                     value = this.resolveFieldValue(field, bean, beanName);
    11.                 }
    12.             } else {
    13.                 // 获取字段@Value对应的值
    14.                 value = this.resolveFieldValue(field, bean, beanName);
    15.             }
    16.  
    17.             if (value != null) {
    18.                 ReflectionUtils.makeAccessible(field);
    19.                 // 通过反射给目标字段赋值
    20.                 field.set(bean, value);
    21.             }
    22.         }
    23.     }
    24. }

    field.set(bean, value);

    1. public final class Field extends AccessibleObject implements Member {
    2.     @CallerSensitive
    3.     public void set(Object obj, Object value)
    4.         throws IllegalArgumentException, IllegalAccessException
    5.     {
    6.         if (!override) {
    7.             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
    8.                 Class caller = Reflection.getCallerClass();
    9.                 checkAccess(caller, clazz, obj, modifiers);
    10.             }
    11.         }
    12.         getFieldAccessor(obj).set(obj, value);
    13.     }
    14. }

  • 相关阅读:
    低代码工具大比拼：哪个最适合你？
    Rust常用特型之From和Into特型
    如何安装 Elasticsearch
    ionic Execution failed for task ‘:processDebugResources‘.
    规则引擎go
    免费分享一套SpringBoot+Vue农产品在线销售(在线商城)管理系统【论文+源码+SQL脚本】，帅呆了~~
    神经网络做预测的原理,神经网络预测空气质量
    线性表顺序存储结构--(Java)
    MySQL主从复制
    Java高性能本地缓存框架Caffeine
  • 原文地址：https://blog.csdn.net/luciferlongxu/article/details/126474919