org.springframework.beans.factory.support

Class PropertiesBeanDefinitionReader

  • All Implemented Interfaces:
    BeanDefinitionReader, EnvironmentCapable


    public class PropertiesBeanDefinitionReader
    extends AbstractBeanDefinitionReader
    Bean definition reader for a simple properties format.

    Provides bean definition registration methods for Map/Properties and ResourceBundle. Typically applied to a DefaultListableBeanFactory.

    Example:

     employee.(class)=MyClass       // bean is of class MyClass
     employee.(abstract)=true       // this bean can't be instantiated directly
     employee.group=Insurance       // real property
     employee.usesDialUp=false      // real property (potentially overridden)
    
     salesrep.(parent)=employee     // derives from "employee" bean definition
     salesrep.(lazy-init)=true      // lazily initialize this singleton bean
     salesrep.manager(ref)=tony     // reference to another bean
     salesrep.department=Sales      // real property
    
     techie.(parent)=employee       // derives from "employee" bean definition
     techie.(scope)=prototype       // bean is a prototype (not a shared instance)
     techie.manager(ref)=jeff       // reference to another bean
     techie.department=Engineering  // real property
     techie.usesDialUp=true         // real property (overriding parent value)
    
     ceo.$0(ref)=secretary          // inject 'secretary' bean as 0th constructor arg
     ceo.$1=1000000                 // inject value '1000000' at 1st constructor arg
     
    Since:
    26.11.2003
    Author:
    Rod Johnson, Juergen Hoeller, Rob Harrop
    See Also:
    DefaultListableBeanFactory
    • Field Detail

      • TRUE_VALUE

        public static final java.lang.String TRUE_VALUE
        Value of a T/F attribute that represents true. Anything else represents false. Case seNsItive.
        See Also:
        Constant Field Values
      • SEPARATOR

        public static final java.lang.String SEPARATOR
        Separator between bean name and property name. We follow normal Java conventions.
        See Also:
        Constant Field Values
      • CLASS_KEY

        public static final java.lang.String CLASS_KEY
        Special key to distinguish owner.(class)=com.myapp.MyClass.
        See Also:
        Constant Field Values
      • PARENT_KEY

        public static final java.lang.String PARENT_KEY
        Special key to distinguish owner.(parent)=parentBeanName.
        See Also:
        Constant Field Values
      • SCOPE_KEY

        public static final java.lang.String SCOPE_KEY
        Special key to distinguish owner.(scope)=prototype. Default is "true".
        See Also:
        Constant Field Values
      • SINGLETON_KEY

        public static final java.lang.String SINGLETON_KEY
        Special key to distinguish owner.(singleton)=false. Default is "true".
        See Also:
        Constant Field Values
      • ABSTRACT_KEY

        public static final java.lang.String ABSTRACT_KEY
        Special key to distinguish owner.(abstract)=true Default is "false".
        See Also:
        Constant Field Values
      • LAZY_INIT_KEY

        public static final java.lang.String LAZY_INIT_KEY
        Special key to distinguish owner.(lazy-init)=true Default is "false".
        See Also:
        Constant Field Values
      • REF_SUFFIX

        public static final java.lang.String REF_SUFFIX
        Property suffix for references to other beans in the current BeanFactory: e.g. owner.dog(ref)=fido. Whether this is a reference to a singleton or a prototype will depend on the definition of the target bean.
        See Also:
        Constant Field Values
      • REF_PREFIX

        public static final java.lang.String REF_PREFIX
        Prefix before values referencing other beans.
        See Also:
        Constant Field Values
      • CONSTRUCTOR_ARG_PREFIX

        public static final java.lang.String CONSTRUCTOR_ARG_PREFIX
        Prefix used to denote a constructor argument definition.
        See Also:
        Constant Field Values
    • Constructor Detail

      • PropertiesBeanDefinitionReader

        public PropertiesBeanDefinitionReader(BeanDefinitionRegistry registry)
        Create new PropertiesBeanDefinitionReader for the given bean factory.
        Parameters:
        registry - the BeanFactory to load bean definitions into, in the form of a BeanDefinitionRegistry
    • Method Detail

      • setDefaultParentBean

        public void setDefaultParentBean(@Nullable
                                         java.lang.String defaultParentBean)
        Set the default parent bean for this bean factory. If a child bean definition handled by this factory provides neither a parent nor a class attribute, this default value gets used.

        Can be used e.g. for view definition files, to define a parent with a default view class and common attributes for all views. View definitions that define their own parent or carry their own class can still override this.

        Strictly speaking, the rule that a default parent setting does not apply to a bean definition that carries a class is there for backwards compatibility reasons. It still matches the typical use case.

      • getDefaultParentBean

        @Nullable
        public java.lang.String getDefaultParentBean()
        Return the default parent bean for this bean factory.
      • getPropertiesPersister

        public PropertiesPersister getPropertiesPersister()
        Return the PropertiesPersister to use for parsing properties files.
      • loadBeanDefinitions

        public int loadBeanDefinitions(Resource resource,
                                       @Nullable
                                       java.lang.String prefix)
                                throws BeanDefinitionStoreException
        Load bean definitions from the specified properties file.
        Parameters:
        resource - the resource descriptor for the properties file
        prefix - a filter within the keys in the map: e.g. 'beans.' (can be empty or null)
        Returns:
        the number of bean definitions found
        Throws:
        BeanDefinitionStoreException - in case of loading or parsing errors
      • loadBeanDefinitions

        public int loadBeanDefinitions(EncodedResource encodedResource)
                                throws BeanDefinitionStoreException
        Load bean definitions from the specified properties file.
        Parameters:
        encodedResource - the resource descriptor for the properties file, allowing to specify an encoding to use for parsing the file
        Returns:
        the number of bean definitions found
        Throws:
        BeanDefinitionStoreException - in case of loading or parsing errors
      • loadBeanDefinitions

        public int loadBeanDefinitions(EncodedResource encodedResource,
                                       @Nullable
                                       java.lang.String prefix)
                                throws BeanDefinitionStoreException
        Load bean definitions from the specified properties file.
        Parameters:
        encodedResource - the resource descriptor for the properties file, allowing to specify an encoding to use for parsing the file
        prefix - a filter within the keys in the map: e.g. 'beans.' (can be empty or null)
        Returns:
        the number of bean definitions found
        Throws:
        BeanDefinitionStoreException - in case of loading or parsing errors
      • registerBeanDefinitions

        public int registerBeanDefinitions(java.util.ResourceBundle rb,
                                           @Nullable
                                           java.lang.String prefix)
                                    throws BeanDefinitionStoreException
        Register bean definitions contained in a ResourceBundle.

        Similar syntax as for a Map. This method is useful to enable standard Java internationalization support.

        Parameters:
        rb - the ResourceBundle to load from
        prefix - a filter within the keys in the map: e.g. 'beans.' (can be empty or null)
        Returns:
        the number of bean definitions found
        Throws:
        BeanDefinitionStoreException - in case of loading or parsing errors
      • registerBeanDefinitions

        public int registerBeanDefinitions(java.util.Map<?,?> map)
                                    throws BeansException
        Register bean definitions contained in a Map, using all property keys (i.e. not filtering by prefix).
        Parameters:
        map - a map of name to property (String or Object). Property values will be strings if coming from a Properties file etc. Property names (keys) must be Strings. Class keys must be Strings.
        Returns:
        the number of bean definitions found
        Throws:
        BeansException - in case of loading or parsing errors
        See Also:
        registerBeanDefinitions(java.util.Map, String, String)
      • registerBeanDefinitions

        public int registerBeanDefinitions(java.util.Map<?,?> map,
                                           @Nullable
                                           java.lang.String prefix)
                                    throws BeansException
        Register bean definitions contained in a Map. Ignore ineligible properties.
        Parameters:
        map - a map of name to property (String or Object). Property values will be strings if coming from a Properties file etc. Property names (keys) must be Strings. Class keys must be Strings.
        prefix - a filter within the keys in the map: e.g. 'beans.' (can be empty or null)
        Returns:
        the number of bean definitions found
        Throws:
        BeansException - in case of loading or parsing errors
      • registerBeanDefinitions

        public int registerBeanDefinitions(java.util.Map<?,?> map,
                                           @Nullable
                                           java.lang.String prefix,
                                           java.lang.String resourceDescription)
                                    throws BeansException
        Register bean definitions contained in a Map. Ignore ineligible properties.
        Parameters:
        map - a map of name to property (String or Object). Property values will be strings if coming from a Properties file etc. Property names (keys) must be Strings. Class keys must be Strings.
        prefix - a filter within the keys in the map: e.g. 'beans.' (can be empty or null)
        resourceDescription - description of the resource that the Map came from (for logging purposes)
        Returns:
        the number of bean definitions found
        Throws:
        BeansException - in case of loading or parsing errors
        See Also:
        registerBeanDefinitions(Map, String)
      • registerBeanDefinition

        protected void registerBeanDefinition(java.lang.String beanName,
                                              java.util.Map<?,?> map,
                                              java.lang.String prefix,
                                              java.lang.String resourceDescription)
                                       throws BeansException
        Get all property values, given a prefix (which will be stripped) and add the bean they define to the factory with the given name.
        Parameters:
        beanName - name of the bean to define
        map - a Map containing string pairs
        prefix - prefix of each entry, which will be stripped
        resourceDescription - description of the resource that the Map came from (for logging purposes)
        Throws:
        BeansException - if the bean definition could not be parsed or registered