## 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

    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
`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
`PropertiesBeanDefinitionReader(BeanDefinitionRegistry registry)` Create new PropertiesBeanDefinitionReader for the given bean factory.

Method Summary
`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, getRegistry, getResourceLoader, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, setBeanClassLoader, setBeanNameGenerator, 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