org.springframework.beans.factory.support

## Class PropertiesBeanDefinitionReader

- java.lang.Object
- - org.springframework.beans.factory.support.AbstractBeanDefinitionReader
  - - org.springframework.beans.factory.support.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 Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `ABSTRACT_KEY` Special key to distinguish `owner.(abstract)=true` Default is "false".
    `static String` | `CLASS_KEY` Special key to distinguish `owner.(class)=com.myapp.MyClass`-
    `static String` | `CONSTRUCTOR_ARG_PREFIX` Prefix used to denote a constructor argument definition.
    `static String` | `LAZY_INIT_KEY` Special key to distinguish `owner.(lazy-init)=true` Default is "false".
    `static String` | `PARENT_KEY` Special key to distinguish `owner.(parent)=parentBeanName`.
    `static String` | `REF_PREFIX` Prefix before values referencing other beans.
    `static String` | `REF_SUFFIX` Property suffix for references to other beans in the current BeanFactory: e.g.
    `static String` | `SCOPE_KEY` Special key to distinguish `owner.(scope)=prototype`.
    `static String` | `SEPARATOR` Separator between bean name and property name.
    `static String` | `SINGLETON_KEY` Special key to distinguish `owner.(singleton)=false`.
    `static String` | `TRUE_VALUE` Value of a T/F attribute that represents true.

    - ### Fields inherited from class org.springframework.beans.factory.support.AbstractBeanDefinitionReader

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PropertiesBeanDefinitionReader(BeanDefinitionRegistry registry)` Create new PropertiesBeanDefinitionReader for the given bean factory.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `String` | `getDefaultParentBean()` Return the default parent bean for this bean factory.
    `PropertiesPersister` | `getPropertiesPersister()` Return the PropertiesPersister to use for parsing properties files.
    `int` | `loadBeanDefinitions(EncodedResource encodedResource)` Load bean definitions from the specified properties file.
    `int` | `loadBeanDefinitions(EncodedResource encodedResource, String prefix)` Load bean definitions from the specified properties file.
    `int` | `loadBeanDefinitions(Resource resource)` Load bean definitions from the specified properties file, using all property keys (i.e.
    `int` | `loadBeanDefinitions(Resource resource, String prefix)` Load bean definitions from the specified properties file.
    `protected void` | `registerBeanDefinition(String beanName, Map<?,?> map, String prefix, String resourceDescription)` Get all property values, given a prefix (which will be stripped) and add the bean they define to the factory with the given name
    `int` | `registerBeanDefinitions(Map map)` Register bean definitions contained in a Map, using all property keys (i.e.
    `int` | `registerBeanDefinitions(Map map, String prefix)` Register bean definitions contained in a Map.
    `int` | `registerBeanDefinitions(Map map, String prefix, String resourceDescription)` Register bean definitions contained in a Map.
    `int` | `registerBeanDefinitions(ResourceBundle rb)` Register bean definitions contained in a resource bundle, using all property keys (i.e.
    `int` | `registerBeanDefinitions(ResourceBundle rb, String prefix)` Register bean definitions contained in a ResourceBundle.
    `void` | `setDefaultParentBean(String defaultParentBean)` Set the default parent bean for this bean factory.
    `void` | `setPropertiesPersister(PropertiesPersister propertiesPersister)` Set the PropertiesPersister to use for parsing properties files.

    - ### Methods inherited from class org.springframework.beans.factory.support.AbstractBeanDefinitionReader

      `getBeanClassLoader, getBeanFactory, getBeanNameGenerator, getEnvironment, getRegistry, getResourceLoader, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, setBeanClassLoader, setBeanNameGenerator, setEnvironment, setResourceLoader`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### TRUE_VALUE

          public static final 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 String SEPARATOR

      Separator between bean name and property name. We follow normal Java conventions.
      See Also:
        Constant Field Values

    - #### CLASS_KEY

          public static final String CLASS_KEY

      Special key to distinguish `owner.(class)=com.myapp.MyClass`-
      See Also:
        Constant Field Values

    - #### PARENT_KEY

          public static final String PARENT_KEY

      Special key to distinguish `owner.(parent)=parentBeanName`.
      See Also:
        Constant Field Values

    - #### SCOPE_KEY

          public static final String SCOPE_KEY

      Special key to distinguish `owner.(scope)=prototype`. Default is "true".
      See Also:
        Constant Field Values

    - #### SINGLETON_KEY

          public static final String SINGLETON_KEY

      Special key to distinguish `owner.(singleton)=false`. Default is "true".
      See Also:
        Constant Field Values

    - #### ABSTRACT_KEY

          public static final String ABSTRACT_KEY

      Special key to distinguish `owner.(abstract)=true` Default is "false".
      See Also:
        Constant Field Values

    - #### LAZY_INIT_KEY

          public static final 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 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 String REF_PREFIX

      Prefix before values referencing other beans.
      See Also:
        Constant Field Values

    - #### CONSTRUCTOR_ARG_PREFIX

          public static final 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(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 compatiblity reasons. It still matches the typical use case.

    - #### getDefaultParentBean

          public String getDefaultParentBean()

      Return the default parent bean for this bean factory.

    - #### setPropertiesPersister

          public void setPropertiesPersister(PropertiesPersister propertiesPersister)

      Set the PropertiesPersister to use for parsing properties files. The default is DefaultPropertiesPersister.
      See Also:
        `DefaultPropertiesPersister`

    - #### getPropertiesPersister

          public PropertiesPersister getPropertiesPersister()

      Return the PropertiesPersister to use for parsing properties files.

    - #### loadBeanDefinitions

          public int loadBeanDefinitions(Resource resource)
                                  throws BeanDefinitionStoreException

      Load bean definitions from the specified properties file, using all property keys (i.e. not filtering by prefix).
      Parameters:
        `resource` - the resource descriptor for the properties file
      Returns:
        the number of bean definitions found
      Throws:
        `BeanDefinitionStoreException` - in case of loading or parsing errors
      See Also:
        `loadBeanDefinitions(org.springframework.core.io.Resource, String)`

    - #### loadBeanDefinitions

          public int loadBeanDefinitions(Resource resource,
                                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,
                                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(ResourceBundle rb)
                                      throws BeanDefinitionStoreException

      Register bean definitions contained in a resource bundle, using all property keys (i.e. not filtering by prefix).
      Parameters:
        `rb` - the ResourceBundle to load from
      Returns:
        the number of bean definitions found
      Throws:
        `BeanDefinitionStoreException` - in case of loading or parsing errors
      See Also:
        `registerBeanDefinitions(java.util.ResourceBundle, String)`

    - #### registerBeanDefinitions

          public int registerBeanDefinitions(ResourceBundle rb,
                                    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(Map map)
                                      throws BeansException

      Register bean definitions contained in a Map, using all property keys (i.e. not filtering by prefix).
      Parameters:
        `map` - Map: name -> 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(Map map,
                                    String prefix)
                                      throws BeansException

      Register bean definitions contained in a Map. Ignore ineligible properties.
      Parameters:
        `map` - Map name -> 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(Map map,
                                    String prefix,
                                    String resourceDescription)
                                      throws BeansException

      Register bean definitions contained in a Map. Ignore ineligible properties.
      Parameters:
        `map` - Map name -> 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(String beanName,
                                    Map<?,?> map,
                                    String prefix,
                                    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` - 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