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