Spring 注入

  • Spring注入
  1. Spring Bean生命周期
  2. PlaceholderConfigurer
  3. SpringEL

Spring Bean生命周期

 

 

在Spring容器(BeanFactory)创建后,就需要开始了Bean创建。Bean创建又分为两个阶段:

1) 准备Bean定义

在所有的Bean创建之前,由BeanFactoryPostProcessor创建一个PlaceholderConfiguer(3.1之前是PropertyPlaceholderConfiguer,之后是PropertySourcesPlaceholderConfigurer)。这个PlaceholderConfiguer用于将Bean定义中引用的属性${}进行替换。

 

       这个过程是在BeanFactoryPostProcessor#postProcessBeforeInstantation()中完成。

 

2)创建Bean并使用BeanPostProcessor对Bean进行注入

2.1在此阶段,因为需要对每一个新创建的Bean进行属性注入,所以 要先创建BeanPostProcessor对象,因为Spring要支持自动注入,所以最终创建的是一个AutowiredAnnotationBeanPostProcessor对象。

 

2.2接下来根据Bean定义一个一个的创建Bean。

2.2.1 在Bean对象创建完后,就使用AutowiredAnnotationBeanPostProcessor # postProcessPropertyValues() 进行注入。

这个过程其实是根据类中的@Autowired,@Value,@Inject,@Resource 进行注入。

注入的时候,必然会从BeanFactory中获取依赖,获取属性配置等。特别是在使用@Value的注入,还会触发Spring EL 解析,取值操作。

 

获取依赖值后,使用反射方式注入。

2.2.2 BeanPostProcessor#postProcessBeforeInitialization()

该过程调用的是 @PostConstruct

2.2.2 InitializingBean#afterProperties()

2.2.3 XML(init-method)

 

PlaceholderConfigurer

        在Bean定义的准备阶段,会使用PlaceholderConfigurer对Bean定义中的占位符进行替换。

PlaceholderConfigurer目前有两个版本:Spring 3.1之前使用的是PropertyPlaceholderConfiguer,之后使用的是PropertySourcesPlaceholderConfigurer,后者比前者更具扩展性。

   当你在applicationContext.xml中使用了<context:property-placeholder>时,Spring就会自动的根据applicationContext.xml中引用的spring-context-VERSION.xsd版本来自动创建实现。此外,不论使用哪种实现,都只会创建一个实例,所以配置多个会无效的。

 

 

 

PropertyPlaceholderConfigurer 

PropertyPlaceholderConfigurer
    postProcessBeanFactory:
        // 把多个配置文件合并到一个Properties集合中。
        Properties mergedProps = mergeProperties();
        // Convert the merged properties, if necessary.
        convertProperties(mergedProps);
        // Let the subclass process the properties.
        processProperties(beanFactory, mergedProps):
            replace bean define 's placeholder
            当替换placeholder时,会从mergedProps 和(或)systemProperties中找对应的值。
            虽然默认是会从systemProperties找的,但是从systemProperties中找并不是必须的,
            如果不想从systemProperties中找,需要调用PropertyPlaceholderConfigurer#setSearchSystemEnvironment(false)
            如果会从systemProperties中找的话,
            顺序是:
            protected String resolvePlaceholder(String placeholder, Properties props, int systemPropertiesMode) {
                String propVal = null;
                if (systemPropertiesMode == 2) {
                    propVal = resolveSystemProperty(placeholder);
                }
                if (propVal == null) {
                    propVal = resolvePlaceholder(placeholder, props);
                }
                if (propVal == null && systemPropertiesMode == 1) {
                    propVal = resolveSystemProperty(placeholder); // 从系统属性找,不包含操作系统的环境变量
                }
                return propVal;
            }

            systemPropertiesMode 的默认值是1,即默认是 配置文件优先,然后才是systemProperties

 

支持:指定location, system properties, OS environment variables。  

 

PropertySourcePlaceholderConfigurer

 

从3.1开始,在applicationContext.xml中指定<context:property-placeholder>,不会再生成PropertyPlaceholderConfigurer对象了,而是生成
PropertySourcesPlaceholderConfigurer对象。
这两个类的作用是一样的,都是用来替换 bean define中的占位符的。而PropertySourcesPlaceholderConfigurer的大概结构是:

    
class PropertySourcesPlaceholderConfigurer {
    private Properties localProperties;
    private Resource[] locations;
    private boolean localOverride = false; // 默认是false
    private Environment environment;
    private PropertySources propertySources;

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        if (this.propertySources == null) {
                // 创建propertySources
            this.propertySources = new MutablePropertySources();
            // 把Environment添加到 propertySources
            // Environment 默认包括:command line arguments, systemProperties, environment variables
            if (this.environment != null) {
                this.propertySources.addLast(
                    new PropertySource<Environment>(ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME, this.environment) {
                        @Override
                        public String getProperty(String key) {
                            return this.source.getProperty(key);
                        }
                    }
                );
            }
            try {
                // localPropertySource 是  localProperties 与 locations 合并的产物,具体参见mergeProperties()
                // 如果localOverride ==true, 则 localPropertySource 优先于 Environment ,
                // 否则 Environment 优先于 localPropertySource,
                PropertySource<?> localPropertySource =
                    new PropertiesPropertySource(LOCAL_PROPERTIES_PROPERTY_SOURCE_NAME, mergeProperties());
                if (this.localOverride) {
                    this.propertySources.addFirst(localPropertySource);
                }
                else {
                    this.propertySources.addLast(localPropertySource);
                }
            }
            catch (IOException ex) {
                throw new BeanInitializationException("Could not load properties", ex);
            }
        }
        
        // 替换占位符
        processProperties(beanFactory, new PropertySourcesPropertyResolver(this.propertySources));
    }

    protected Properties mergeProperties() throws IOException {
        Properties result = new Properties();

        if (this.localOverride) {
            // Load properties from file upfront, to let local properties override.
            loadProperties(result);
        }

        if (this.localProperties != null) {
            for (Properties localProp : this.localProperties) {
                CollectionUtils.mergePropertiesIntoMap(localProp, result);
            }
        }

        if (!this.localOverride) {
            // Load properties from file afterwards, to let those properties override.
            loadProperties(result);
        }

        return result;
    }
}

 


引入了PropertySource, Environment的概念。一个PropertySource可以是一个Properties对象,可以是一个.properties文件等,java的系统属性、操作系统的环境变量、Java程序的command line 参数等,都可以视为一个PropertSource。 

 

每一个PropertySource都有一个名字,作为整个PropertySource的标识。

 

Environment提供了一个运行环境的概念,特别是在Spring Boot中,将其运用的出神入化。它其实又是多个PropertySource的集合。

StandardEnvironment中,会将系统属性和操作系统环境分别转换为一个PropertySource,作为内置。

其中系统属性被转为名为systemProperties的PropertySource,环境变量被转为systemEnvironment的PropertySource。

 

SpringEL访问

Spring中的表达式可以分为两大类:\${}, #{}。其中 \${}就是上面通过PlaceholerConfiger进行替换的。而#{}则是Spring的EL系统,它类似于OGNL等。

SpringEL是建立在Spring容器之上的,所以在解析SpringEL时,必然会支持要对容器、环境配置的访问。

一个Spring EL的解析是由StandardBeanExpressionResolver来完成的:

StandardBeanExpressionResolver#evaluate :
    它内部由一堆的PropertyAccessor, 由这些属性访问器来从对象导航读取值
    取值顺序:
        1)ReflectivePropertyAccessor ,且它是优先使用getter, setter, 找不到才是 通过field反射。可以对对象的字段进行read-write
        2)BeanExpressionContextAccessor 从Spring EL的 context(也就是BeanExpressionContext)获取, read-only
        3)BeanFactoryAccessor    从BeanFactory(Spring Bean 容器)获取依赖等
        4)MapAccessor 访问Java.util.Map 对象,基于key来读取值
        5)EnvironmentAccessor 访问Spring Environment ,从Environment读取值
        

 

和${}一样,#{}既可以在xml中使用,也可以在@Value中使用。

上面已经说了@Value会在Bean创建后注入属性时使用到,那么也就是说在注入属性时会触发Spring EL的解析。

 

想要了解更多SpEL,参见:

https://docs.spring.io/spring/docs/4.3.19.BUILD-SNAPSHOT/spring-framework-reference/htmlsingle/#expressions

 

posted @ 2018-07-14 16:06 FangJinuo 阅读(...) 评论(...) 编辑 收藏